class GeventedHTTPTransport(HTTPTransport): scheme = ['gevent+http', 'gevent+https'] def __init__(self, parsed_url, maximum_outstanding_requests=100): if not gevented: raise ImportError('GeventedHTTPTransport requires gevent.') self._lock = Semaphore(maximum_outstanding_requests) super(GeventedHTTPTransport, self).__init__(parsed_url) # remove the gevent+ from the protocol, as it is not a real protocol self._url = self._url.split('+', 1)[-1] def send(self, data, headers): """ Spawn an async request to a remote webserver. """ # this can be optimized by making a custom self.send that does not # read the response since we don't use it. self._lock.acquire() return spawn(super(GeventedHTTPTransport, self).send, data, headers).link(self._done, self) def _done(self, *args): self._lock.release()
def __new__(cls, s): if s.id in sites: return sites[s.id] self = object.__new__(cls) sites[s.id] = self self.s = s self.connect() self._delay_on = Semaphore() self.controllers = set() self.envgroups = set() self.meters = {} for M in METERS: ml = set() self.meters[M.meter_type] = ml for d in getattr(self.s, M.meter_type + "_meters").all(): ml.add(M(d)) self.log("Startup") self.connect_monitors(do_controllers=False) signal.signal(signal.SIGINT, self.do_shutdown) signal.signal(signal.SIGTERM, self.do_shutdown) signal.signal(signal.SIGHUP, self.do_syncsched) self.running = True return self
def __init__(self, svc): #maxsize - 最大缓存,超过限制将视为无效解码 self.buf = '' self.conn = None self.svc = svc self.mtx = Semaphore() self.msgcnt = 0 #接收消息计数
def __init__(self, url, bucket, password="", verbose=False): self.log = logger.logger("VBucketAwareMemcachedClient") self.bucket = bucket self.rest_username = bucket self.rest_password = password self._memcacheds = {} self._vBucketMap = {} self._vBucketMap_lock = Lock() self._vBucketMapFastForward = {} self._vBucketMapFastForward_lock = Lock() #TODO: use regular expressions to parse the url server = {} if not bucket: raise InvalidArgumentException("bucket can not be an empty string", parameters="bucket") if not url: raise InvalidArgumentException("url can not be an empty string", parameters="url") if url.find("http://") != -1 and url.rfind(":") != -1 and url.find("/pools/default") != -1: server["ip"] = url[url.find("http://") + len("http://"):url.rfind(":")] server["port"] = url[url.rfind(":") + 1:url.find("/pools/default")] server["username"] = self.rest_username server["password"] = self.rest_password self.servers = [server] self.servers_lock = Lock() self.rest = RestConnection(server) self.reconfig_vbucket_map() self.init_vbucket_connections() self.dispatcher = CommandDispatcher(self) self.dispatcher_thread = Process(name="dispatcher-thread", target=self._start_dispatcher) self.dispatcher_thread.daemon = True self.dispatcher_thread.start() self.streaming_thread = Process(name="streaming", target=self._start_streaming, args=()) self.streaming_thread.daemon = True self.streaming_thread.start() self.verbose = verbose
class MediaCodec_Base: def __init__(self,svc): #maxsize - 最大缓存,超过限制将视为无效解码 self.buf ='' self.conn = None self.svc = svc self.mtx = Semaphore() self.msgcnt=0 #接收消息计数 def parseMessage(self,s): pass #数据置入队列,应检查队列长度和数据合法性 def queueIn(self,s,conn): self.mtx.acquire() # self.buflist.append(s) self.buf+=s self.mtx.release() return True def decode(self): #@return (packets,retry) retry表示解码遇到错误或者数据非法 return (),False #根据传入的消息分拣出gps,alarm消息 MsgAoModule_Alarm(), MsgAoModule_GpsData() def filter_msg(self,m,aom): # GSP,ALARM 消息是关心的消息,需要反馈到客户端 return (m,) def command(self,aom,m): pass def save(self,aom,m): ''' 保存设备所有信息,不区分是何类型 ''' try: cm = aom.ao.cm params= m.params if isinstance(m.params,dict): params = json.dumps(m.params) log = cm.AO_ModuleLog() log.ao = aom.ao.r log.module = aom.r log.type = ModuleMsgType.DEV2SYS log.time = datetime.datetime.now() log.msgtype = 'N/A' log.params = params log.rawmsg = m.rawmsg log.seq = 0 log.save() return True except: traceback.print_exc() return False
class Client(object): px_per_tick = 100 def __init__(self, canvas): self.canvas = canvas self.socket = None self.connect_ts = time.time() # This buffer discards all but the newest 1024 messages self.sendbuffer = deque([], 1024) # And this is used to limit clients to X messages per tick # We start at 0 (instead of x) to add a reconnect-penalty. self.limit = Semaphore(0) self.lock = RLock() def send(self, line): self.sendbuffer.append(line.strip() + '\n') def nospam(self, line): if not self.sendbuffer: self.sendbuffer.append(line.strip() + '\n') def disconnect(self): with self.lock: if self.socket: socket = self.socket self.socket = None socket.close() log.info('Disconnect') def serve(self, socket): with self.lock: self.socket = socket sendall = self.socket.sendall readline = self.socket.makefile().readline try: while self.socket: self.limit.acquire() # Idea: Send first, receive later. If the client is to # slow to get the send-buffer empty, he cannot send. while self.sendbuffer: sendall(self.sendbuffer.popleft()) line = readline().strip() if not line: break arguments = line.split() command = arguments.pop(0) try: self.canvas.fire('COMMAND-%s' % command.upper(), self, *arguments) except Exception, e: socket.send('ERROR %r :(' % e) break finally: self.disconnect() def tick(self): while self.limit.counter <= self.px_per_tick: self.limit.release()
def test_release_twice(self): s = Semaphore() result = [] s.rawlink(lambda s: result.append('a')) s.release() s.rawlink(lambda s: result.append('b')) s.release() gevent.sleep(0.001) self.assertEqual(result, ['a', 'b'])
class GeventSemaphore(BaseSemaphore): def __init__(self): self.__semaphore = Semaphore() def acquire(self): self.__semaphore.acquire() def release(self): self.__semaphore.release()
def __init__(self, parsed_url, maximum_outstanding_requests=100): if not gevented: raise ImportError('GeventedHTTPTransport requires gevent.') self._lock = Semaphore(maximum_outstanding_requests) super(GeventedHTTPTransport, self).__init__(parsed_url) # remove the gevent+ from the protocol, as it is not a real protocol self._url = self._url.split('+', 1)[-1]
def test(): s = Semaphore(0) future1 = yield batchy_gevent.greenlet_future(gevent.spawn(acq, s)) future2 = yield batchy_gevent.greenlet_future(gevent.spawn(acq, s)) s.release() yield future1 s.release() yield future2
def handle_socket(sock, address): semaphore = Semaphore() while 1: sock.setblocking(0) semaphore.acquire() sockfd = sock.makefile() chunk_size = 1024 head_packet_format = "!LL128s128sL" head_packet_size = struct.calcsize(head_packet_format) data = sockfd.read(head_packet_size) if not data or len(data) != head_packet_size: return filepath_len, filename_len, filepath,filename, filesize = struct.unpack(head_packet_format,data) filepath = filepath[:filepath_len] filename = filename[:filename_len] #logger.debug("update file: %s" % filepath + '/' + filename) fd = open(filename,'wb') fcntl.flock(fd,fcntl.LOCK_EX) print "File %s size: %s" % (filename, filesize) print 111111111111111 writen_size = 0 if filesize > chunk_size: times = filesize / chunk_size first_part_size = times * chunk_size second_part_size = filesize % chunk_size print "times: %s first_part_size:%s second_part_size:%s" % (times,first_part_size,second_part_size) print 22222222222222222222 #receive first part packets while 1: data = sockfd.read(chunk_size) fd.write(data) fd.flush() writen_size += len(data) if writen_size == first_part_size: break print "writen_size in first_par: %s" % writen_size print 333333333333333333333 if second_part_size: #receive the packet at last data = sockfd.read(second_part_size) fd.write(data) fd.flush() writen_size += len(data) print 4444444444444444444444 else: data = sockfd.read(filesize) fd.write(data) fd.flush() writen_size += len(data) fcntl.flock(fd,fcntl.LOCK_UN) fd.close() print '555555555555555555555' print "File %s size: %s\n" % (filename, writen_size) semaphore.release()
def __init__(self, *args, **kwargs): Greenlet.__init__(self) Model.__init__(self, *args, **kwargs) docker_url = config.get('docker_url') self.container = api.DockerAPI(self.cid, docker_url) self._lock = Semaphore() self._lock.acquire() # locking semaphore self._new_data = None
def __init__(self): self.__db = SQ.connect(":memory:") self.cur = self.__db.cursor() self.cur.execute( "CREATE TABLE hosts (id TEXT, addr TEXT, hostname TEXT)") self.cur.execute( "CREATE TABLE workers (id TEXT, host_id TEXT, service TEXT, addr TEXT, pid INT, online BOOLEAN)" ) self.cur.execute("CREATE TABLE services (host_id TEXT, name TEXT)") self.SEMA = Semaphore()
class MediaCodec_Base: def __init__(self, svc): #maxsize - 最大缓存,超过限制将视为无效解码 self.buf = '' self.conn = None self.svc = svc self.mtx = Semaphore() self.msgcnt = 0 #接收消息计数 def parseMessage(self, s): pass #数据置入队列,应检查队列长度和数据合法性 def queueIn(self, s, conn): self.mtx.acquire() # self.buflist.append(s) self.buf += s self.mtx.release() return True def decode(self): #@return (packets,retry) retry表示解码遇到错误或者数据非法 return (), False #根据传入的消息分拣出gps,alarm消息 MsgAoModule_Alarm(), MsgAoModule_GpsData() def filter_msg(self, m, aom): # GSP,ALARM 消息是关心的消息,需要反馈到客户端 return (m, ) def command(self, aom, m): pass def save(self, aom, m): ''' 保存设备所有信息,不区分是何类型 ''' try: cm = aom.ao.cm params = m.params if isinstance(m.params, dict): params = json.dumps(m.params) log = cm.AO_ModuleLog() log.ao = aom.ao.r log.module = aom.r log.type = ModuleMsgType.DEV2SYS log.time = datetime.datetime.now() log.msgtype = 'N/A' log.params = params log.rawmsg = m.rawmsg log.seq = 0 log.save() return True except: traceback.print_exc() return False
def __init__(self, size=None, greenlet_class=None): if size is not None and size < 0: raise ValueError('size must not be negative: %r' % (size, )) Group.__init__(self) self.size = size if greenlet_class is not None: self.greenlet_class = greenlet_class if size is None: self._semaphore = DummySemaphore() else: self._semaphore = Semaphore(size)
def __init__(self, size=None, greenlet_class=None): if size is not None and size < 0: raise ValueError('Invalid size for pool (positive integer or None required): %r' % (size, )) Group.__init__(self) self.size = size if greenlet_class is not None: self.greenlet_class = greenlet_class if size is None: self._semaphore = DummySemaphore() else: self._semaphore = Semaphore(size)
def __init__(self, dsn, max_con=10, max_idle=3, connection_factory=RealDictConnection): self.dsn = dsn self.max_con = max_con self.max_idle = max_idle self.connection_factory = connection_factory self._sem = Semaphore(max_con) self._free = [] self._local = gevent_local()
def __init__(self, engine, min_sessions=10, max_sessions=25): self.engine = engine sm = sessionmaker(autoflush=False, autocommit=False, bind=engine) self.session = scoped_session(sm) self.min_sessions = min_sessions self.max_sessions = max_sessions self.session_pool = [] self.available = [] self.checkouts = {} self.sessions = local() self.lock = Semaphore()
def __init__(self, size=None, greenlet_class=None): if size is not None and size < 1: raise ValueError( 'Invalid size for pool (positive integer or None required): %r' % (size, )) Group.__init__(self) self.size = size if greenlet_class is not None: self.greenlet_class = greenlet_class if size is None: self._semaphore = DummySemaphore() else: self._semaphore = Semaphore(size)
class imap_manager(object): def __init__(self): from gevent.coros import Semaphore self.client = None self.sem = Semaphore(1) self.count = 0 def close(self, current): import gevent gevent.sleep(360) self.sem.acquire() if self.client is not None and self.count == current: self.client.close() self.client = None self.sem.release() @contextmanager def get(self): import gevent self.count += 1 self.sem.acquire() self.count += 1 if self.client is None: from rbit import config from rbit import backend from rbit import imap cfg = config.Config('config', backend.create_session) self.client = imap.IMAPClient.from_config(cfg) yield self.client self.sem.release() gevent.spawn(lambda : self.close(self.count))
class Pool(Group): def __init__(self, size=None, greenlet_class=None): if size is not None and size < 0: raise ValueError('size must not be negative: %r' % (size, )) Group.__init__(self) self.size = size if greenlet_class is not None: self.greenlet_class = greenlet_class if size is None: self._semaphore = DummySemaphore() else: self._semaphore = Semaphore(size) def wait_available(self): self._semaphore.wait() def full(self): return self.free_count() <= 0 def free_count(self): if self.size is None: return 1 return max(0, self.size - len(self)) def add(self, greenlet): self._semaphore.acquire() try: Group.add(self, greenlet) except: self._semaphore.release() raise def _discard(self, greenlet): Group._discard(self, greenlet) self._semaphore.release()
class SessionPool(object): """ This class is intended to allow for the model to be used in a threaded environment. """ def __init__(self, engine, min_sessions=10, max_sessions=25): self.engine = engine sm = sessionmaker(autoflush=False, autocommit=False, bind=engine) self.session = scoped_session(sm) self.min_sessions = min_sessions self.max_sessions = max_sessions self.session_pool = [] self.available = [] self.checkouts = {} self.sessions = local() self.lock = Semaphore() def checkin(self): self.lock.acquire() try: session = self.sessions.session if session: session.close() finally: self.lock.release() def checkout(self): self.lock.acquire() try: session = self.sessions.session = self.session() return session finally: self.lock.release()
def websocket(token): if request.environ.get('wsgi.websocket'): email = database_helper.get_active(token) if (email == None) : # return json.dumps({"success": False, "message": "Your are not signed in."}) else : websocket = request.environ['wsgi.websocket'] sema = Semaphore(0) websockets[email] = {"websocket": websocket, "sema": sema} print "websocket(): waiting at sema for [" + email + "]" sema.acquire() print "websocket(): sema for [" + email + "] passed" # return json.dumps({"success": True, "message": "Websocket connected."}) return "websocket(): done"
class HitCounter(object): def __init__(self): self.value = 0 self.lock = Semaphore(1) def __str__(self): return str(self.value) def increment(self): try: self.lock.acquire() self.value += 1 finally: self.lock.release()
def __init__(self, oc_gateway): self._oc_gateway = oc_gateway self._model_settings_update_in_progress = Semaphore() self._vol_curves = {} self._parent_symbol_to_sandbox_symbol_dict = {} self._parent_month_id_to_sandbox_month_id_dict = {} self._vol_curve_factory = VolCurveFactory(oc_gateway)
def __init__(self, socket, environ): self.origin = environ.get('HTTP_ORIGIN') self.protocol = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL') self.path = environ.get('PATH_INFO') self.fobj = socket.makefile() self._writelock = Semaphore(1) self._write = socket.sendall
def __init__(self,svc): #maxsize - 最大缓存,超过限制将视为无效解码 self.buf ='' self.conn = None self.svc = svc self.mtx = Semaphore() self.msgcnt=0 #接收消息计数
def __init__(self, sock, environ): self.rfile = sock.makefile('rb', -1) self.socket = sock self.origin = environ.get('HTTP_ORIGIN') self.protocol = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL', 'unknown') self.path = environ.get('PATH_INFO') self._writelock = Semaphore(1)
def _reset(self): ''' reset all the variables used for keeping track of internal state ''' #an list of Character()s self.results = [] #an list of strings self.str_results = [] #character generators take care of building the Character objects. we need one per row self.char_gens = [] #a queue for communications between Character()s and request_makers self.q = Queue() #"threads" that run the Character()s self.character_pool = Pool(self.concurrency) #"threads" that make requests self.request_makers = [gevent.spawn(self._request_maker) for i in range(self.concurrency)] #fire this event when shutting down self.shutting_down = Event() #do we need to add more rows? self.need_more_rows = True #use this as a lock to know when not to mess with self.results self.results_lock = Semaphore(1) #request_count is the number of requests made on the current run self.request_count = 0 #failure_count is the number of requests made on the current run self.failure_count = 0
def _init_instance(cls): _worker = SidManager.SidWorker() _instance = cls(_worker) _instance.sid_dict = dict() _instance.semaphore = Semaphore() _instance.worker.sid_mgr = _instance return _instance
def __init__(self, local_listener_ip, local_listener_port, lwm2m_server_ip, lwm2m_server_port, local_client_ip, local_client_port): self.ep_location_mapping = {} self.total_resources = {} self.res_dict = {} self.lwm2m_dm_server_ip = lwm2m_server_ip self.lwm2m_dm_server_port = lwm2m_server_port self.sem = Semaphore() self.local_listener_ip = local_listener_ip self.local_listener_port = local_listener_port self.local_client_ip_ = local_client_ip self.local_client_port = local_client_port #local_client_port #self.local_client_port_end = local_client_port_end #local_client_port self.dispatcher = EventDispatcher() self.lwm2m_resources = LWM2MResourceTree(self.dispatcher) self.registration = Registration(self.lwm2m_resources) self.read = Read(self.lwm2m_resources) self.write = Write(self.lwm2m_resources) self.write_attributes = WriteAttributes(self.lwm2m_resources) self.create_object_instance = Create(self.lwm2m_resources) self.observation = ObservationNotificationEngine( self.lwm2m_resources, self.dispatcher) self.execution = Execution(self.lwm2m_resources) self.discover = Discovery(lwm2m_resources=self.lwm2m_resources) self.observation_started = False
def __new__(cls,s): if s.id in sites: return sites[s.id] self = object.__new__(cls) sites[s.id] = self self.s = s self.connect() self._delay_on = Semaphore() self.controllers = set() self.envgroups = set() self.meters = {} for M in METERS: ml = set() self.meters[M.meter_type] = ml for d in getattr(self.s,M.meter_type+"_meters").all(): ml.add(M(d)) self.log("Startup") self.connect_monitors(do_controllers=False) signal.signal(signal.SIGINT,self.do_shutdown) signal.signal(signal.SIGTERM,self.do_shutdown) signal.signal(signal.SIGHUP,self.do_syncsched) self.running = True return self
def __init__(self, fobj, environ): self.origin = environ.get('HTTP_ORIGIN') self.protocol = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL') self.path = environ.get('PATH_INFO') self._writelock = Semaphore(1) self.fobj = fobj self._write = _get_write(fobj)
def __init__(self, svr, sock, uid, size=None): if 0: self.svr = RpcServer() self.svr = svr #self._pool = Pool(size=size) self.sock = sock if isinstance(svr, RpcClient): self.sock_addr = svr.addr else: self.sock_addr = self.sock.getpeername() self.uid = str(uid) if len(self.uid) != self.UID_LEN: raise ValueError, 'uid length error: len(uid)=%d <> %d' % ( len(uid), self.UID_LEN) self._slock = Semaphore() self._reconnected = None self.reconnect_timeout = RECONNECT_TIMEOUT #self.iter_id = itertools.cycle(xrange(MAX_INDEX)) self._next_id = 0 self._resps = {} self._proxys = WeakValueDictionary() self.stoped = True self.sock_error = False if HEARTBEAT_TIME > 0: self._heart_time = time.time() self._heart_task = spawn(self.heartbeat) self.shells = {}
def __init__(self, worker_id): # used in process of selecting jobs self.own_async_id = worker_id # database setup dbb = settings.ASYNC_DB_BACKEND if dbb=="sqlite": from db.sqlite import SQLiteDatabase self.DB = SQLiteDatabase( worker_id ) else: raise Exception("Unknown database backend defined in configuration: %r" % dbb) # serializer / deserializer self.serializer = Serializer() # caller self.PROXY = RawProxy() self._processing = True self.SEMA = Semaphore()
def _start(self, ): self.sem = Semaphore() self.sem_counter = 0 self.set_configurations() self.api.run_task(self.create_server) self.subscribe_nscl() self.api.run_task(self.subscribe_dm_server) if self.config["enable_test"]: pass # self.api.run_task(self.send_execute_command) # Uncomment to check these operations # self.api.run_task(self.send_specific_observation) # self.api.run_task(self.send_specific_observation1) # self.api.run_task(self.send_cancel_observation) #self.api.run_task(self.send_discover_resources) #self.api.run_task(self.send_write_attributes) #self.api.run_task(self.send_create) self._started()
def __init__(self, fobj, environ): self.origin = environ.get('HTTP_SEC_WEBSOCKET_ORIGIN') self.protocol = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL', 'unknown') self.path = environ.get('PATH_INFO') self._chunks = bytearray() self._first_opcode = None self._writelock = Semaphore(1) self.fobj = fobj self._write = _get_write(fobj)
def __init__(self, store, relay, backoff=None, bounce_factory=None, store_pool=None, relay_pool=None): super(Queue, self).__init__() self.store = store self.relay = relay self.backoff = backoff or self._default_backoff self.bounce_factory = bounce_factory or Bounce self.wake = Event() self.queued = [] self.queued_lock = Semaphore(1) self.queue_policies = [] self._use_pool('store_pool', store_pool) self._use_pool('relay_pool', relay_pool)
def __init__(self, url, protocols=None, version='13'): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) ThreadedClient.__init__(self, url, protocols=protocols, version=version, sock=sock) self._lock = Semaphore() self._th = Greenlet(self._receive) self._messages = Queue() self.extensions = []
def __init__(self, minimal_precision=None, max_track=None): if minimal_precision is None: minimal_precision = config.default_precision if max_track is None: max_track = config.default_track self.min_prec = minimal_precision self.max_track = max_track self.registred = deque() self.lock = Semaphore(1)
def initialize(self, *args, **kwargs): #TODO: Add documentation #TODO: This should put the DataHandler back into an 'unconfigured' state """ Called from: InstrumentAgent._handler_idle_reset InstrumentAgent._handler_idle_go_inactive InstrumentAgent._handler_stopped_reset InstrumentAgent._handler_stopped_go_inactive InstrumentAgent._handler_observatory_reset InstrumentAgent._handler_observatory_go_inactive InstrumentAgent._handler_uninitialized_initialize |--> ExternalDataAgent._start_driver """ log.debug('Initializing DataHandler...') self._glet_queue = [] self._semaphore = Semaphore() return None
def __init__(self, canvas): self.canvas = canvas self.socket = None self.connect_ts = time.time() # This buffer discards all but the newest 1024 messages self.sendbuffer = deque([], 1024) # And this is used to limit clients to X messages per tick # We start at 0 (instead of x) to add a reconnect-penalty. self.limit = Semaphore(0) self.lock = RLock()
def __new__(cls, v): if v.id in valves: return valves[v.id] self = object.__new__(cls) valves[v.id] = self self.v = v self.site = SchedSite(self.v.controller.site) self.env = EnvGroup(self.v.envgroup) self.controller = SchedController(self.v.controller) self.sched_lock = Semaphore() if self.site.qb: try: self.site.send_command("set", "output", "off", *(self.v.var.split())) except NotConnected: pass except Exception as e: raise RuntimeError(self.v.var) from e return self
def __init__(self, stream_registrar, dh_config): self._polling = False #Moved these four variables so they're instance variables, not class variables self._polling_glet = None self._dh_config = {} self._terminate_polling = None self._params = { 'POLLING_INTERVAL' : 3600, 'PATCHABLE_CONFIG_KEYS' : ['stream_id','constraints'] } self._dh_config=dh_config self._stream_registrar = stream_registrar self._semaphore=Semaphore()
def run_every(self,delay): """Initiate running the calculation and scheduling loop every @delay seconds.""" if self._run_delay is not None: self._run_delay = delay # just update return self._run_delay = delay self._run_last = now() self._running = Semaphore() self._run_result = None sd = self._run_delay.total_seconds()/10 if sd < 66: sd = 66 self._run = gevent.spawn_later(sd, connwrap,self.run_main_task, kill=False) if self._sched is not None: self._sched.kill() self._sched = gevent.spawn_later(2, connwrap,self.run_sched_task, kill=False, reason="run_every")
def __new__(cls,v): if v.id in valves: return valves[v.id] self = object.__new__(cls) valves[v.id] = self self.v = v self.site = SchedSite(self.v.controller.site) self.env = EnvGroup(self.v.envgroup) self.controller = SchedController(self.v.controller) self.sched_lock = Semaphore() if self.site.ci: try: self.site.send_command("set","output","off",*(self.v.var.split())) except NotConnected: pass return self
class BaseSensor(Greenlet, Model): """ Base class for sensors. Each sensor is associated with a Docker container by its cid (or name, if you prefer). A sensor has to be started with its `start` method, eventually, stopped with its `kill` method. Every sensor provides collected data by means of `get_data` method which returns a generator. Each call to `next` value is blocking for a time declared on `__init__` of the sensor through `spacing` parameter. """ cid = StringType(required=True) spacing = FloatType(default=0.1) @serializable def uid(self): return get_uid(self.__class__, self.cid) def __init__(self, *args, **kwargs): Greenlet.__init__(self) Model.__init__(self, *args, **kwargs) docker_url = config.get('docker_url') self.container = api.DockerAPI(self.cid, docker_url) self._lock = Semaphore() self._lock.acquire() # locking semaphore self._new_data = None @raise_connection_error def _run(self): while True: self._new_data = self._get() LOG.debug("{} got {}".format(self.uid, self._new_data)) self._store(self._new_data) self._lock.release() sleep(self.spacing) def _get(self): """Override""" return None def _store(self, data): """Override""" pass def get_data(self): while True: if not self.started or self.dead: raise SensorError("Start the sensor before getting data.") self._lock.acquire() yield self._new_data
def __init__(self, dh_config): """ Constructor for all data handlers. @param dh_config: Dictionary containing configuration parameters for the data handler """ self._polling = False # Moved these four variables so they're instance variables, not class variables self._polling_glet = None self._dh_config = {} self._terminate_polling = None self._acquiring_data = None self._params = {"POLLING_INTERVAL": 30, "PATCHABLE_CONFIG_KEYS": ["stream_id", "constraints", "stream_route"]} self._dh_config = dh_config self._semaphore = Semaphore()
def __init__(self, cps=None, cpm=None, cph=None, cpd=None, max_wait=None): self.__max_wait = max_wait self.__limits = {} if cps is not None and cps != 0: self.__limits['calls per second'] = RateLimit(cps, 1) if cpm is not None and cpm != 0: self.__limits['calls per minute'] = RateLimit(cpm, 60) if cph is not None and cph != 0: self.__limits['calls per hour'] = RateLimit(cph, 60*60) if cpd is not None and cpd != 0: self.__limits['calls per day'] = RateLimit(cpd, 60*60*24) self.__semaphore = Semaphore()
def initialize(self, *args, **kwargs): #TODO: Add documentation #TODO: This should put the DataHandler back into an 'unconfigured' state """ Called from: InstrumentAgent._handler_idle_reset InstrumentAgent._handler_idle_go_inactive InstrumentAgent._handler_stopped_reset InstrumentAgent._handler_stopped_go_inactive InstrumentAgent._handler_observatory_reset InstrumentAgent._handler_observatory_go_inactive InstrumentAgent._handler_uninitialized_initialize |--> ExternalDataAgent._start_driver """ log.debug('Initializing DataHandler...') self._glet_queue = [] self._semaphore=Semaphore() return None
class Sema: def __init__(self): self.sem = Semaphore() self.timestamp = datetime.datetime.now() self.count = 1 self.sem.acquire(blocking=True) def join(self): self.count += 1 self.sem.acquire(blocking=True) def release(self): for ii in xrange(self.count): self.sem.release()