def start_heartbeats(self):
LOG.info("Client HB: %s Server HB: %s", self._client.clientHeartBeat,
self._client.serverHeartBeat)
if self._client.clientHeartBeat:
if self.client_heartbeat:
# Timer already exists, just reset it
self.client_heartbeat.reset()
else:
LOG.info("Client will send heartbeats to server")
# Send heartbeats at 80% of agreed rate
self.client_heartbeat = Timer(
(self._client.clientHeartBeat / 1000.0) * 0.8,
ClientHeartbeat(),
persist=True)
self.client_heartbeat.register(self)
else:
LOG.info("No Client heartbeats will be sent")
if self._client.serverHeartBeat:
if self.server_heartbeat:
# Timer already exists, just reset it
self.server_heartbeat.reset()
else:
LOG.info("Requested heartbeats from server.")
# Allow a grace period on server heartbeats
self.server_heartbeat = Timer(
(self._client.serverHeartBeat / 1000.0) * self.ALLOWANCE,
ServerHeartbeat(),
persist=True)
self.server_heartbeat.register(self)
else:
LOG.info("Expecting no heartbeats from Server")
def init_scene(self):
print(EventReport("Info", "Init Scene"))
self.sensors = []
num_sensors = len(c["sensor"])
for i in range(0, num_sensors):
s1 = Sensor(i, c["sensor"][i]["name"],
c["sensor"][i]["readlatency"],
c["sensor"][i]["period"], c["sensor"][i]["pin"])
self.sensors.append(s1)
self.set_endtime(c["interval"]["M"])
self.bought_data = c["params"]["D"]
print(self.sensors)
for i in range(0, num_sensors):
s1 = self.sensors[i]
CircuitsApp.timers["sense"] = Timer(s1.period,
SenseEvent(
s1, self.readings_queue),
persist=False).register(self)
CircuitsApp.timers["upload"] = Timer(c["interval"]["upload"],
UploadEvent(self.readings_queue),
persist=False).register(self)
def __init__(self, host="matelight", port=1337, *args):
super(Matelight, self).__init__(*args)
self.log("Initializing matelight output")
self.host = host
self.port = port
self.size = (40, 16)
self.gamma = 0.5
self.fading = None
self.auto_restart = True
self.output_broken = False
self.last_frame = np.zeros(self.size, np.uint8)
path = os.path.abspath("./images/startscreen_matelight.png")
boot_image = cv.imread(path)
self.boot_image = cv.cvtColor(boot_image, cv.COLOR_BGR2RGB)
self._transmit(self.boot_image)
self.fade_timer = None
self.init_timer = Timer(5, fade_out_ml()).register(self)
self.refresh_timer = Timer(1, refresh_ml(),
persist=True).register(self)
def started(self, component):
print("started")
Timer(20, Event.create("end")).register(self)
# Fire some test events
N = 3
for loop in range(1, N):
self.fire(ActionMessage(source="test_thing", headers=None, message={"who": "you"}))
Timer(1, ActionMessage(source="test_thing", headers=None, message={"who": "me"})).register(self)
Timer(2, ActionMessage(source="test_thing", headers=None, message={"who": "us"})).register(self)
def __init__(self, *args, **kwargs):
super(FloodProtectedManager, self).__init__(*args, **kwargs)
self._flooding = {}
self._flood_counter = {}
self._flood_counters_resetter = Timer(
2, Event.create("reset_flood_counters"), persist=True
).register(self)
self._flood_offender_resetter = Timer(
10, Event.create("reset_flood_offenders"), persist=True
).register(self)
def started(self, component):
"""started Event handler
Setup 3 timers at 5, 1 and 3 seconds.
The 2nd two timers are persitent meaning that
they are fired repeatedly every 1 and 3 seconds
respectively.
"""
# Timer(seconds, event, persist=False)
Timer(5, Event.create("hello")).register(self)
Timer(1, Event.create("foo"), persist=True).register(self)
Timer(3, Event.create("bar"), persist=True).register(self)
def __init__(self, *args):
ConfigurableComponent.__init__(self, "IRCBOT", *args)
if self.config.get('password', None) is None:
self.config.password = std_uuid()
self.config.save()
self.channel = 'ircbot'
self.fireEvent(cli_register_event('test_irc_send', cli_test_irc_send), "isomer-web")
self.log("Started")
self.host = self.config.host
self.port = self.config.port
self.hostname = gethostname()
self.nick = self.config.nick
self.irc_channels = self.config.channels
# Mapping of IRC Channel -> Set of Nicks
self.channel_map = defaultdict(set)
# Mapping of Nick -> Set of IRC Channels
self.nick_map = defaultdict(set)
# Add TCPClient and IRC to the system.
self.transport = TCPClient(channel=self.channel).register(self)
self.protocol = IRC(channel=self.channel).register(self)
# Keep-Alive Timer
Timer(60, Event.create("keepalive"), persist=True).register(self)
def init(self, events, gui=None):
self.timers = []
# Create and register all the events defined in PeriodicEvents
events.register(self)
# Construct the list of timer handlers for all events iff interval[e] is defined/registered
self.timers = [
Timer(events.interval[e], Event.create(e),
persist=True).register(self) for e in events.event_names
if events.interval.get(e)
]
# Set up GUI handler for updating
if gui is not None:
self.gui = gui
Timer(0.01, Event.create('update_gui'),
persist=True).register(self)
self.queue = Queue.Queue()
def started(self, *args): self.conn = ModbusClient(host=self.ip[0], port=self.ip[1], auto_open=True) self.fire(sample(), self) self.sample_timer = Timer(self.DEFAULT_INTERVAL + random.uniform(0, 1), sample(), self, persist=True).register(self) return
def persistent(self, interval):
timer = Timer(interval, single(), persist=True)
timer.register(self)
yield sleep(interval * 10)
timer.unregister()
def __init__(self, *args):
"""
Initialize the navigation sensor data component.
:param args:
"""
super(Sensors, self).__init__('NAVDATA', *args)
self.datatypes = {}
# self._update_sensordata()
self.sensed = {}
self.referenceframe = {} # objectmodels['sensordata']()
self.referenceages = {}
self.changed = False
self.interval = 1
self.passiveinterval = 10
self.intervalcount = 0
self.subscriptions = {}
Timer(self.interval,
Event.create('navdatapush'),
self.channel,
persist=True).register(self)
def started(self, component):
# x = yield self.call(task(factorial, 10))
Timer(1, Event.create("foo"), persist=True).register(self)
self.fire(task(download_web_page,
'http://www.slickdeals.net')) # async
self.fire(task(download_web_page, 'http://www.google.com')) # async
self.fire(task(download_web_page, 'http://www.yahoo.com')) # async
def upload_event(self, *args, **kwargs):
## args[0] is the reading queue
queue = args[0]
print(EventReport("UploadEvent", (str(args) + ", " + str(kwargs))))
#lprint(EventReport("UploadEvent", "started"))
CircuitsApp.shareState = 0
yield self.call(task(upload_a_bundle(queue)))
print("Upload successful.")
CircuitsApp.shareState = 1
lprint(EventReport("UploadEvent", "ENDED"))
CircuitsApp.last_uploaded = getSentByte() - CircuitsApp.startbyte
lprint(
EventReport("UploadedSoFar",
str(convert_size(CircuitsApp.last_uploaded))), 45)
M = c["interval"]["M"]
t = time.time() - CircuitsApp.starttime
if (M == t):
return
#~ if(M - t < c["interval"]["upload"]):
#~ CircuitsApp.timers["upload"] = Timer((M - t), UploadEvent(args[0]), persist=False).register(self)
#~ else:
if not CircuitsApp.isEnd:
CircuitsApp.timers["upload"] = Timer(c["interval"]["upload"],
UploadEvent(args[0]),
persist=False).register(self)
rate = CircuitsApp.upload_rate
u = CircuitsApp.last_uploaded
CircuitsApp.upload_rate = min((c["params"]["D"] - u) * 1.0 / (M - t),
c["upload"]["max_rate"])
def __init__(self, opts):
super(FunctionComponent, self).__init__(opts)
self.options = opts.get("fn_symantec_dlp", {})
self.dlp_listener = DLPListener(opts)
if "pytest" in sys.modules:
# Reaching here indicates that the component is invoked from within a testing session.
# In this case, don't start the Poller
LOG.info("Running within a test environment. Not starting listener")
else:
# The dlp_listener_toggle will determine whether the Poller will run
if str_to_bool(self.options.get("sdlp_should_poller_run", None)):
if self.dlp_listener.soap_client.is_connected:
self.setup_listener()
# Use a circuits timer to fire off an event every N seconds.
# When the event is fired, a function with the decorator @handler(name_of_event)
# will be used to handle the event and perform some task
polling_interval = int(self.options.get("sdlp_listener_timer", DEFAULT_POLLING_INTERVAL))
LOG.debug(u"DLP Polling interval will be %s seconds", polling_interval)
Timer(interval=polling_interval,
event=Event.create("DLPListenerPollingEvent"),
persist=True).register(self)
def test_datetime(app):
now = datetime.now()
d = now + timedelta(seconds=0.1)
timer = Timer(d, test(), "timer")
timer.register(app)
assert pytest.wait_for(app, "flag")
app.reset()
def sense_event(self, *args, **kwargs):
"hello, I got an event"
print(EventReport("SenseEvent", (str(args) + ", " + str(kwargs))))
CircuitsApp.timers["sense"] = Timer(args[0].period,
SenseEvent(args[0], args[1]),
persist=False).register(self)
self.fire(ReadEvent(args[0], args[1]))
def _start_auto_refresh(self, incident):
# Get the interval from the avalon_auto_refresh_time field
refresh_interval_minutes = self.actions.res.incident_get_avalon_auto_refresh_time(
incident)
# default to 60 minutes if not set in IBM Resilient
if not refresh_interval_minutes:
refresh_interval_minutes = 60
# create timer
incident_id = incident["id"]
auto_refresh_event = auto_refresh(incident_id)
timer = Timer(60 * refresh_interval_minutes,
auto_refresh_event,
self.channel,
persist=True)
# keep timer in the incident map
self.incident_timer[incident_id] = timer
# start ticking
timer.register(self)
# fire event once to refresh nodes now
self.fire(auto_refresh_event)
def __init__(self, maxcams=16, *args):
super(Manager, self).__init__("CAM", *args)
self._cameras = {}
self._subscribers = {}
self._filming = True
self._frame_count = 0
self._frames = {}
if opencv is not None:
self.log("Checking opencv for cameras.", lvl=debug)
for cam in range(maxcams):
video = opencv.VideoCapture(cam)
if video.isOpened():
camera = {
'uuid': str(uuid4()),
'name': 'Camera' + str(cam),
'cam': video
}
self._cameras[cam] = camera
self.log("Found camera [", cam, "]: ", camera)
if len(self._cameras) > 0:
self.log("Starting timer")
self.timer = Timer(0.05, Event.create("rec"),
persist=True).register(self)
self.log("Found cameras: ", self._cameras, lvl=debug)
else:
self.log("No opencv, no cameras.")
self.log("Started")
def __init__(self, maxcams=16, *args):
super(CameraManager, self).__init__(*args)
self._cameras = {}
self._subscribers = {}
self._filming = True
self._framecount = 0
self._frames = {}
hfoslog("[CAM] Checking opencv for cameras.", lvl=debug)
for cam in range(maxcams):
video = opencv.VideoCapture(cam)
if video.isOpened():
camera = {
'uuid': str(uuid4()),
'name': 'Camera' + str(cam),
'cam': video
}
self._cameras[cam] = camera
hfoslog("[CAM] Found camera [", cam, "]: ", camera)
hfoslog("[CAM] Starting timer")
self.timer = Timer(0.05, Event.create("rec"),
persist=True).register(self)
hfoslog("[CAM] Found cameras: ", self._cameras, lvl=debug)
hfoslog("[CAM] Started")
def __init__(self, *args, **kwargs):
super(BackupManager, self).__init__("BACKUP", *args, **kwargs)
self.log("Backup manager started")
self.timer = Timer(self.config.interval,
Event.create("backup"),
persist=True).register(self)
def joystickchange(self, event):
if event.input.type != pygame.JOYBUTTONUP:
return
# self.log(event.input, pretty=True)
button = event.input.button
key = ""
if button == 0:
key = "X"
elif button == 1:
key = "O"
elif button == 2:
key = "A"
elif button == 3:
key = "S"
self.input += key
if self.timer is not None:
self.timer.unregister()
if self.input in self.combos:
self.log("Firing combo event for combo", self.input, lvl=debug)
self.fireEvent(Event.create(self.combos[self.input]))
self.input = ""
else:
self.timer = Timer(self.config.timeout,
reset_combo_trigger()).register(self)
def __init__(self, *args):
super(ConnectivityMonitor, self).__init__("NETMON", *args)
self.fireEvent(
cli_register_event('test_connectivity', cli_test_connectivity))
self.old_status = True
self.status = False
self.nodestate = objectmodels['nodestate'].find_one(
{'uuid': STATE_UUID_CONNECTIVITY})
status = self._can_connect()
self.log('Initial connectivity state:', status)
self.fireEvent(
backend_nodestate_toggle(STATE_UUID_CONNECTIVITY,
on=status,
force=True))
self.old_status = self.status = status
self.timer = Timer(self.config.interval,
timed_connectivity_check(),
persist=True).register(self)
self.log("Started")
def __init__(self, *args):
super(NavdataSim, self).__init__("NAVSIM", *args)
if self.config.active is True:
self.log("Started, channel:", self.channel)
Timer(3, generatenavdata(), persist=True).register(self)
else:
self.log("Disabled.")
def play(self):
self.log('Play!', lvl=debug)
self.playing = True
if self.timer is None:
self.ptime = time.time()
self.timer = Timer(self.config['delay'] / 1000.0,
render(),
persist=True).register(self)
def call_loop(self, event):
"""Runs a given client loop for interactive processes"""
self.log('Running external loop')
try:
self.loop_function()
except Exception:
self.loop_timer.unregister()
Timer(2, Event.create("quit")).register(self)
def on_read(self, *args):
print(args)
parsed_data = json.loads(args[0].decode())
if parsed_data.get("ACK"):
print("Write data!!!", file_data)
self.write(file_data)
if parsed_data.get("info"):
print(parsed_data.get("info"))
Timer(1, disconnect()).register(self)
def _execute_action_from_queue(self):
discard = False
action = None
if len(self.actionqueue):
logging.debug('dequeuing next API action')
# pop from queue
action = self.actionqueue.popleft()
elif self.shm['state']['ICHCAPI']['room_joined']:
# no actions; simply receive any new message from the API
action = ['recv']
delay = self.config['polling_interval']
if action:
requeue = True
# process only join requests when not joined
query_type = action[0]
if query_type == 'join':
# ensure rejoin gets sent
requeue = False
if not self.shm['state']['ICHCAPI']['join_lock']:
self.shm['state']['ICHCAPI']['join_lock'] = True
else:
# suppress superfluous join requests
discard = True
elif self.shm['state']['ICHCAPI']['room_joined']:
requeue = False
if requeue:
# put back actions we're not ready to execute
self.actionqueue.appendleft(action)
elif not discard:
self.shm['state']['ICHCAPI']['last_action'] = action[0]
self.shm['state']['ICHCAPI']['last_query'] = time()
# send in line
self._query_api_from_action(action)
self.shm['stats']['ICHCAPI']['api_requests'] += 1
# throttle if we recv'd last time and got no new messages
if (action[0] == 'recv' and
self.shm['state']['ICHCAPI']['last_action'] == 'recv'
and self.shm['state']['ICHCAPI']['empty_recvs'] >
(int(self.config['api_throttle_idle_timeout'] //
self.config['polling_interval']) - 1)):
delay = self.shm['state']['ICHCAPI']['last_interval']
if (delay < self.config['max_polling_interval']):
delay += self.config['api_throttle_step']
self.shm['state']['ICHCAPI']['last_interval'] = delay
logging.debug(
"throttling API polling to {}s".format(delay))
self.http_poll_timer = Timer(float(delay),
events.do_process_next_action(),
self.channel).register(self)
def _fail(self, event, message="Invalid credentials"):
"""Sends a failure message to the requesting client"""
notification = {"component": "auth", "action": "fail", "data": message}
ip = event.sock.getpeername()[0]
self.failing_clients[ip] = event
Timer(3, Event.create("notify_fail", event.clientuuid, notification,
ip)).register(self)
def init(self, *args, **kwargs):
super(Logger, self).init(*args, **kwargs)
interval = datetime.fromordinal(
(date.today() + timedelta(1)).toordinal())
print("Next log roration set for: {}".format(
interval.strftime("%Y-%m-%d %H:%M:%S")))
Timer(interval, rotate(), self.channel).register(self)
def started(self, component):
self.fire(task(factorial, 3)) # async
self.fire(task(factorial, 5)) # async
self.fire(task(factorial, 7)) # async
self.fire(task(factorial, 10)) # async
self.fire(task(factorial, 11)) # async
self.fire(task(factorial, 11)) # async
self.fire(task(factorial, 12)) # async
self.fire(task(factorial, 14)) # async
Timer(1, Event.create("foo"), persist=True).register(self)
