def process(self, q_item):
if q_item.method == 'post':
json_resp = self.post(url=q_item.url,
data=json.loads(q_item.payload))
else:
json_resp = self.get(url=q_item.url)
if 'error' in session:
q_item.status = "error"
error = session.pop('error')
q_item.response = json.dumps(error)
if q_item.retry_count is None:
q_item.retry_count = 0
else:
q_item.retry_count += 1
Queue.update(q_item)
return error
else:
if q_item.cache_name:
Cache.set_data(q_item.cache_name,
json_resp,
is_unique=q_item.cache_is_unique)
q_item.status = "ok"
q_item.response = json.dumps(json_resp)
Queue.update(q_item)
return json_resp
def reserve_place(self, name, email, eventdate_id):
data = {'name': name, 'email': email, 'eventdate_id': eventdate_id}
Queue.add(f'reserve place for {name}',
url='event/reserve',
method='post',
payload=data)
return json.dumps({'message': 'Your place will be reserved'})
def add_subscription_email(self, name, email, marketing_id):
data = {'name': name, 'email': email, 'marketing_id': marketing_id}
Queue.add(f'subscribe {name}',
url='member/subscribe',
method='post',
payload=data)
return json.dumps({'message': 'Your subscription will be processed'})
def get_users(self):
Queue.add(f'get users',
url='users',
method='get',
backoff_duration=30,
cache_name="get_users",
cache_is_unique=True)
return Cache.get_data('get_users', default=[])
def queue():
form = QueueForm()
form.setup_status_filter()
if form.validate_on_submit():
queue = Queue.list_queue(form.status_filter.data)
else:
queue = Queue.list_queue("new")
return render_template('views/admin/queue.html', queue=queue, form=form)
def update_user_access_area(self, user_id, access_area):
data = {'access_area': access_area}
resp = self.post(url='user/{}'.format(user_id), data=data)
Queue.add(f'get users',
url='users',
method='get',
backoff_duration=30,
cache_name="get_users",
cache_is_unique=True,
replace=True)
return resp
def send_message(self, name, email, reason, message):
data = {
'name': name,
'email': email,
'reason': reason,
'message': message,
}
Queue.add('send message from web form',
url='send_message',
method='post',
payload=data)
return json.dumps({'message': 'Your message will be sent'})
def create_user(self, profile):
data = {
'email': profile['email'],
'name': profile['name'],
}
resp = self.post(url='user', data=data)
Queue.add(f'get users',
url='users',
method='get',
backoff_duration=30,
cache_name="get_users",
cache_is_unique=True,
replace=True)
return resp
def show_queue(_type=None, status="new"):
queue = Queue.list_queue(status)
if not _type:
queue['type'] = "show"
else:
queue['type'] = _type
return jsonify(queue)
def process_queue():
ok = 0
error = 0
for q in Queue.list_queue(["new", "error"], return_as_string=False):
api_client.process(q)
if q.status == "ok":
ok += 1
else:
error += 1
return jsonify({"ok": ok, "error": error})
def process(action, hash_item):
if action == 'delete':
Queue.delete(hash_item)
return 'deleted'
elif action == 'play':
q_item = Queue.get(hash_item)
response = api_client.process(q_item)
return jsonify(response)
elif action == 'suspend':
q_item = Queue.get(hash_item)
q_item.status = 'suspend'
Queue.update(q_item)
return f"{q_item.hash_item} {action}ed"
import fastapi_jsonrpc as jsonrpc
from fastapi.middleware.cors import CORSMiddleware
from loguru import logger
from app.errors import *
from app.queue import Queue
# JSON-RPC entrypoint
api_v1 = jsonrpc.Entrypoint("/v1")
# Server singletons: database, queue and library handler
queue = Queue('redis')
# RPC Methods
@api_v1.method(errors=[])
def allocation() -> dict:
"""Get assigned a start for your brick of TMs to compute and submit"""
logger.info("allocation requested ")
@api_v1.method(errors=[])
def submission(client: str, start_tm: int, result_map: dict) -> dict:
"""Submit your TM results for an allocated compute task"""
logger.info("submission made for {} ", start_tm)
@api_v1.method()
def network() -> dict:
"""Gets the latest volunteer network information"""
pass
def update_queue():
q = Queue.get("27f1daa58b456bb0702bae8575a9ec1e")
q.status = "error"
Queue.update(q)
return show_queue("update")
def delete_from_queue(hash_item):
Queue.delete(hash_item)
return show_queue("delete")
def add_queue2():
Queue.add("test2", "test/api2", "POST", {"test": "test2"})
return show_queue("add2")
def add_queue():
Queue.add("test", "test/api", "POST", {"test": "test"})
return show_queue(("add"))
def suspend_error_items():
return jsonify({"suspended": Queue.suspend_error_items()})
def purge_queue():
current_app.logger.info('Purging queue')
return jsonify({"deleted": Queue.purge_expired_items()})
class Subscriber:
def __init__(self, q: Queue, client: APIClient):
self.queue = q
self.client = client
def subscribe(self):
while True:
try:
for key in self.queue.peek_all_keys():
value = self.queue.get(key)
span_ctx = tracer.extract(Format.TEXT_MAP, value)
with tracer.start_active_span('subscribe', child_of=span_ctx) as scope:
scope.span.set_tag('env', ENV)
print(f'subscriber: value = {value}')
tracer.inject(scope.span, Format.HTTP_HEADERS, value)
self.client.save(key, value)
except Exception as e:
print(e)
finally:
time.sleep(LOOP_INTERVAL)
if __name__ == '__main__':
queue = Queue.create()
api_client = APIClient(host=API_HOST, port=API_PORT)
print(' === start subscriber === ')
subscriber = Subscriber(queue, api_client)
subscriber.subscribe()
