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 __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, 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 __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 __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_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, 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, 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, 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 __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 __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 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'])
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()
def __init__(self): # Get id for web-socket session self.id = RedisConn.incr("".join([self.__class__.__name__, '_ids'])) self.output_queue = Queue() self.params = {'wssid': self.id} # Session specific parameters self.greenlets = {} # The dictionary that storages all greenlets associated with this session # except of input/output servelet handlers and main servelet function self.terminators = {} # list of functions for execute while session is terminating self._collection[self.id] = self self.semaphore = Semaphore() # use it concurent data access conditions
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, 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 test_auto_rollback(): """Test that a transaction is rolled back if it fails.""" # Start a transaction in another thread but kill it partway through sem = Semaphore(0) greenlet = gevent.spawn(slow_insert, sem) time.sleep(0.5) greenlet.kill(block=True) # Check that the database does not contain the values from the transaction names = select_names().flat assert 'five' not in names assert 'seven' not in names
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, socket, 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._writelock = Semaphore(1) self.socket = socket self._write = socket.sendall self.fobj = makefile(socket) self.close_code = None self.close_message = None self._reading = False
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)
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"
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 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 _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, 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 test_competing__routing_call(self): svc = self._make_service() p = IonProcessThread(name=sentinel.name, listeners=[], service=svc) p.start() p.get_ready_event().wait(timeout=5) sem = Semaphore() # define a callable method that tries to grab a shared semaphore def thecall(ar=None): semres = sem.acquire(blocking=False) if not semres: raise StandardError( "Could not get semaphore, routing_call/control flow is broken!" ) # make this take a sec time.sleep(1) # make sure we release sem.release() # set the ar ar.set(True) # schedule some calls (in whatever order) ar1 = AsyncResult() ar2 = AsyncResult() ar3 = AsyncResult() p._routing_call(thecall, None, ar=ar3) p._routing_call(thecall, None, ar=ar1) p._routing_call(thecall, None, ar=ar2) # wait on all the ARs to be set ar1.get(timeout=5) ar2.get(timeout=5) ar3.get(timeout=5) # just getting here without throwing an exception is the true test! p._notify_stop() p.stop()
def __init__(self, server_ip, server_port, client_ip, client_port): super(DMServerCore, self).__init__() self.lwm2m_dm_server_ip = server_ip self.lwm2m_dm_server_port = server_port self.local_client_ip_ = client_ip self.local_client_port_ = client_port self.sem = Semaphore() self.sem_counter = 0 self.lwm2m_resources = LWM2MResourceTree() self.registration = Registration(self.lwm2m_resources) self.execution = Execution(self.lwm2m_resources) self.discover = Discovery(lwm2m_resources=self.lwm2m_resources) self.observation = ObservationNotificationEngine(self.lwm2m_resources) self.read = Read(self.lwm2m_resources) self.write = Write(self.lwm2m_resources) self.create_object_instance = Create(self.lwm2m_resources) self.write_attributes = WriteAttributes(self.lwm2m_resources)
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