def AddClientKeywords(self, client_id, keywords):
self._ValidateClientId(client_id)
if client_id not in self.metadatas:
raise db.UnknownClientError()
keywords = [utils.SmartStr(k) for k in keywords]
for k in keywords:
self.keywords.setdefault(k, {})
self.keywords[k][client_id] = rdfvalue.RDFDatetime.Now()
def WriteClientMetadata(self,
client_id,
certificate=None,
fleetspeak_enabled=None,
first_seen=None,
last_ping=None,
last_clock=None,
last_ip=None,
last_foreman=None,
last_crash=None):
self._ValidateClientId(client_id)
md = {}
if certificate is not None:
md["certificate"] = certificate
if fleetspeak_enabled is not None:
md["fleetspeak_enabled"] = fleetspeak_enabled
else:
# This is an update to an existing client. Raise if the client
# is not known.
if client_id not in self.metadatas:
raise db.UnknownClientError()
if first_seen is not None:
md["first_seen"] = first_seen
if last_ping is not None:
md["ping"] = last_ping
if last_clock is not None:
md["clock"] = last_clock
if last_ip is not None:
if not isinstance(last_ip, rdf_client.NetworkAddress):
raise ValueError(
"last_ip must be client.NetworkAddress, got: %s" %
type(last_ip))
md["ip"] = last_ip
if last_foreman is not None:
md["last_foreman_time"] = last_foreman
if last_crash is not None:
if not isinstance(last_crash, rdf_client.ClientCrash):
raise ValueError(
"last_crash must be client.ClientCrash, got: %s" %
type(last_crash))
md["last_crash"] = last_crash
if not md:
raise ValueError("NOOP write.")
self.metadatas.setdefault(client_id, {}).update(md)
def AddClientLabels(self, client_id, owner, labels):
self._ValidateClientId(client_id)
if isinstance(labels, basestring):
raise ValueError("Expected iterable, got string.")
if client_id not in self.metadatas:
raise db.UnknownClientError()
labelset = self.labels.setdefault(client_id, {}).setdefault(owner, set())
for l in labels:
labelset.add(utils.SmartUnicode(l))
def WriteClient(self, client_id, client):
"""Write new client snapshot."""
if not isinstance(client, objects.Client):
raise ValueError("WriteClient requires rdfvalues.objects.Client, got: %s"
% type(client))
self._ValidateClientId(client_id)
if client_id not in self.metadatas:
raise db.UnknownClientError()
history = self.clients.setdefault(client_id, {})
history[time.time()] = client
def WriteClientCrashInfo(self, client_id, crash_info):
if not isinstance(crash_info, rdf_client.ClientCrash):
raise ValueError(
"WriteClientCrashInfo requires rdf_client.ClientCrash, got: %s" %
type(crash_info))
self._ValidateClientId(client_id)
if client_id not in self.metadatas:
raise db.UnknownClientError()
history = self.crash_history.setdefault(client_id, {})
history[time.time()] = crash_info.SerializeToString()
def WriteClientStartupInfo(self, client_id, startup_info):
if not isinstance(startup_info, rdf_client.StartupInfo):
raise ValueError(
"WriteClientStartupInfo requires rdf_client.StartupInfo, got: %s" %
type(startup_info))
self._ValidateClientId(client_id)
if client_id not in self.metadatas:
raise db.UnknownClientError()
ts = rdfvalue.RDFDatetime.Now()
self.metadatas[client_id]["startup_info_timestamp"] = ts
history = self.startup_history.setdefault(client_id, {})
history[ts] = startup_info.SerializeToString()
def WriteClientSnapshotHistory(self, clients):
super(InMemoryDB, self).WriteClientSnapshotHistory(clients)
if clients[0].client_id not in self.metadatas:
raise db.UnknownClientError(clients[0].client_id)
for client in clients:
startup_info = client.startup_info
client.startup_info = None
snapshots = self.clients.setdefault(client.client_id, {})
snapshots[client.timestamp] = client.SerializeToString()
startup_infos = self.startup_history.setdefault(client.client_id, {})
startup_infos[client.timestamp] = startup_info.SerializeToString()
client.startup_info = startup_info
def WriteClientSnapshot(self, client):
"""Write new client snapshot."""
if not isinstance(client, objects.ClientSnapshot):
raise ValueError(
"WriteClient requires rdfvalues.objects.ClientSnapshot, got: %s"
% type(client))
startup_info = client.startup_info
client.startup_info = None
insert_history_query = (
"INSERT INTO client_snapshot_history(client_id, timestamp, "
"client_snapshot) VALUES (%s, %s, %s)")
insert_startup_query = (
"INSERT INTO client_startup_history(client_id, timestamp, "
"startup_info) VALUES(%s, %s, %s)")
update_query = ("UPDATE clients SET last_client_timestamp=%s, "
"last_startup_timestamp=%s "
"WHERE client_id = %s")
int_id = _ClientIDToInt(client.client_id)
timestamp = datetime.datetime.utcnow()
con = self.pool.get()
cursor = con.cursor()
try:
cursor.execute(insert_history_query,
(int_id, timestamp, client.SerializeToString()))
cursor.execute(
insert_startup_query,
(int_id, timestamp, startup_info.SerializeToString()))
cursor.execute(update_query, (timestamp, timestamp, int_id))
con.commit()
except MySQLdb.IntegrityError as e:
raise db_module.UnknownClientError(str(e))
finally:
cursor.close()
con.close()
client.startup_info = startup_info
def WriteClient(self, client):
"""Write new client snapshot."""
if not isinstance(client, objects.Client):
raise ValueError("WriteClient requires rdfvalues.objects.Client, got: %s"
% type(client))
client_id = client.client_id
self._ValidateClientId(client_id)
if client_id not in self.metadatas:
raise db.UnknownClientError()
startup_info = client.startup_info
client.startup_info = None
ts = time.time()
history = self.clients.setdefault(client_id, {})
history[ts] = client.SerializeToString()
history = self.startup_history.setdefault(client_id, {})
history[ts] = startup_info.SerializeToString()
client.startup_info = startup_info
