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
