def __init__(self, balancer, reset_vm_callback, new_session_callback): # keeps track of what remote IP a server is servicing # False means there is a fresh VM ready for a new session # hosts are removed from this dict entirely during re-imaging self.srv_states = {} # TODO: lazy design, this should really be part of srv_states but then False can't # be used to denote a fresh VM self.user_datas = {} # maps remote IPs to internal IPs self.remote_sessions = {} # remote IPs that have connected recently self.temp_blacklist = set() # make sure srv_states and remote_sessions accesses stay coherent self.lock = aiorwlock.RWLock() # I noticed sometimes multiple connections would print the msg multiple times so this prevents the callback being ran more than once self.has_session_callbacked = False self.reset_vm_callback = reset_vm_callback self.new_session_callback = new_session_callback self.balancer = balancer
def __init__(self, dagMetaMfsPath, dagMetaHistoryMax=12, offline=False, unpinOnUpdate=False, autoPreviousNode=True, cipheredMeta=False, autoUpdateDates=False, loop=None, portalCacheTtl=60): super().__init__() self.loop = loop if loop else asyncio.get_event_loop() self.lock = aiorwlock.RWLock(loop=loop) self.loaded = asyncio.Future() self.portalCache = TTLCache(1, portalCacheTtl) self._curMetaEntry = None self._dagRoot = None self._dagMeta = None self._dagCid = None self._offline = offline self._dagMetaMaxHistoryItems = dagMetaHistoryMax self._dagMetaMfsPath = dagMetaMfsPath self._unpinOnUpdate = unpinOnUpdate self._autoPrevious = autoPreviousNode self._autoUpdateDates = autoUpdateDates self._cipheredMeta = cipheredMeta self.dagUpdated = AsyncSignal(str) self.available = AsyncSignal(object) self.changed.connect(lambda: ensure(self.ipfsSave()))
def __init__(self, channel, psService, gWindow, sticky=False): super(ChatRoomWidget, self).__init__(gWindow, sticky=sticky) self.lock = aiorwlock.RWLock() self.chans = ChatChannels() self.pSub = psSubscriber(f'chatroom.{channel}') self.pSub.add_async_listener(keyChatChanUserList, self.onChatChanUserList) self.pSub.add_async_listener(makeKeyPubChatTokens(channel), self.onChatTokenMessage) self.participantsModel = ParticipantsModel(self) self.participantsModel.setHorizontalHeaderLabels( ['Token', 'SpaceHandle']) self.chatView = ChatWebView(self) self.channel = channel self.subscriber = psSubscriber(psService.topic) self.psService = psService self.subscriber.add_async_listener(self.psService.psKey, self.onChatMessageReceived) self.chatWidget = QWidget() self.vLayout.addWidget(self.chatWidget) self.ui = ui_chatroom.Ui_Form() self.ui.setupUi(self.chatWidget) self.ui.hLayoutTop.addWidget(self.chatView) self.ui.hideUsersButton.clicked.connect(self.onHideUsers) self.ui.usersView.setModel(self.participantsModel) self.ui.usersView.hideColumn(0)
class ThinkAioKafkaProducer(object): g_dictConnPool = {} g_rwlock = aiorwlock.RWLock() @classmethod async def send(cls, szHost, szTopic, szMsg): if cls.g_dictConnPool.get(szHost) is None: async with cls.g_rwlock.writer: if cls.g_dictConnPool.get(szHost) is None: try: producer = AIOKafkaProducer( loop=asyncio.get_event_loop(), bootstrap_servers=szHost) await producer.start() cls.g_dictConnPool[szHost] = producer except Exception as e: await g_aio_logger.error(e) producer = cls.g_dictConnPool.get(szHost) if producer is None: return -1 try: # Produce message await producer.send_and_wait(szTopic, szMsg.encode("utf-8")) return len(szMsg) except Exception as e: del cls.g_dictConnPool[szHost] await producer.stop() return -1
async def go(): rwlock = aiorwlock.RWLock() async with rwlock.writer: print("inside writer: only one writer is possible") async with rwlock.reader: print("inside reader: multiple reader possible")
class ThinkAioMysql(object): g_dictConnPool = {} g_rwlock = aiorwlock.RWLock() @classmethod async def get_conn_pool_ex(cls, szGroup="mysql"): ret = await cls.get_conn_pool( host=ThinkConfig.get_default_config().get(szGroup, "host"), port=int(ThinkConfig.get_default_config().get(szGroup, "port")), user=ThinkConfig.get_default_config().get(szGroup, "user"), password=ThinkConfig.get_default_config().get(szGroup, "password"), db=ThinkConfig.get_default_config().get(szGroup, "db"), mincached=int(ThinkConfig.get_default_config().get_int( szGroup, "maxconnections") / 2), maxcached=int(ThinkConfig.get_default_config().get_int( szGroup, "maxconnections")), maxconnections=int(ThinkConfig.get_default_config().get( szGroup, "maxconnections")), charset="utf8", use_unicode=True) return ret @classmethod async def get_conn_pool( cls, host=ThinkConfig.get_default_config().get("mysql", "host"), port=int(ThinkConfig.get_default_config().get("mysql", "port")), user=ThinkConfig.get_default_config().get("mysql", "user"), password=ThinkConfig.get_default_config().get("mysql", "password"), db=ThinkConfig.get_default_config().get("mysql", "db"), mincached=int(ThinkConfig.get_default_config().get_int( "mysql", "maxconnections") / 2), maxcached=int(ThinkConfig.get_default_config().get_int( "mysql", "maxconnections")), maxconnections=int(ThinkConfig.get_default_config().get( "mysql", "maxconnections")), charset="utf8", use_unicode=True): szHostPortDb = "{}:{}-{}".format(host, port, db) if cls.g_dictConnPool.get(szHostPortDb) is None: async with cls.g_rwlock.writer: if cls.g_dictConnPool.get(szHostPortDb) is None: connPool = await aiomysql.create_pool( minsize=mincached, maxsize=maxcached, host=host, user=user, password=password, db=db, port=port, charset=charset, use_unicode=use_unicode) cls.g_dictConnPool[szHostPortDb] = connPool return cls.g_dictConnPool.get(szHostPortDb)
class ThinkAioRedisPool(object): g_dictConnPool = {} g_rwlock = aiorwlock.RWLock() @classmethod async def get_conn_pool_ex(cls, szGroup="redis"): ret = await cls.get_conn_pool(host=ThinkConfig.get_default_config().get(szGroup, "host") , password=ThinkConfig.get_default_config().get(szGroup, "password") , port=ThinkConfig.get_default_config().get_int(szGroup, "port") , db=ThinkConfig.get_default_config().get_int(szGroup, "db") , max_connections=int(ThinkConfig.get_default_config().get_int(szGroup, "max_connections"))) return ret @classmethod async def get_conn_pool(cls , host=ThinkConfig.get_default_config().get("redis", "host") , password=ThinkConfig.get_default_config().get("redis", "password") , port=ThinkConfig.get_default_config().get_int("redis", "port") , db=ThinkConfig.get_default_config().get_int("redis", "db") , max_connections=int(ThinkConfig.get_default_config().get_int("redis", "max_connections"))): szHostPortDb = "{}:{}-{}".format(host, port, db) if cls.g_dictConnPool.get(szHostPortDb) is None: async with cls.g_rwlock.writer: if cls.g_dictConnPool.get(szHostPortDb) is None: connPool = await cls.mk_conn_pool(host, password, port, db, max_connections) cls.g_dictConnPool[szHostPortDb] = connPool return cls.g_dictConnPool.get(szHostPortDb) @classmethod async def mk_conn_pool(cls , host='127.0.0.1' , password=None , port=6379 , db=0 , max_connections=16): szAddress = "redis://{}:{}".format(host, port) _conn_pool = await aioredis.create_pool(szAddress, db=db, password=password, minsize=2, maxsize=max_connections) return _conn_pool # async def main(): # # conn_pool = await ThinkAioRedisPool.get_default_conn_pool() # with await (await ThinkAioRedisPool.get_conn_pool_ex()) as conn: # await conn.execute('set', 'fxxxxk', get_current_time_str()) # # szVal = await conn.execute("get", "fxxxxk") # print("return val: ", szVal.decode()) # # if __name__ == '__main__': # asyncio.get_event_loop().run_until_complete(main())
async def cnt_dec(self, request): """ dec count interface :param request: :return: """ post = await request.post() logging.info('post %s', post) company_name = post.get("company") cnt = int(post.get("cnt", 0)) rwlock = self.company_lock.get(company_name, "") if not rwlock: # rwlock = locks.Lock(loop=self.loop) rwlock = aiorwlock.RWLock(loop=self.loop) self.company_lock[company_name] = rwlock # with await rwlock: async with rwlock.writer: uuid_s = uuid.uuid1().hex logging.debug("[%s]---[%s]", uuid_s, id(rwlock)) msg = dict() sql = "select * from shield.company where name=%s" po = await self.db.get(sql, company_name) if not po: # cant not found company logging.error("not found company name [%s]", company_name) msg["code"] = 404 msg["code"] = "not found company" return self.response(request, msg) po_cnt = int(po.get("count")) old_cnt = po.get("count") if po_cnt == 0: logging.error("company [%s] cnt is 0", company_name) msg["code"] = 400 msg["reason"] = "cnt is 0" return self.response(request, msg) if po_cnt < cnt: # database count is not enough logging.error("company [%s] count is not enough", company_name) msg["code"] = 405 msg["reason"] = "count is not enough" return self.response(request, msg) res = po_cnt - cnt update_sql = "update shield.company set count=%s where name=%s" args_values = [res, company_name] update_res = await self.db.execute(update_sql, args_values) if not isinstance(update_res, int): # 执行update 失败 logging.error("sql update is err:", update_res) msg["code"] = 403 msg["reason"] = "inc fail" return self.response(request, msg) logging.info( "uuid [%s] lock [%s] company [%s] dec cnt [%s] old cnt [%s] true will is [%s] success", uuid_s, id(rwlock), company_name, cnt, old_cnt, res) msg["code"] = 200 msg["reason"] = "ok" return self.response(request, msg)
def new(cls, path: pathlib.Path, logger: logging.Logger = tensorcraft.logging.internal_logger): self = cls() logger.info("Using file storage experiment engine") self.logger = logger self.rwlock = aiorwlock.RWLock() self.db = tinydb.TinyDB(path=path.joinpath("experiments.json"), default_table="experiments") return self
async def go(): rwlock = aiorwlock.RWLock() # acquire reader lock async with rwlock.reader_lock: print('inside reader lock') await asyncio.sleep(0.1) # acquire writer lock async with rwlock.writer_lock: print('inside writer lock') await asyncio.sleep(0.1)
def go(): rwlock = aiorwlock.RWLock(loop=loop) # acquire reader lock with (yield from rwlock.reader_lock): print("inside reader lock") yield from asyncio.sleep(0.1, loop=loop) # acquire writer lock with (yield from rwlock.writer_lock): print("inside writer lock") yield from asyncio.sleep(0.1, loop=loop)
def __init__(self, ctx): super().__init__() self.app = QApplication.instance() self.ctx = ctx self.lock = aiorwlock.RWLock() self.evStopWatcher = asyncio.Event() self._byPeerId = collections.OrderedDict() self._byHandle = collections.OrderedDict() self._didGraphLStatus = [] self._didAuthInp = {} self._pgScanCount = 0 self.peerAuthenticated.connectTo(self.onPeerAuthenticated)
async def go(): rwlock = aiorwlock.RWLock() # acquire reader lock await rwlock.reader_lock.acquire() try: print('inside reader lock') await asyncio.sleep(0.1) finally: rwlock.reader_lock.release() # acquire writer lock await rwlock.writer_lock.acquire() try: print('inside writer lock') await asyncio.sleep(0.1) finally: rwlock.writer_lock.release()
def go(): rwlock = aiorwlock.RWLock(loop=loop) # acquire reader lock yield from rwlock.reader_lock.acquire() try: print("inside reader lock") yield from asyncio.sleep(0.1, loop=loop) finally: yield from rwlock.reader_lock.release() # acquire writer lock yield from rwlock.writer_lock.acquire() try: print("inside writer lock") yield from asyncio.sleep(0.1, loop=loop) finally: yield from rwlock.writer_lock.release()
async def new(cls, storage: AbstractStorage, preload: bool = False, logger: logging.Logger = internal_logger): self = cls() self.logger = logger self.storage = storage self.lock = aiorwlock.RWLock() self.models = {} self.storage.on_save.append(self.save_to_cache) self.storage.on_delete.append(self.delete_from_cache) if not preload: return self async for m in self.all(): logger.info("Loading {0} model".format(m)) await self.unsafe_load(m.name, m.tag) return self
async def cnt_set(self, request): """ set count interface :param request: :return: """ post = await request.post() logging.info('post %s', post) company_name = post.get("company") cnt = post.get("cnt") sql = "update shield.company set count=%s where name=%s" args_values = [cnt, company_name] rwlock = self.company_lock.get(company_name, "") if not rwlock: # rwlock = locks.Lock(loop=self.loop) rwlock = aiorwlock.RWLock(loop=self.loop) self.company_lock[company_name] = rwlock # with await rwlock: async with rwlock.writer: msg = dict() po_sql = "select * from shield.company where name=%s" po = await self.db.get(po_sql, company_name) if not po: # cant not found company logging.error("not found company name [%s]", company_name) msg["code"] = 404 msg["code"] = "not found company" return self.response(request, msg) res = await self.db.execute(sql, args_values) if not isinstance(res, int): logging.error("sql update is err:", res) msg["code"] = 403 msg["reason"] = "set fail" return self.response(request, msg) logging.info("company [%s] set cnt [%s] is success", company_name, cnt) msg["code"] = 200 msg["reason"] = "ok" return self.response(request, msg)
class ThinkAioPG(object): g_dictConnPool = {} g_rwlock = aiorwlock.RWLock() @classmethod async def get_conn_pool_ex(cls, szGroup="postgresql"): ret = await cls.get_conn_pool(host=ThinkConfig.get_default_config().get(szGroup, "host") , port=int(ThinkConfig.get_default_config().get(szGroup, "port")) , user=ThinkConfig.get_default_config().get(szGroup, "user") , password=ThinkConfig.get_default_config().get(szGroup, "password") , db=ThinkConfig.get_default_config().get(szGroup, "db") , mincached=int( ThinkConfig.get_default_config().get_int(szGroup, "maxconnections") / 2) , maxcached=int(ThinkConfig.get_default_config().get_int(szGroup, "maxconnections")) , maxconnections=int( ThinkConfig.get_default_config().get(szGroup, "maxconnections")) , charset="utf8" , use_unicode=True) return ret @classmethod async def get_conn_pool(cls , host=ThinkConfig.get_default_config().get("postgresql", "host") , port=int(ThinkConfig.get_default_config().get("postgresql", "port")) , user=ThinkConfig.get_default_config().get("postgresql", "user") , password=ThinkConfig.get_default_config().get("postgresql", "password") , db=ThinkConfig.get_default_config().get("postgresql", "db") , mincached=int(ThinkConfig.get_default_config().get_int("postgresql", "maxconnections") / 2) , maxcached=int(ThinkConfig.get_default_config().get_int("postgresql", "maxconnections")) , maxconnections=int(ThinkConfig.get_default_config().get("mysql", "maxconnections")) , charset="utf8" , use_unicode=True): szHostPortDb = "{}:{}-{}".format(host, port, db) if cls.g_dictConnPool.get(szHostPortDb) is None: async with cls.g_rwlock.writer: if cls.g_dictConnPool.get(szHostPortDb) is None: dsn = 'dbname={} user={} password={} host={} port={}'.format(db, user, password, host, port) connPool = await aiopg.create_pool( dsn = dsn , minsize=mincached , maxsize=maxcached) cls.g_dictConnPool[szHostPortDb] = connPool return cls.g_dictConnPool.get(szHostPortDb) # async def main(): # with await (await ThinkAioPG.get_conn_pool_ex()) as conn: # cur = await conn.cursor(cursor_factory=psycopg2.extras.DictCursor) # # await cur.execute("SELECT 1 as fxxk") # ret = [] # async for row in cur: # ret.append(dict(row)) # # print(ret) # # # await cur.execute("INSERT INTO t_test_col(id, name, score) VALUES (%s, %s, %s)", (1024001, "Thinkman Wang", 99)) # # if __name__ == '__main__': # loop = asyncio.get_event_loop() # loop.run_until_complete(main())
def __init__( self, _callable: Callable, deployment_name: str, replica_tag: ReplicaTag, deployment_config: DeploymentConfig, user_config: Any, version: DeploymentVersion, is_function: bool, controller_handle: ActorHandle, ) -> None: self.deployment_config = deployment_config self.deployment_name = deployment_name self.replica_tag = replica_tag self.callable = _callable self.is_function = is_function self.user_config = user_config self.version = version self.rwlock = aiorwlock.RWLock() user_health_check = getattr(_callable, HEALTH_CHECK_METHOD, None) if not callable(user_health_check): def user_health_check(): pass self.user_health_check = sync_to_async(user_health_check) self.num_ongoing_requests = 0 self.request_counter = metrics.Counter( "serve_deployment_request_counter", description= ("The number of queries that have been processed in this replica." ), tag_keys=("deployment", "replica"), ) self.request_counter.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.error_counter = metrics.Counter( "serve_deployment_error_counter", description=( "The number of exceptions that have occurred in this replica." ), tag_keys=("deployment", "replica"), ) self.error_counter.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.restart_counter = metrics.Counter( "serve_deployment_replica_starts", description= ("The number of times this replica has been restarted due to failure." ), tag_keys=("deployment", "replica"), ) self.restart_counter.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.processing_latency_tracker = metrics.Histogram( "serve_deployment_processing_latency_ms", description="The latency for queries to be processed.", boundaries=DEFAULT_LATENCY_BUCKET_MS, tag_keys=("deployment", "replica"), ) self.processing_latency_tracker.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.num_processing_items = metrics.Gauge( "serve_replica_processing_queries", description="The current number of queries being processed.", tag_keys=("deployment", "replica"), ) self.num_processing_items.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.restart_counter.inc() self._shutdown_wait_loop_s = deployment_config.graceful_shutdown_wait_loop_s if deployment_config.autoscaling_config: process_remote_func = controller_handle.record_autoscaling_metrics.remote config = deployment_config.autoscaling_config start_metrics_pusher( interval_s=config.metrics_interval_s, collection_callback=self._collect_autoscaling_metrics, metrics_process_func=process_remote_func, ) # NOTE(edoakes): we used to recommend that users use the "ray" logger # and tagged the logs with metadata as below. We now recommend using # the "ray.serve" 'component logger' (as of Ray 1.13). This is left to # maintain backwards compatibility with users who were using the # existing logger. We can consider removing it in Ray 2.0. ray_logger = logging.getLogger("ray") for handler in ray_logger.handlers: handler.setFormatter( logging.Formatter( handler.formatter._fmt + f" component=serve deployment={self.deployment_name} " f"replica={self.replica_tag}"))
registered_members = {} # Format = {<Post>: {<Student Number>: (<Candidate Object>, <Email>), ...}, ...} standing = {} # Format = {<Title>: <Description>, ...} referenda = {} referendum_options = [Candidate('For'), Candidate('Against')] # Format = {<Student Number>: <Preferred Name>, ...} preferred_names = {} # Format = {<User ID>: [(<Candidate Student ID>, <Message ID>), ...], ...} voting_messages = {} current_live_post_lock = aiorwlock.RWLock() votes_lock = aiorwlock.RWLock() voted_lock = asyncio.Lock() def get_members(): members = society_members.get_members() members[0] = 'RON (Re-Open-Nominations)' # Substitute preferred names for id in preferred_names: members[id] = preferred_names[id] return members def save_voters():
def new(cls, path: pathlib.Path): self = cls() self._rw_lock = aiorwlock.RWLock() self._db = tinydb.TinyDB(path=path.joinpath("metadata.json"), default_table="metadata") return self
def __init__(self, p): self.rwlock = aiorwlock.RWLock() self.inner = p
async def write_locked(self): async with self._rw_lock.writer_lock: db = FsModelsMetadata() db._db = self._db db._rw_lock = aiorwlock.RWLock(fast=True) yield db
def __init__( self, _callable: Callable, deployment_name: str, replica_tag: ReplicaTag, deployment_config: DeploymentConfig, user_config: Any, version: DeploymentVersion, is_function: bool, controller_handle: ActorHandle, ) -> None: self.deployment_config = deployment_config self.deployment_name = deployment_name self.replica_tag = replica_tag self.callable = _callable self.is_function = is_function self.user_config = user_config self.version = version self.rwlock = aiorwlock.RWLock() user_health_check = getattr(_callable, HEALTH_CHECK_METHOD, None) if not callable(user_health_check): def user_health_check(): pass self.user_health_check = sync_to_async(user_health_check) self.num_ongoing_requests = 0 self.request_counter = metrics.Counter( "serve_deployment_request_counter", description=("The number of queries that have been " "processed in this replica."), tag_keys=("deployment", "replica"), ) self.request_counter.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.error_counter = metrics.Counter( "serve_deployment_error_counter", description=("The number of exceptions that have " "occurred in this replica."), tag_keys=("deployment", "replica"), ) self.error_counter.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.restart_counter = metrics.Counter( "serve_deployment_replica_starts", description=("The number of times this replica " "has been restarted due to failure."), tag_keys=("deployment", "replica"), ) self.restart_counter.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.processing_latency_tracker = metrics.Histogram( "serve_deployment_processing_latency_ms", description="The latency for queries to be processed.", boundaries=DEFAULT_LATENCY_BUCKET_MS, tag_keys=("deployment", "replica"), ) self.processing_latency_tracker.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.num_processing_items = metrics.Gauge( "serve_replica_processing_queries", description="The current number of queries being processed.", tag_keys=("deployment", "replica"), ) self.num_processing_items.set_default_tags({ "deployment": self.deployment_name, "replica": self.replica_tag }) self.restart_counter.inc() self._shutdown_wait_loop_s = deployment_config.graceful_shutdown_wait_loop_s if deployment_config.autoscaling_config: config = deployment_config.autoscaling_config start_metrics_pusher( interval_s=config.metrics_interval_s, collection_callback=self._collect_autoscaling_metrics, controller_handle=controller_handle, ) ray_logger = logging.getLogger("ray") for handler in ray_logger.handlers: handler.setFormatter( logging.Formatter( handler.formatter._fmt + f" component=serve deployment={self.deployment_name} " f"replica={self.replica_tag}"))
def __init__(self, upstreams=None): self.upstreams = dict([(s, dict()) for s in Status]) if upstreams: self.upstreams[Status.WORKING] = upstreams self.rwlock = aiorwlock.RWLock() self.logger = logging.getLogger(self.__class__.__name__)