From 8c5f2e0f7788f57eef766d7edb2e1adf8a9fa0c8 Mon Sep 17 00:00:00 2001
From: simon987 <fortier.simon@protonmail.com>
Date: Mon, 18 Feb 2019 22:00:02 -0500
Subject: [PATCH] initial commit

---
 .gitignore                     |   4 +
 .idea/vcs.xml                  |   6 +
 __pycache__/api.cpython-37.pyc | Bin 0 -> 7733 bytes
 api.py                         | 230 +++++++++++++++++++++++++++++++++
 run.py                         |   2 +
 worker.py                      | 112 ++++++++++++++++
 6 files changed, 354 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 .idea/vcs.xml
 create mode 100644 __pycache__/api.cpython-37.pyc
 create mode 100644 api.py
 create mode 100644 run.py
 create mode 100644 worker.py

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..5f3ae1a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+.idea/
+work/
+worker.json
+
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/__pycache__/api.cpython-37.pyc b/__pycache__/api.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2340eae4473d8ab8843a6adf631d54001f23a24c
GIT binary patch
literal 7733
zcmbVRJ9r#d6`uFbKD1iP@-vB}BqU@Z_Cj!+04A}VD2ao!HnJQ$OJK6vJCb&_+F9Qj
z+0ruN%NMzzAka{{km%CT@qH9Dbkvl$rE*721OGX9-xdKf(miuuGjq@5p7Wo(S7&B&
z2Cjd#Hb41t!7%<#jlt!jas?$m01<{T+eS^_&6>$=t7h@tuGxHdYL2jKuCQyKaB3Oh
z)_mdBvgpf+Of4_`S^;A-B3moIXNa80KQu&s->S``RS+|1&7f66t0-pCnnmlFI1$c;
z$HO^MdSr`ZV(y_^o5zgfVjeT*G2?_VZyDv2kFiRl`j}Sz*aBInwqg9^t;ZSM9(zO_
zA~q2dq=7QL=#eWZ@zWroK^%fRQ&<lTaAyk#cSpGRlBY5^Wz-5ANrN7ui|$n3Mv3o&
zq^2;>7^x9Z&ElGgn$0x}HHT|9YA)9t)I6@asAah3q2_ZflNu&OkB?`o%4!PbcV#n@
z&16?Oo%&X&vW<4s34?9fR{nZ331rxfROWst<7U)R&Q_EN<#o4L+s#JVm!xx<CsH6X
zL!?M#mPm=nF_5yQoH%T+DZdp*ogi9meQC&f4E*y_Wh2@OD?;L<m3L&+U5$1sqMp<%
zZ{MnPcax2%Q%RDbyBjpx&9IYH>fPpr?ymBKpxMFlf|GblJO^T!xv9TisW06NgUJn2
z7F~3wWwV%HK_xK`%+zREC^m|N;-Yvc5LwGd$qMt4e@GT$RsRpxbIKv6l`FQly7B)k
zF;fy#EF?`%psBnh`ry`$>T{^aK8RsDX2JB$UU9&xo=`2jBqGvi5U5-bY(-+bP4z+$
z+}p0V^@t?t$umSq8)JmNCbJ+^iOJf1)6a9y*EV)%r5<liSh|h(vI^R$z($|2^n@%N
zw!RPL1Z3md+R4VXwUdo&YbP7m)}BF4Tf2{1mhC=^T8?Wuw*Gu|qzRSj>RqTZGE8JM
zj8%TCz5~<O4KGgW$#$$f88({TP|ea{J&v2}ogisq&*aA&bJ#1*wPvH9V8aBBXuFe?
z^P`Wk2<18OE1xB@K!o%upC|GHk#7)r5u|KsD>zOaBMq@~NOj*riK$;3e{o_1^kzuj
zN83K_Ru=q4RHkkJz&(V+nY4Yhb0~T2f$U%pWXHJrYKEAXf;@$f$<steeuE!m3;d7b
z;HQt=4{W-Z@WPlFqRrs*cEE<nGxNjUAkWfgpCUqT`M((cGni6F85n*+QcnYAcu^F%
zf)alQGW7D#2us)xP5Ak90zMu!M?5R?qJWwkdZ8y~9$6fd5Y^E3sURLX9FH7CxCP9a
ze`Jai;w0izuHQN(PCs-I_s)p3h#rM-Mm!~+eu!;RD{{<wPI-4Cxf#l8gTfYFbhlAh
z%`c;p(jGEWxVXSftOGl>52?pV;qU@Ch06;(-Wz7MoM8<qx882nVfd@{IJ|VRmR-Gc
zQG|_1gvyJ<2KI-_2f7kqNI3z#bJ=B^RrZ6Xkl)02B}r1*7&^*?7cm$!bTB>q6;OJ!
znwOF3QbeSS?n9nP<uFNh+-#Cqw<W)gUX@!5lg37n!2bJNsFv&R@c^ru+DRAi$onWU
zf5z+`>wkXq5=p-HaS4%4QshvEBqY!v|40|zhtY)0Yp^Vc+=6(W)J?rKllq5QM32!j
z^YQlT7J?YBGpn~c?}z8{4joosKuviY^>_pF&24v@_qM|zP9(br?L4Nq`7WOLF$&wR
zVa=PpxjsMRU$az(z6xoOTZ^~bNrRj`U34ewX2YQ%G|A1OGr>bahV2mMp_y<r6XaFo
zYapsH?hU5}PdoP}%0TeP`wN|XrE=Th{jjYvTVWj6*8x$;>B1*(b(I@8qHZ{0^Q0MG
zI>}{n>8W!_uxq3MyB)3f?Nz>k>GJzTen8}hM5aW08GW}<2J6lB*NeBTludT(UsH-j
z8A7pf64V<Fa9Qrlk&HokI=W!Xv9(Mu>PMLK(b%F+423xU#)+^?8fFm@R2zxt(3%iV
zZaqx;yL%9a*f^(zas}`B7-b-o!R{G7Jw#o!zi6-Ux5-8l<O0Ilw|={@XC~&s1o{&8
zBLw_I%QWr)u>QnYHtuTR>QsCA2kh)FFt9Qolx-bQhTaCq+JRkkIN~UWkk{A@ikf|n
zlpSp+Qxa7Lnja)lu-0scpI~x7x)cy!=nv6lV5#FXhiuw-WXLAj%#h8O`)rzr=AM<<
zDS`zsiN&bK(uhWQUtoicv74D@SB|k#CRQBz3T`7`E6?lRtJF&|S2^vdF62wpZS$xy
z*TDK}Ynt`!nvAxXZ-L1gVp;{jilW&o^$lw{rR-F3(RT9KLCOk!kQ}7^4iR#i>?q6D
z%1U|m$Pi4vSCY$8cC(X6@(9W%|3-3?WZUuzktGmSARyLkY=uY*g#3W|N5;rCMn=Tv
z6%<BBzM0G9Y~UlOWY60ryJ-7<UlPjNuCwS=marT!9snLGk1pCHRA*a#2bILwH}()J
zg|X?&1p#|atbOy8k=nw#Y;=$z=vspG3~&{h-em)I%t76`j8W_^x2g)`=}a$oI}YXf
z#dV}Mz5LztTEyqC32NLLEUIk7hMSE<UdK9A=A)(MTi0$>q4z4<TKPA4WFxE#WNKql
zA%UpkS|qpXNzfl|qc5hdZ<wCtn{$>A6&EbIf}RF-53V7``4f5u7$>xW0kLa=bC9Kn
zu5i$Dg@=|Gx?x6SfN*?~Mcc<{4x@yBfNe0E3vDVuL2e%f<+(Q(=EhJ^f%|5Fa*hKT
z&5ILwx=4NEB;KvD(5!eC?{dXi^bi(uYb9W(LC-Vd9D0t4Gm!ansz_LHMb;YtNQ*!y
zrm~UWPPjyJO{{8yA{r?Tu#hRqy$)O;)u-gkVDcB}AGp9%liwTS7<?GP7G~BNew$Dl
z75;XL3b|u)imBN|=JSQMXQh_hVdrSIfY|oz#7R-xH%)ks7R0}4%d3e8BSS{CZ+>nj
z8Pt&zQ8vVR(5OY{2cs5eM*Gg5lfvULx4CMsSkb<<0(e(XLiQ?Hx3e0F-N%2$0y##i
zOe5+fFk0p5>Dni;JMxilZX`)J=tkJc?0;PHKe2L>a3@hNP8{%HUT0OvkN_vMOFNCQ
zOBs{in;Jv%$CVF!(v3QCsAl-|V9=C5rPYia0Gm1zx6LrnYx*U|_0fPe2e%D3X60b#
z=S*Otvr{S>dkmW9H{ZeILp_l@pu&10sE`^5&=UnH*3iXq4ME0`w7dvS!3{tQ$XfSt
zaKJKltG#T6uvY~UQd!Zatl@Q#4S`ixWwq=urqiXLVNm{@2&EtcV89DprC!>wQ$mpB
zRDX>!7Psh-pk(&WOtC$JxWF&;(gs6uROntnVTKn_=`%cmXH%TWJwlRwNWRUk_6nLY
z4ODPO!g%3%JUjxkHJ`w2uzl&G{2mRwNMr#73!qqA&S?nA93Jt!e3c%Ud~}+BiYLEA
z(W$ZRnbyP~GK^{Uk3(ZutN#c**dT{U7u_kkv2aMzsg)R;mRx|4aEdVi{SXdLDo8jO
zw=jN%#}W5+QZO-YWBgMd$NoNI+`;%~JnlX@p1=W<M_>yBV#rm1Nh=9lUI>#pf)&^x
z&1iPkqJH&3U3U7<g;GYcckEi{KJq`YfQbtX!2zqX*KfQRtSm3Sy~Ns5KDDn^-@T!0
zcNUkcdd|}F@{MH~KsG=Je3Zo+Jz^=-+M~$-dzAjEo^PIp?GB68o13y>EDt>L+b`lV
z&O7Ams2!aaoWuykNSl|%3?&fG>|5}Rw%~pS0<<*w%7Kyg{nHU2o#uuR%^y&PIWE~E
zEbyr*E+%sx%?_LYn|N5h1@d*+IaTSWy_Km1!`6Fq`0}F|oBaGVV}#BAcm!k5Ji*v_
z9x`yQ^zI3)H4K6zFs&bro`A5($>O-8WeM6uuO{{Z9Ba!x<fB1yt|Ql48ZxZUB`T6~
z6LztD4gq6ar;h7HJ|#i{N)Em3go9-Pyi4PgQHCMupV1$)LqI&qJ?UCU`45gIlpl6P
zHzJ5jHZ$a$l2v*KJCe^)K{8-$X62>CXu&>l9&H`~ZylP6gHUgMVIO#hK%o@kG3qlw
za5`R+0XB7nv*+$yPTeHCX~=Z<Y?5o`0VfJ6P--%h;ymgLd(TU~TR8rvzZ6d6bz{%{
z*tmD~E(+yY@Z*`Pa<-GTH-I|r&2U%QTk*Qeism}<Qye2hg9J7;>?E)c?lP2-Qzk{(
zG2{MnQ8^o1^@g%L;RAgF<b@rM^%)8P?dB>H+Ku|FuU%5vjc`Z5o*^hh303-V@ow<`
z%F4}Pd1+<&+R`n;0c=UJvMD+e5L5ZZo7aMsYacG%xV?fyEA}&OS_AJ)UMDY!&lWje
zPHB>i;V&rsV~qhvbIvST9?(J#+q8(bgUyN@!t9-%vg=`-ZV)b@i*ml9GJk^xAFNu3
zNNh=kz*#mc_ex^p2L>2$>Lgw(!)o=RRwxb!MRqI4YW1MjEYyl0!1gjbZ>E_f54HYk
z_vxh2nt@u2tkzi^ERkZJJwNq_ip{WMGf?bxDE9hLv2qKmf>Z0@CL<zU>Uct<w!BA!
zBsyds_%%lBw4^u7X&Ot2NFp&2LVj|a$bBLYh^!DH93gjz?1I!B28E<M`3sP8|I~|h
zc9(idakU(w&0uvm31e++U#&#K4Sz$4X~P;;2}#ZA2{q<MYMe$uBdAJ=EdJ-F^Hg>f
zC-Gv2rczLiuo%NE&Rr#)x9N=a5^4mNqxM+x${vRnIp#;$4hgc#+aNuZe!5z;i^Y;(
zES@aPXXY~{ckUR^0K7u3eNw(mkFcQGagk898c3X4(92ZY0I6}berM_G?e}DpI$K0G
zha)!^tJmJvlipoiS-h@)n_%8vqM6J&^Tw*Ag&xI$@-OS3m)<0I5YwahvB>nH2H)Z%
T6HTE6{<Dko#Z$#s=8OLZbDA3_

literal 0
HcmV?d00001

diff --git a/api.py b/api.py
new file mode 100644
index 0000000..a36545a
--- /dev/null
+++ b/api.py
@@ -0,0 +1,230 @@
+import base64
+import hashlib
+import json
+
+import requests
+import hmac
+
+API_TIMEOUT = 5
+MAX_HTTP_RETRIES = 2
+VERSION = 1.0
+
+LOG_TRACE = 7
+LOG_DEBUG = 6
+LOG_INFO = 5
+LOG_WARN = 4
+LOG_ERROR = 3
+LOG_PANIC = 2
+LOG_FATAL = 1
+
+
+class Project:
+    def __init__(self, json_obj):
+        self.id: int = json_obj["id"]
+        self.priority: int = json_obj["priority"]
+        self.name: str = json_obj["name"]
+        self.clone_url: str = json_obj["clone_url"]
+        self.git_repo: str = json_obj["git_repo"]
+        self.version: str = json_obj["version"]
+        self.motd: str = json_obj["motd"]
+        self.public: bool = json_obj["public"]
+        self.secret: str
+
+    def toJSON(self):
+        return json.dumps({
+            "id": self.id, "priority": self.priority, "name": self.name,
+            "clone_url": self.clone_url, "git_repo": self.git_repo,
+            "version": self.version, "motd": self.motd, "public": self.public,
+        })
+
+
+class Task:
+    def __init__(self, json_obj):
+        self.id: int = json_obj["id"]
+        self.priority: int = json_obj["priority"]
+        self.project: Project = Project(json_obj["project"])
+        self.retries: int = json_obj["retries"]
+        self.max_retries: int = json_obj["max_retries"]
+        self.status: int = json_obj["status"]
+        self.recipe: str = json_obj["recipe"]
+        self.max_assign_time: int = json_obj["max_assign_time"]
+        self.assign_time: int = json_obj["assign_time"]
+        self.verification_count: int = json_obj["verification_count"]
+
+    def toJSON(self):
+        return json.dumps({
+            "id": self.id, "priority": self.priority,
+            "project": self.project.toJSON(), "retries": self.retries,
+            "max_retries": self.max_retries, "status": self.status,
+            "recipe": self.recipe, "max_assign_time": self.max_assign_time,
+            "verification_count": self.verification_count,
+        })
+
+
+class Worker:
+    def __init__(self, wid=None, alias=None, secret=None, api=None):
+        self.id: int = wid
+        self.alias: str = alias
+        self.secret: bytes = base64.b64decode(secret)
+        self._secret_b64 = secret
+        self._api: TaskTrackerApi = api
+
+    def fetch_task(self, project_id=None):
+        return self._api.fetch_task(self)
+
+    def submit_task(self, project, recipe, priority=1, max_assign_time=3600, hash64=0, unique_str="",
+                    verification_count=1, max_retries=3):
+        return self._api.submit_task(self, project, recipe, priority, max_assign_time, hash64, unique_str,
+                                     verification_count, max_retries)
+
+    def release_task(self, task_id: int, result: int, verification):
+        return self._api.release_task(self, task_id, result, verification)
+
+    def log(self, level: int, message: str, timestamp: int, scope: str):
+        return self._api.log(self, level, message, timestamp, scope)
+
+    def request_access(self, project: int, assign=True, submit=True):
+        return self._api.request_access(self, project, assign, submit)
+
+    def get_secret(self, project: int):
+        return self._api.get_secret(self, project)
+
+    def dump_to_file(self):
+        with open("worker.json", "w") as out:
+            json.dump({
+                "id": self.id,
+                "alias": self.alias,
+                "secret": self._secret_b64
+            }, out)
+
+    @staticmethod
+    def from_file(api):
+        with open("worker.json", "r") as f:
+            obj = json.load(f)
+            return Worker(wid=obj["id"], alias=obj["alias"],
+                          secret=obj["secret"], api=api)
+
+
+def format_headers(ua: str = None, wid: int = None, signature: str = None):
+    headers = dict()
+
+    if ua is None:
+        headers["User-Agent"] = "tt_py_client" + str(VERSION)
+    else:
+        headers["User-Agent"] = ua
+
+    headers["X-Worker-Id"] = str(wid)
+    headers["X-Signature"] = str(signature)
+
+    return headers
+
+
+class TaskTrackerApi:
+    def __init__(self, url: str):
+        self.url = url
+
+    def make_worker(self, alias) -> Worker:
+
+        response = self._http_post("/worker/create", body={"alias": alias})
+        if response:
+            json_response = json.loads(response.text)
+            print(response.text)
+
+            if response.status_code != 200:
+                raise Exception(json_response["message"])
+
+            worker = Worker(json_response["content"]["worker"]["id"], json_response["content"]["worker"]["alias"],
+                            json_response["content"]["worker"]["secret"], self)
+            return worker
+
+    def fetch_task(self, worker: Worker) -> Task:
+        response = self._http_get("/task/get", worker)
+        if response:
+            json_response = json.loads(response.text)
+            if json_response["ok"]:
+                return Task(json_response["content"]["task"])
+        return None
+
+    def submit_task(self, worker: Worker, project, recipe, priority, max_assign_time, hash64, unique_str,
+                    verification_count, max_retries):
+
+        return self._http_post("/task/submit", {
+            "project": project,
+            "recipe": recipe,
+            "priority": priority,
+            "max_assign_time": max_assign_time,
+            "hash_u64": hash64,
+            "unique_str": unique_str,
+            "verification_count": verification_count,
+            "max_retries": max_retries,
+        }, worker)
+
+    def log(self, worker: Worker, level: int, message: str, timestamp: int, scope: str):
+        if level == LOG_TRACE:
+            return self._http_post("/log/trace", {"level": level, "message": message, "timestamp": timestamp, "scope": scope}, worker)
+        if level == LOG_INFO:
+            return self._http_post("/log/info", {"level": level, "message": message, "timestamp": timestamp, "scope": scope}, worker)
+        if level == LOG_WARN:
+            return self._http_post("/log/warn", {"level": level, "message": message, "timestamp": timestamp, "scope": scope}, worker)
+        if level == LOG_ERROR:
+            return self._http_post("/log/error", {"level": level, "message": message, "timestamp": timestamp, "scope": scope}, worker)
+
+        print("Invalid log level")
+
+    def release_task(self, worker: Worker, task_id: int, result: int, verification: int):
+        return self._http_post("/task/release", {
+            "task_id": task_id,
+            "result": result,
+            "verification": verification
+        }, worker)
+
+    def request_access(self, worker: Worker, project: int, assign:bool, submit:bool):
+        return self._http_post("/project/request_access", {
+            "project": project,
+            "assign": assign,
+            "submit": submit,
+        }, worker)
+
+    def get_secret(self, worker: Worker, project: int):
+        r = self._http_get("/project/secret/" + str(project), worker)
+        if r.status_code == 200:
+            return json.loads(r.text)["content"]["secret"]
+
+    def _http_get(self, endpoint: str, worker: Worker = None):
+        if worker is not None:
+            signature = hmac.new(key=worker.secret, msg=endpoint.encode("utf8"), digestmod=hashlib.sha256).hexdigest()
+            headers = format_headers(signature=signature, wid=worker.id)
+        else:
+            headers = format_headers()
+        retries = 0
+        while retries < MAX_HTTP_RETRIES:
+            try:
+                response = requests.get(self.url + endpoint, timeout=API_TIMEOUT,
+                                        headers=headers)
+                return response
+            except:
+                retries += 1
+                pass
+        return None
+
+    def _http_post(self, endpoint: str, body, worker: Worker = None):
+
+        body_bytes = json.dumps(body).encode("utf8")
+
+        if worker is not None:
+            signature = hmac.new(key=worker.secret, msg=body_bytes, digestmod=hashlib.sha256).hexdigest()
+            headers = format_headers(signature=signature, wid=worker.id)
+        else:
+            headers = format_headers()
+        retries = 0
+        while retries < MAX_HTTP_RETRIES:
+            try:
+                response = requests.post(self.url + endpoint, timeout=API_TIMEOUT,
+                                         headers=headers, data=body_bytes)
+                return response
+            except:
+                retries += 1
+                pass
+        return None
+
+
diff --git a/run.py b/run.py
new file mode 100644
index 0000000..b2af8db
--- /dev/null
+++ b/run.py
@@ -0,0 +1,2 @@
+#!/bin/env python
+
diff --git a/worker.py b/worker.py
new file mode 100644
index 0000000..2c3330b
--- /dev/null
+++ b/worker.py
@@ -0,0 +1,112 @@
+import datetime
+import json
+import os
+import shutil
+import subprocess
+from subprocess import Popen
+
+from api import Project, Worker, TaskTrackerApi, Task
+
+
+class WorkerContext:
+
+    def _format_project_path(self, project: Project):
+        return "work/%s/%d_%s" % (self._ctx_name, project.id, project.version,)
+
+    def __init__(self, worker: Worker, ctx_name):
+        self._worker = worker
+        self._projects = dict()
+        self._ctx_name = ctx_name
+
+    def _deploy_project(self, project: Project):
+
+        project.secret = self._worker.get_secret(project.id)
+
+        print("Deploying project " + project.name)
+        path = self._format_project_path(project)
+        if os.path.exists(path):
+            shutil.rmtree(path)
+
+        os.makedirs(path, exist_ok=True)
+        proc = Popen(args=["git", "clone", project.clone_url, path])
+        proc.wait()
+
+        if project.version:
+            proc = Popen(args=["git", "checkout", project.version], cwd=os.path.abspath(path))
+            proc.wait()
+
+        if os.path.exists(os.path.join(path, "setup")):
+            proc = Popen(args=["./setup", ], cwd=os.path.abspath(path))
+            proc.wait()
+
+        self._projects[project.id] = project
+
+    def _get_project_path(self, project: Project):
+        if project.id not in self._projects or self._projects[project.id].version != project.version:
+            self._deploy_project(project)
+        return self._format_project_path(project)
+
+    def execute_task(self, task: Task):
+        path = self._get_project_path(task.project)
+
+        if os.path.exists(os.path.join(path, "run")):
+            proc = Popen(args=["./run", task.toJSON(), self._projects[task.project.id].secret],
+                         stdout=subprocess.PIPE, cwd=os.path.abspath(path))
+            result = proc.communicate()[0].decode("utf8")
+            try:
+                json_result = json.loads(result)
+                self._do_post_task_hooks(json_result)
+                print(self._worker.release_task(task.id,
+                                                json_result["result"],
+                                                json_result["verification"] if "verification" in json_result else 0).text)
+            except Exception as e:
+                print(e)
+                return
+
+    def _do_post_task_hooks(self, res):
+
+        if "logs" in res:
+            for log in res["logs"]:
+                r = self._worker.log(log["level"] if "level" in log else 7,
+                                     log["message"],
+                                     log.get("timestamp", int(datetime.datetime.utcnow().timestamp())),
+                                     log.get("scope", "tt_py_client"))
+                print("LOG: %s <%d>" % (log, r.status_code))
+
+        if "tasks" in res:
+            for task in res["tasks"]:
+                r = self._worker.submit_task(task["project"],
+                                             task["recipe"],
+                                             task.get("priority"),
+                                             task.get("max_assign_time"),
+                                             task.get("hash64"),
+                                             task.get("unique_str"),
+                                             task.get("verification_count"),
+                                             task.get("max_retries"))
+                print("SUBMIT: %s <%d>" % (task, r.status_code))
+
+
+api = TaskTrackerApi("http://localhost:42901")
+# w = api.make_worker("python_tt")
+# w.dump_to_file()
+
+w1 = Worker.from_file(api)
+
+# print(w1.request_access(1, True, True).text)
+
+
+# def submit(i):
+#     w1.submit_task(project=1, recipe=json.dumps({
+#         "tid": str(i),
+#     }), hash64=i)
+
+
+# pool = multiprocessing.Pool(processes=100)
+# pool.map(submit, range(0, 500000))
+# pool.join()
+# print(t.toJSON())
+
+t = w1.fetch_task()
+
+ctx = WorkerContext(w1, "main")
+ctx.execute_task(t)