def ReadAllAuditEvents(self, cursor=None):
"""Reads all audit events stored in the database."""
cursor.execute("""
SELECT username, urn, client_id, timestamp, details
FROM audit_event
ORDER BY timestamp
""")
result = []
for username, urn, client_id, timestamp, details in cursor.fetchall():
event = rdf_events.AuditEvent.FromSerializedString(details)
event.user = username
if urn:
event.urn = rdfvalue.RDFURN(urn)
if client_id is not None:
event.client = rdf_client.ClientURN(
mysql_utils.IntToClientID(client_id))
event.timestamp = mysql_utils.MysqlToRDFDatetime(timestamp)
result.append(event)
return result
def ListClientsForKeywords(self, keywords, start_time=None, cursor=None):
"""Lists the clients associated with keywords."""
keywords = set(keywords)
keyword_mapping = {utils.SmartUnicode(kw): kw for kw in keywords}
result = {}
for kw in itervalues(keyword_mapping):
result[kw] = []
query = (
"SELECT DISTINCT keyword, client_id FROM client_keywords WHERE "
"keyword IN ({})".format(",".join(["%s"] * len(keyword_mapping))))
args = list(iterkeys(keyword_mapping))
if start_time:
query += " AND timestamp >= %s"
args.append(mysql_utils.RDFDatetimeToMysqlString(start_time))
cursor.execute(query, args)
for kw, cid in cursor.fetchall():
result[keyword_mapping[kw]].append(mysql_utils.IntToClientID(cid))
return result
def ReadAllClientIDs(self, cursor=None):
"""Reads client ids for all clients in the database."""
cursor.execute("SELECT client_id FROM clients")
return [mysql_utils.IntToClientID(res[0]) for res in cursor.fetchall()]
def _ResponseToClientsFullInfo(self, response):
"""Creates a ClientFullInfo object from a database response."""
c_full_info = None
prev_cid = None
for row in response:
(cid, fs, crt, ping, clk, ip, foreman, first, last_client_ts,
last_crash_ts, last_startup_ts, client_obj, client_startup_obj,
last_startup_obj, label_owner, label_name) = row
if cid != prev_cid:
if c_full_info:
yield mysql_utils.IntToClientID(prev_cid), c_full_info
metadata = rdf_objects.ClientMetadata(
certificate=crt,
fleetspeak_enabled=fs,
first_seen=mysql_utils.MysqlToRDFDatetime(first),
ping=mysql_utils.MysqlToRDFDatetime(ping),
clock=mysql_utils.MysqlToRDFDatetime(clk),
ip=mysql_utils.StringToRDFProto(
rdf_client_network.NetworkAddress, ip),
last_foreman_time=mysql_utils.MysqlToRDFDatetime(foreman),
startup_info_timestamp=mysql_utils.MysqlToRDFDatetime(
last_startup_ts),
last_crash_timestamp=mysql_utils.MysqlToRDFDatetime(
last_crash_ts))
if client_obj is not None:
l_snapshot = rdf_objects.ClientSnapshot.FromSerializedString(
client_obj)
l_snapshot.timestamp = mysql_utils.MysqlToRDFDatetime(
last_client_ts)
l_snapshot.startup_info = rdf_client.StartupInfo.FromSerializedString(
client_startup_obj)
l_snapshot.startup_info.timestamp = l_snapshot.timestamp
else:
l_snapshot = rdf_objects.ClientSnapshot(
client_id=mysql_utils.IntToClientID(cid))
if last_startup_obj is not None:
startup_info = rdf_client.StartupInfo.FromSerializedString(
last_startup_obj)
startup_info.timestamp = mysql_utils.MysqlToRDFDatetime(
last_startup_ts)
else:
startup_info = None
prev_cid = cid
c_full_info = rdf_objects.ClientFullInfo(
metadata=metadata,
labels=[],
last_snapshot=l_snapshot,
last_startup_info=startup_info)
if label_owner and label_name:
c_full_info.labels.append(
rdf_objects.ClientLabel(name=label_name,
owner=label_owner))
if c_full_info:
yield mysql_utils.IntToClientID(prev_cid), c_full_info
def _ReadCurrentFlowInfo(self, responses, currently_available_requests,
next_request_by_flow,
responses_expected_by_request,
current_responses_by_request, cursor):
"""Reads stored data for flows we want to modify."""
flow_conditions = []
flow_args = []
req_conditions = []
req_args = []
for r in responses:
flow_conditions.append("(client_id=%s AND flow_id=%s)")
flow_args.append(mysql_utils.ClientIDToInt(r.client_id))
flow_args.append(mysql_utils.FlowIDToInt(r.flow_id))
req_conditions.append(
"(client_id=%s AND flow_id=%s AND request_id=%s)")
req_args.append(mysql_utils.ClientIDToInt(r.client_id))
req_args.append(mysql_utils.FlowIDToInt(r.flow_id))
req_args.append(r.request_id)
flow_query = ("SELECT client_id, flow_id, next_request_to_process "
"FROM flows WHERE ")
flow_query += " OR ".join(flow_conditions)
req_query = (
"SELECT client_id, flow_id, request_id, responses_expected "
"FROM flow_requests WHERE ")
req_query += " OR ".join(req_conditions)
res_query = ("SELECT client_id, flow_id, request_id, response_id "
"FROM flow_responses WHERE ")
res_query += " OR ".join(req_conditions)
cursor.execute(flow_query, flow_args)
for row in cursor.fetchall():
client_id_int, flow_id_int, next_request_to_process = row
client_id = mysql_utils.IntToClientID(client_id_int)
flow_id = mysql_utils.IntToFlowID(flow_id_int)
next_request_by_flow[(client_id,
flow_id)] = next_request_to_process
cursor.execute(req_query, req_args)
for row in cursor.fetchall():
client_id_int, flow_id_int, request_id, responses_expected = row
client_id = mysql_utils.IntToClientID(client_id_int)
flow_id = mysql_utils.IntToFlowID(flow_id_int)
request_key = (client_id, flow_id, request_id)
currently_available_requests.add(request_key)
if responses_expected:
responses_expected_by_request[request_key] = responses_expected
cursor.execute(res_query, req_args)
for row in cursor.fetchall():
client_id_int, flow_id_int, request_id, response_id = row
client_id = mysql_utils.IntToClientID(client_id_int)
flow_id = mysql_utils.IntToFlowID(flow_id_int)
request_key = (client_id, flow_id, request_id)
current_responses_by_request.setdefault(request_key,
set()).add(response_id)