def started(self, *args):
logging.info("Initializing DeviceManager")
logging.info("Initializing discovery")
self.active = True
self.sample_worker = Worker(channel="sample_worker").register(self)
self.discovery_worker = Worker(workers=1, channel="discovery_worker").register(self)
self.discovery_timer = Timer(self.DISCOVERY_INTERVAL, discover(),
persist=True).register(self)
self.fire(discover())
return
def __init__(self, application, *args, **kwargs):
self.application = application
self.multiprocess = kwargs.get('multiprocess', False)
self.multithread = kwargs.get('multithread', False)
self.worker = kwargs.get('worker', None)
super(Gateway, self).__init__(*args, **kwargs)
if self.multithread or self.multiprocess:
Worker(self.multiprocess, self.worker,
channel=self.channel).register(self)
def worker(request, manager):
worker = Worker().register(manager)
def finalizer():
worker.unregister()
request.addfinalizer(finalizer)
return worker
class SenseHandler(Component):
_worker = Worker(process=True)
@handler("sense_event", priority=20)
def sense_event(self, event):
### Fire and Wait for: task()
#yield self.call(task(blocking_sense), self._worker)
### This will only print after task() is complete.
print(time_of_now(), "SENSING done. Now uploading...")
self.fire(Event.create("upload_event"))
class SenseHandler(Component):
_worker = Worker(process=True)
@handler("SenseEvent", priority=100)
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 worker(request, manager, watcher):
worker = Worker().register(manager)
assert watcher.wait("registered")
def finalizer():
worker.unregister()
assert watcher.wait("unregistered")
request.addfinalizer(finalizer)
return worker
class UploadHandler(Component):
_worker = Worker(process=True)
@handler("upload_event", priority=10)
def upload_event(self, event):
ustart = time_of_now()
print(time_of_now(), "Sensing+Uploading started")
###log.log(45, "Before upload BYTES\t" + str(get_tx_bytes()))
yield self.call(task(upload_a_packet), self._worker)
###log.log(45, "After upload BYTES\t" + str(get_tx_bytes()))
print(time_of_now(), "Sensing+Uploading IS COMPLETED. of time ",
ustart)
class UploadHandler(Component):
_worker = Worker(process=True)
@handler("UploadEvent", priority=120)
def upload_event(self, *args, **kwargs):
ustart = get_time_as_string(time.time())
print(EventReport("UploadEvent", "started"))
#yield self.call(task(upload_a_bundle), self._worker)
upload_a_bundle(args[0])
print(
EventReport("UploadEvent",
"ENDED (started at " + str(ustart) + ")"))
CircuitsApp.timers["upload"] = Timer(c["interval"]["upload"],
UploadEvent(args[0]),
persist=False).register(self)
def __init__(self,
dataname,
filename,
x=0,
y=0,
width=0,
height=0,
transparency=255,
scale=(1920, 1200),
ignore_timings=True,
immediately=False):
super(GIFImage, self).__init__(dataname)
self.filename = filename
self.x = x
self.y = y
self.width = width
self.height = height
self.transparency = transparency
self.ignore_timings = ignore_timings
self.factor = 1
self.scale = scale
self.delta = 0.0
self.frames = []
self.durations = []
self.worker = Worker(process=False,
workers=2,
channel="gifimport_" + dataname).register(self)
# if transparency < 255:
# self.log('Setting alpha to %i' % transparency)
# for frame in self.frames:
# frame[0].set_alpha(transparency)
self.cur = 0
self.ptime = 0
self.playing = False
self.breakpoint = 0
self.startpoint = 0
self.reversed = False
if immediately:
self.get_frames()
def worker(request):
worker = Worker()
def finalizer():
worker.stop()
request.addfinalizer(finalizer)
if request.config.option.verbose:
from circuits import Debugger
Debugger().register(worker)
waiter = pytest.WaitEvent(worker, "started")
worker.start()
assert waiter.wait()
return worker
def __init__(self,
tile_path='/var/cache/hfos',
default_tile=None,
**kwargs):
"""
:param tile_path: Caching directory structure target path
:param default_tile: Used, when no tile can be cached
:param kwargs:
"""
super(MaptileService, self).__init__('MTS', **kwargs)
self.worker = Worker(process=False, workers=2,
channel="tcworkers").register(self)
self.cache_path = tile_path
self.default_tile = default_tile
self._tiles = []
def __init__(self, default_tile=None, **kwargs):
"""
:param tile_path: Caching directory structure target path
:param default_tile: Used, when no tile can be cached
:param kwargs:
"""
super(MaptileService, self).__init__('MTS', **kwargs)
self.worker = Worker(process=False, workers=2,
channel="tcworkers").register(self)
for item in ['tilecache', 'rastertiles', 'rastercache']:
get_path('cache', item, ensure=True)
self.cache_path = get_path('cache', '')
self.default_tile = default_tile
self._tiles = []
def __init__(self, settings):
super(GIFPlayer, self).__init__()
self.log('Player initializing')
pygame.display.init()
self.config = settings
self.factor = 1
self.delta = 0.0
self.frames = []
self.durations = []
self.clients = []
self.timer = None
self.worker = Worker(process=False,
workers=2,
channel="gifimport_" +
self.uniquename).register(self)
# if transparency < 255:
# self.log('Setting alpha to %i' % transparency)
# for frame in self.frames:
# frame[0].set_alpha(transparency)
self.cur = 0
self.ptime = 0
self.playing = False
self.breakpoint = 0
self.startpoint = 0
self.direction = True
self.fireEvent(cli_register_event("test_gifplayer",
cli_test_gifplayer))
if self.config['immediately']:
self.get_frames()
def init(self, search_string, song_web_query_object):
Worker(process=False).register(self)
self.search_string = search_string
self.query_object = song_web_query_object
# Links to the specific page of song search service that have been used
# (Added to initial list, added to list due to low count, or accept/rejected by user.)
# This keeps from asking about previously processed links.
self.used_links = set()
# Links from a given search_link. This is in an OrderedDict, as we may have to pull
# prior to the user accept or rejecting it, due to running out of links.
self.future_links = OrderedDict()
# If youtube search is in progress, this caches calls to allow youtube so send when complete
self.youtube_wait = []
# Initial search link. Do we need to save this?
start_link = self.query_object.get_initial_url(search_string)
if not start_link:
self.fire(search_exhausted(), '*')
return
self._initialize_data(start_link)
self.fire(song_found(start_link), '*')
def __init__(self, device_id=0, targetresolution=(40, 16), *args,
**kwargs):
super(CVCamera, self).__init__(*args, **kwargs)
self.targetresolution = targetresolution
self.cam = cv2.VideoCapture(device_id)
self.cam.set(3, 320)
self.cam.set(4, 240)
self.framerate = 20 / 1000.0
self.recording = True
self.worker = Worker(process=False, workers=1,
channel="camera").register(self)
self.cam_timer = Timer(2, Event.create('takepicture')).register(
self)
self.surface = pygame.Surface(targetresolution)
self.log('Camera started')
def __init__(self,
path="/tilecache",
tilepath="/var/cache/hfos/tilecache",
defaulttile=None,
**kwargs):
"""
:param path: Webserver path to offer cache on
:param tilepath: Caching directory structure target path
:param defaulttile: Used, when no tile can be cached
:param kwargs:
"""
super(TileCache, self).__init__(**kwargs)
self.worker = Worker(process=False, workers=2,
channel="tcworkers").register(self)
self.tilepath = tilepath
self.path = path
self.defaulttile = defaulttile
self._tilelist = []
def __init__(self, bot, *args, **kwargs):
self.trigger = ' '
self.debugger = None
self.parser = ArgumentParser(description=self.__doc__, prog='')
self.subparsers = self.parser.add_subparsers(
title='User commands',
description='All available commands',
parser_class=ArgumentParser)
self.commands = {}
self.authenticated = []
self.master = {
'*': [
'spaceone',
]
}
self._master = {'*': []}
self.ignore = []
import spacebot.plugins as plugins
self.plugins = plugins
super(Commander, self).__init__(bot, *args, **kwargs)
Worker(channel=self.channel).register(self)
def __init__(self, *args):
super(FileManager, self).__init__('FILES', *args)
self.file_object = objectmodels['file']
self.volumes = {}
self.volumes_lookup = {}
for item in objectmodels['volume'].find():
self.volumes[item.uuid] = item
self.volumes_lookup[item.name] = item
if not os.path.exists(item.path):
self.log('Target volume does not exist. Creating path', item.path, lvl=warn)
try:
os.makedirs(item.path)
except Exception as e:
self.log('Could not create volume path:', e, type(e), exc=True, lvl=error)
self.worker = Worker(process=False, workers=1,
channel="filemanagerworkers").register(self)
def __init__(self, *args, **kwargs):
"""
:param tile_path: Caching directory structure target path
:param default_tile: Used, when no tile can be cached
:param kwargs:
"""
super(MaptileLoader, self).__init__('MTL', *args, **kwargs)
for item in ['tilecache', 'rastertiles', 'rastercache']:
get_path('cache', item, ensure=True)
self.cache_path = get_path('cache', '')
self.worker = Worker(process=False, workers=2,
channel="tclworkers").register(self)
self.cancelled = []
self.requests = {}
self.fire(cli_register_event('test_maploader',
cli_test_maptile_Loader))
def main():
config = Config()
logger = setup_logging(config)
db = setup_database(config, logger)
manager = Manager()
Worker(channel="threadpool").register(manager)
if config["debug"]:
Debugger(
logger=logger,
events=config["verbose"],
).register(manager)
if config["daemon"]:
Daemon(config["pidfile"]).register(manager)
Core(config, db).register(manager)
manager.run()
def init(self, *args, **kwargs):
Worker(process=True).register(self)
def queue_cancel(self, event):
self.log('Cancelling download of offline tiles')
self.worker.pool.terminate()
self.worker.unregister()
self.worker = Worker(process=False, workers=2,
channel="tclworkers").register(self)
def init(self, *args, **kwargs):
self.foo_count = 0
Worker(process=False).register(self)
