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
Esempio n. 2
0
    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
Esempio n. 3
0
 def __init__(self, svc):
     #maxsize - 最大缓存,超过限制将视为无效解码
     self.buf = ''
     self.conn = None
     self.svc = svc
     self.mtx = Semaphore()
     self.msgcnt = 0  #接收消息计数
Esempio n. 4
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)
Esempio n. 5
0
    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
Esempio n. 6
0
    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 = {}
Esempio n. 7
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
Esempio n. 8
0
 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)
Esempio n. 9
0
 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)
Esempio n. 10
0
 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)
Esempio n. 11
0
    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]
Esempio n. 12
0
    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 = []
Esempio n. 13
0
 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'])
Esempio n. 14
0
 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()
Esempio n. 15
0
 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
Esempio n. 16
0
    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
Esempio n. 17
0
 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)
Esempio n. 18
0
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
Esempio n. 19
0
 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
Esempio n. 21
0
    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()
Esempio n. 22
0
 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)
Esempio n. 23
0
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"
Esempio n. 24
0
    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()
Esempio n. 25
0
 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()
Esempio n. 27
0
 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)
Esempio n. 28
0
    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)
Esempio n. 30
0
 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