def heartbeat(bucket_name,start_time,activity):
client = ActivityWatchClient("aw-watcher-cli", testing=False)
bucket_id = "{}_{}".format(bucket_name, client.hostname)
event_type = "cli_ping"
client.create_bucket(bucket_id, event_type=event_type)
# Asynchronous loop
with client:
heartbeat_data = {"label": "heartbeat"}
now = datetime.now(timezone.utc)
heartbeat_event = Event(timestamp=now, data=heartbeat_data)
sleeptime = 1
#Sending hearbeat until keyboard interrup
second = 1
while(True):
# The duration between the heartbeats will be less than pulsetime, so they will get merged.
rd = relativedelta.relativedelta (now, start_time)
print("Doing: {} for {:02}:{:02}:{:02}".format(activity,rd.hours, rd.minutes, rd.seconds),end="\r")
client.heartbeat(bucket_id, heartbeat_event, pulsetime=sleeptime+1, queued=True)
# Sleep a second until next heartbeat
sleep(sleeptime)
# Update timestamp for next heartbeat
heartbeat_event.timestamp = datetime.now(timezone.utc)
# update now
now = heartbeat_event.timestamp
second += 1
def window_events(client, start_date, end_date):
print("Generating fake window events")
template_window_events = []
for app_i in range(4):
appname = "App " + str(app_i)
for title_i in range(10):
title = "Title " + str(title_i)
e = Event(timestamp=start_date,
data={
"title": title,
"app": appname
})
template_window_events.append(e)
ts = start_date
window_events = []
batch_size = 500
count = 0
while ts < end_date:
event_duration = 5
e = copy(random.choice(template_window_events))
e.timestamp = ts
e.duration = timedelta(seconds=event_duration)
window_events.append(e)
ts += timedelta(seconds=event_duration)
count += 1
if count % batch_size == 0:
client.send_events(window_bucket_name, window_events)
window_events = []
sleep(0.05)
client.send_events(window_bucket_name, window_events)
print("Sent {} window events".format(count))
heartbeat_event = Event(timestamp=now, data=heartbeat_data)
# Now we can send some events via heartbeats
# This will send one heartbeat every second 5 times
sleeptime = 1
for i in range(5):
# The duration between the heartbeats will be less than pulsetime, so they will get merged.
# TODO: Make a section with an illustration on how heartbeats work and insert a link here
print("Sending heartbeat {}".format(i))
client.heartbeat(bucket_id, heartbeat_event, pulsetime=sleeptime+1, queued=True)
# Sleep a second until next heartbeat
sleep(sleeptime)
# Update timestamp for next heartbeat
heartbeat_event.timestamp = datetime.now(timezone.utc)
# Give the dispatcher thread some time to complete sending the last events.
# If we don't do this the events might possibly queue up and be sent the
# next time the client starts instead.
sleep(1)
# Synchronous example, insert an event
event_data = {"label": "non-heartbeat event"}
now = datetime.now(timezone.utc)
event = Event(timestamp=now, data=event_data)
inserted_event = client.insert_event(bucket_id, event)
# The event returned from insert_event has been assigned an id by aw-server
assert inserted_event.id is not None