def load_hourly_cron_jobs(self): orders = self._get_cron_orders(bill_methods=['hour'], region_id=cfg.CONF.region_name) for order in orders: if not order['cron_time']: continue elif isinstance(order['cron_time'], basestring): cron_time = timeutils.parse_strtime( order['cron_time'], fmt=ISO8601_UTC_TIME_FORMAT) else: cron_time = order['cron_time'] # create cron job danger_time = (datetime.datetime.utcnow() + datetime.timedelta(seconds=30)) if cron_time > danger_time: self._create_cron_job(order['order_id'], start_date=cron_time) else: LOG.warning( "The order(%s) is in danger time after master " "started", order['order_id']) while cron_time <= danger_time: cron_time += datetime.timedelta(hours=1) cron_time -= datetime.timedelta(hours=1) action_time = utils.format_datetime( timeutils.strtime(cron_time)) self._create_bill(self.ctxt, order['order_id'], action_time, "System Adjust") self.locks[order['order_id']] = gthreading.Lock()
def __init__(self, max_workers=1000): assert EVENTLET_AVAILABLE, 'eventlet is needed to use a green executor' if max_workers <= 0: raise ValueError("Max workers must be greater than zero") self._max_workers = max_workers self._pool = greenpool.GreenPool(self._max_workers) self._delayed_work = greenqueue.Queue() self._shutdown_lock = greenthreading.Lock() self._shutdown = False
def set_lp(self, url, server): #logging.info('set_lp ' + url + ' ' + server) try: info = self.bitHopper.pool.get_entry(server) info['lp_address'] = url if server not in self.polled: self.polled[server] = threading.Lock() eventlet.spawn_n(self.pull_lp, url, server) except Exception, e: logging.info('set_lp error') logging.info(e)
def __init__(self, max_workers=1000): eu.check_for_eventlet( RuntimeError('Eventlet is needed to use a green' ' executor')) if max_workers <= 0: raise ValueError("Max workers must be greater than zero") self._max_workers = max_workers self._pool = greenpool.GreenPool(self._max_workers) self._delayed_work = greenqueue.Queue() self._shutdown_lock = greenthreading.Lock() self._shutdown = False self._gatherer = _Gatherer(self._submit, lock_cls=greenthreading.Lock)
def create_canvas(): canvas = Canvas() lock = threading.Lock() global room_counter with room_lock: room_id = hashids.encode(room_counter) rooms[room_id] = (canvas, lock) room_counter += 1 return jsonify({'room': room_id})
def set_owner(self, server, block=None): with self.lock: hook_start = plugins.Hook('plugins.lp.set_owner.start') hook_start.notify(self, server, block) if block == None: if self.lastBlock == None: return block = self.lastBlock old_owner = self.blocks[block]["_owner"] if old_owner and self.pool.servers[server][ 'coin'] != self.pool.servers[old_owner]['coin']: return self.blocks[block]["_owner"] = server if server not in self.blocks[block]: self.blocks[block][server] = 0 if '_defer' in self.blocks[block]: old_defer = self.blocks[block]['_defer'] else: old_defer = None new_defer = threading.Lock() new_defer.acquire() self.blocks[block]['_defer'] = new_defer if old_defer: old_defer.release() logging.info('Setting Block Owner ' + server + ':' + str(block)) if server in self.bitHopper.pool.servers and self.bitHopper.pool.servers[ server]['role'] == 'mine_lp' and old_owner != server: old_shares = self.bitHopper.pool.servers[server]['shares'] self.bitHopper.pool.servers[server]['shares'] = 0 self.bitHopper.scheduler.reset() self.bitHopper.select_best_server() eventlet.spawn_n(self.api_check, server, block, old_shares) #If We change servers trigger a LP. if old_owner != server: #Update list of valid server self.bitHopper.server_update() #Figure out which server to source work from source_server = self.bitHopper.pool.get_work_server() work, _, source_server = self.bitHopper.work.jsonrpc_getwork( source_server, []) #Trigger the LP Callback with the new work. self.bitHopper.lp_callback.new_block(work, source_server) hook_end = plugins.Hook('plugins.lp.set_owner.end') hook_end.notify(self, server, block)
def test_foreign_thread(self): # Check that a "foreign" thread can use the threading module. def f(mutex): # Acquiring an RLock forces an entry for the foreign # thread to get made in the threading._active map. r = threading.RLock() r.acquire() r.release() mutex.release() mutex = threading.Lock() mutex.acquire() tid = thread.start_new_thread(f, (mutex, )) # Wait for the thread to finish. mutex.acquire() self.assert_(tid in threading._active) self.assert_(isinstance(threading._active[tid], threading._DummyThread)) del threading._active[tid]
def load_monthly_cron_jobs(self): """Load monthly cron jobs Because owed monthly resource will not cron again, so there is no need to load owed monthly resources """ # owed="" will be tranlated to owed=False by wsme orders = self._get_cron_orders(bill_methods=['month', 'year'], owed="") for order in orders: if not order['cron_time']: continue elif isinstance(order['cron_time'], basestring): cron_time = timeutils.parse_strtime( order['cron_time'], fmt=ISO8601_UTC_TIME_FORMAT) else: cron_time = order['cron_time'] # Because if not specify run_date for date_time job or the # specified run_date is less than the current time, the date # time job will use the current time, so there is no need to # distinguish the danger_time self._create_monthly_job(order['order_id'], run_date=cron_time) self.locks[order['order_id']] = gthreading.Lock()
def lock_object(*args, **kwargs): return greenthreading.Lock(*args, **kwargs)
def __init__(self, pending): self.event = greenthreading.Event() self.lock = greenthreading.Lock() self.pending = pending
def _make_lock(self): return greenthreading.Lock()
def lock_object(self): return green_threading.Lock()
from flask import Flask, render_template, Response, abort, jsonify, request import flask_socketio from flask_socketio import SocketIO, join_room, emit, send from canvas import Canvas from eventlet.green import threading from hashids import Hashids app = Flask(__name__) socketio = SocketIO(app) hashids = Hashids(salt='when the full moon shines, i eat cucumber', min_length=6, alphabet='abcdefghijklmnopqrstuvwxyz1234567890') rooms = {} room_lock = threading.Lock() room_counter = 0 @app.route('/') def index(): return render_template('create.html') @app.route('/canvas', methods=['POST']) def create_canvas(): canvas = Canvas() lock = threading.Lock() global room_counter with room_lock:
def _get_lock(self, order_id): if order_id not in self.locks: self.locks[order_id] = gthreading.Lock() return self.locks.get(order_id)