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)
