def start(self): # create it if it doesn't exist already if not os.path.exists(QUIPT_VP_DESTINATION_FOLDER_PATH): os.mkdir(QUIPT_VP_DESTINATION_FOLDER_PATH) msg = "Set the folder where the quipt_system's Virtual Printer is saving the PDFs to: '" + QUIPT_VP_DESTINATION_FOLDER_PATH + "'" display_alert(msg, blocking=True) self.observer.schedule(QuiptPDFHandler(), QUIPT_VP_DESTINATION_FOLDER_PATH) self.observer.start() print("\n" + timestamp() + ready_text, flush=True) # The observer will keep observing in its own thread. # We are artificially keepthing this main thread alive # because if it finishes execution, python will kill all # its child threads too, which includes the observer's thread. # We just want this main thread to be alive through any means. try: while True: time.sleep(5) except KeyboardInterrupt: print(timestamp() + ": Closing all threads, please wait...", flush=True) self.observer.stop() self.observer.join() print(timestamp() + ": Done") except: print(timestamp() + ": An error occured while running: " + __file__, flush=True) display_alert(r"An error occured while running: " + __file__, blocking=False) self.observer.stop() self.observer.join()
def xrp_transfer(order): """ pretty wrap the asyncio xrp transfer """ # FIXME log this event timestamp() line_number() print("\nORDER\n\n", {k: v for k, v in order.items() if k != "private"}, "\n") event = asyncio.get_event_loop().run_until_complete(xrp_transfer_execute(order)) print(it("red", "XRP TRANSFERRED")) return event
def eos_transfer(order): """ serialize, sign, and broadcast an order dictionary with nine keys """ # FIXME log this event timestamp() line_number() print("\nORDER\n\n", {k: v for k, v in order.items() if k != "private"}, "\n") nodes = eosio_nodes() while 1: nodes.append(nodes.pop(0)) node = nodes[0] # configure the url and port eosio_config.url = node eosio_config.port = "" print("\nADDRESS\n\n", node, "\n") # assemble the transfer operation dictionary operation = { "from": order["public"], "memo": "", # eos must have 4 decimal places formatted as string with space and "EOS" "quantity": precisely(order["quantity"], 4) + " EOS", "to": order["to"], } print("\nOPERATION\n\n", operation, "\n") # serialize the transfer operation raw = RawinputParams( "transfer", # the operation type operation, # the parameters "eosio.token", # the contract; for our purposes always "eosio.token" order["public"] + "@active", # the permitted party (or @owner) ) print("\nSERIALIZE\n\n", raw.params_actions_list, "\n") # sign the transfer operation params = EosioParams(raw.params_actions_list, order["private"]) print("\nSIGN\n\n", params.trx_json, "\n") # broadcast the transfer to the network try: ret = NodeNetwork.push_transaction(params.trx_json) print("\nBROADCAST\n\n", ret) if "processed" not in ret.keys(): raise ValueError("NOT PROCESSED") print(it("red", "EOS TRANSFERRED")) break except Exception as error: print(error) print(it("red", "BROADCAST FAILED"), node, "attempting new api...") continue return ret
def submit_problem_hook(): ret = problem.submit_problem(session['tid'], request, session['is_zju_user']) tstamp = utilities.timestamp(datetime.utcnow()) if tstamp > scoreboard.ctf_end: ret['message'] = '[比赛已经结束] %s' % ret['message'] ret['status'] = 0 ret['sore'] = 0 return ret
def verify_ripple_account(account): """ ripple public api consensus of get_account() returns True or False on existance """ data = json_dumps({ "method": "account_info", "params": [{ "account": account, "strict": True, "ledger_index": "current", "queue": True, }], }) ret = get(URL, data=data).json()["result"] timestamp() line_number() print(ret, "\n") is_account = False if "account_data" in ret.keys(): is_account = True return is_account
def recycler(): """ in a background process, check incoming accounts & move funds to outbound accounts """ networks = ["eos", "xrp"] print(it("red", f"INITIALIZING RECYCLER\n"), "networks:", networks, "\n") while 1: for network in networks: order = {} # EOS specific parameters if network == "eos": nil = NIL_EOS get_balance = eos_balance transfer = eos_transfer # XRP specific parameters elif network == "xrp": nil = NIL_XRP get_balance = xrp_balance transfer = xrp_transfer # recycle gateway incoming transfers to the outbound account for idx, gate in enumerate(GATE[network]): if idx: balance = get_balance(gate["public"]) if balance > nil: timestamp() line_number() print(it("red", f"{network} RECYCLER")) print(gate["public"], balance, "\n") # finalize the order order["private"] = gate["private"] order["public"] = gate["public"] order["to"] = GATE[network][0]["public"] order["quantity"] = balance - nil # serialize, sign, and broadcast print(transfer(order), "\n") time.sleep(60)
def get_package_source_dir(args): """Get the sources for a package. PKGBUILDs contain instructions for downloading sources and then building them. We don't want to download the sources before every build, so this function downloads sources and stores them in a standard location so that they can be copied later rather than re-downloaded. If this function returns successfully, the abs directory for package will have been copied to sources_directory, and the sources for that package will have been downloaded into it. """ if not os.path.isdir(args.abs_dir): die(Status.failure, "Could not find abs directory for dir '%s'" % args.abs_dir) shutil.copytree(args.abs_dir, args.permanent_source_dir) recursive_chown(args.permanent_source_dir) os.chdir(args.permanent_source_dir) # The --nobuild flag to makepkg causes it to download sources, but # not build them. command = ( "sudo -u tuscan makepkg --nobuild --syncdeps " "--skipinteg --skippgpcheck --skipchecksums " "--noconfirm --nocolor --log --noprogressbar " "--nocheck --nodeps" ) time = timestamp() cp = subprocess.run(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) log("command", command, cp.stdout.splitlines(), time) success = False if cp.returncode: shutil.rmtree(args.permanent_source_dir) else: success = True return success
def initialize_repositories(args): """Point pacman to toolchain builds. Ensure that pacman only installs toolchain builds of packages during the build process by pointing pacman.conf to the toolchain repository. """ # Point pacman to our toolchain repository. This means commenting # out the official repositories in pacman.conf, and creating a new # entry for the local toolchain repository. lines = [] with open("/etc/pacman.conf") as f: appending = True for line in f: if re.search("# REPOSITORIES", line): appending = False if appending: lines.append(line.strip()) lines.append("[%s]" % toolchain_repo_name()) lines.append("Server = file://%s" % args.toolchain_directory) with open("/etc/pacman.conf", "w") as f: for line in lines: print(line, file=f) log("info", "Removed vanilla repositories from pacman.conf and added:", lines[-2:]) command = "pacman -Syy --noconfirm" time = timestamp() cp = subprocess.run(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) log("command", command, cp.stdout.splitlines(), time) if cp.returncode: die(Status.failure)
print_to_LL(current_order_pick_list_path) # Even Page/2n -> LL print_to_PP(current_order_packing_slip_path) # Odd Page/1n -> PP print_to_PP(current_order_pick_list_path) # Even Page/2n -> PP else: print_to_LL_stub(current_order_pick_list_path) # Even Page/2n -> LL print_to_PP_stub(current_order_packing_slip_path) # Odd Page/1n -> PP print_to_PP_stub(current_order_pick_list_path) # Even Page/2n -> PP # delete source pdf try: os.remove(path_to_source_pdf) print(timestamp() + ": Received PDF at path deleted: '" + path_to_source_pdf + "'", flush=True) except Exception as exp: error_msg = timestamp() + ": " + __file__ + ": error while deleting source pdf at: '" + path_to_source_pdf + "'" print(error_msg, flush=True) # display_alert(error_msg, blocking=False) print("\n" + timestamp() + ready_text, flush=True) # Close the Preview window opened by the 'PDF Printer' script = r'tell application "System Events" to click first button of (first window of process "Preview")' p = Popen(['osascript', '-'], stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True) stdout, stderr = p.communicate(script) if __name__ == '__main__': print("\n\n" + timestamp() + ": " + __file__ + " started") w = QuiptWatcher() w.start()
def copy_and_build(args): try: shutil.copytree(args.permanent_source_dir, args.build_dir) except shutil.Error as e: # e.args will be a list, containing a single list of 3-tuples. # We are interested in the third item of each tuple. errors = [err[2] for err in e.args[0]] die(Status.failure, "No source directory in source volume: %s" % args.permanent_source_dir, output=errors) recursive_chown(args.build_dir) os.chdir(args.build_dir) proc = subprocess.Popen(["/usr/bin/sloccount", "src"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out, _ = proc.communicate() output = codecs.decode(out, errors="replace") if proc.returncode: log("die", "SLOCCount failed", output.splitlines()) else: log_sloc(output.splitlines()) # Add the --host option to invocations of ./configure with open("PKGBUILD", encoding="utf-8") as f: pkgbuild = f.read().splitlines() pkgbuild = [re.sub(r"configure\s", "configure --host x86_64-unknown-linux ", line) for line in pkgbuild] with open("PKGBUILD", "w", encoding="utf-8") as f: f.write("\n".join(pkgbuild)) # The difference between this invocation and the one in # get_package_source_dir() is the --noextract flag. Sources should # already have been downloaded and extracted by # get_package_source_dir(), so we just want to build them. # # Also, the invocation in get_package_source_dir has the --nodeps # option, since we just wanted to download sources there. Here, we # do want to install dependencies (from our local toolchain # repository), so don't pass the --nodeps flag. if args.env_vars == None: args.env_vars = [] command_env = os.environ.copy() for pair in args.env_vars: var, val = pair.split("=") command_env[var] = val command = ( "sudo -u tuscan " + " ".join(args.env_vars) + " bear makepkg --noextract --syncdeps" " --skipinteg --skippgpcheck --skipchecksums" " --noconfirm --nocolor --log --noprogressbar" " --nocheck" ) time = timestamp() proc = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=command_env) stdout_data, _ = proc.communicate() output = codecs.decode(stdout_data, errors="replace") log("command", command, output.splitlines(), time) # Pick up output left by bear if os.path.exists("compile_commands.json"): with open("compile_commands.json") as f: bear_output = json.load(f) log("bear", "bear", output=bear_output) else: log("die", "No bear output found in dir '%s'" % os.getcwd()) native_tools = {} for native in glob("/tmp/tuscan-native-*"): with open(native) as f: tool = f.readlines() if tool: tool = tool[0].strip() if tool not in native_tools: native_tools[tool] = 0 native_tools[tool] += 1 if native_tools: log("native_tools", "native_tools", native_tools) return proc.returncode
def on_created(event): path_to_source_pdf = event.src_path # When 'PDF Printer' starts "printing" the pdf to the # folder, this method is fired before 'PDF Printer' completes writing the pdf. So we add some # delay to give (more than) enough time to 'PDF Printer' to complete writing the pdf. print(timestamp() + ": Started receiving Quipt-PDF at: '" + path_to_source_pdf + "'", flush=True) print(timestamp() + ": Waiting for " + str(WAIT_TIME_DUE_TO_VP_SAVING_THE_FILE) + " seconds to complete the reception...", flush=True) time.sleep(WAIT_TIME_DUE_TO_VP_SAVING_THE_FILE) # From here on, you can (with very high probability) safely do whatever you want with the source pdf: print(timestamp() + ": Done waiting. Splitting Quipt-PDF received at: '" + path_to_source_pdf + "'", flush=True) # create it if it doesn't exist already if not os.path.exists(SPLIT_QUIPT_PDF_TARGET): os.mkdir(SPLIT_QUIPT_PDF_TARGET) # delete the old contents of the split_quipt_pdf_target to keep its size from # growing indefinitely, old contents are not of use for anything at this point: try: empty_dir(SPLIT_QUIPT_PDF_TARGET) print(timestamp() + ": Deleting all contents of dir at: '" + SPLIT_QUIPT_PDF_TARGET + "'", flush=True) except Exception as expp: error_msg = timestamp() + ": " + __file__ + ": error while deleting deleting all contents of dir at: '" + SPLIT_QUIPT_PDF_TARGET + "'" print(error_msg, flush=True) pages_paths = None try: # extract individual pages from the pdf pages_paths = pdf_to_pages(path_to_source_pdf, SPLIT_QUIPT_PDF_TARGET) print(timestamp() + ": File at '" + path_to_source_pdf + "' split successfuly to '" + SPLIT_QUIPT_PDF_TARGET + "'", flush=True) except Exception as e: # if any error occurs, proceed to deleting the source pdf error_msg = timestamp() + ": " + __file__ + ": error while splitting the received pdf into individual pages." print(error_msg, flush=True) # display_alert(error_msg, blocking=False) if pages_paths != None: # splitting was successful page_count = len(pages_paths) # quipt-pdfs have even number of pages, if a pdf with odd number of pages is received, do nothing with it if page_count % 2 == 0: for page_no in range(1, page_count+1, 2): # processing one page-pair per iteration of the loop current_order_packing_slip_path = pages_paths[page_no] # Odd Page/1n current_order_pick_list_path = pages_paths[page_no+1] # Even Page/2n # the collation happens in this piece of code: if PRINT_TO_PHYSICAL_PRINTER: print_to_LL(current_order_pick_list_path) # Even Page/2n -> LL print_to_PP(current_order_packing_slip_path) # Odd Page/1n -> PP print_to_PP(current_order_pick_list_path) # Even Page/2n -> PP else: print_to_LL_stub(current_order_pick_list_path) # Even Page/2n -> LL print_to_PP_stub(current_order_packing_slip_path) # Odd Page/1n -> PP print_to_PP_stub(current_order_pick_list_path) # Even Page/2n -> PP # delete source pdf try: os.remove(path_to_source_pdf) print(timestamp() + ": Received PDF at path deleted: '" + path_to_source_pdf + "'", flush=True) except Exception as exp: error_msg = timestamp() + ": " + __file__ + ": error while deleting source pdf at: '" + path_to_source_pdf + "'" print(error_msg, flush=True) # display_alert(error_msg, blocking=False) print("\n" + timestamp() + ready_text, flush=True) # Close the Preview window opened by the 'PDF Printer' script = r'tell application "System Events" to click first button of (first window of process "Preview")' p = Popen(['osascript', '-'], stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True) stdout, stderr = p.communicate(script)
def main(): """Install vanilla bootstrap packages from local mirror. Installing all the bootstrap packages is a lengthy (and highly disk-IO bound, thus serializing) procedure, so it's best to do it only once. Instead of having each container running the make_package stage installing the boostrap packages, we install the bootstrap packages in this container and then base the make_package containers on the image of this container. """ parser = get_argparser() args = parser.parse_args() # GPG takes time. Remove package signature checks. lines = [] with open("/etc/pacman.conf") as f: for line in f: if re.search("SigLevel", line): lines.append("SigLevel = Never") else: lines.append(line.strip()) with open("/etc/pacman.conf", "w") as f: for line in lines: print(line.strip(), file=f) name_data_file = os.path.join(args.shared_directory, "get_base_package_names", "latest", "names.json") with open(name_data_file) as f: name_data = json.load(f) bootstrap_packs = name_data["base"] + name_data["base_devel"] + name_data["tools"] + ["sloccount"] vanilla = "file://" + args.mirror_directory + "/$repo/os/$arch" log("info", "Printing %s to mirrorlist" % vanilla) with open("/etc/pacman.d/mirrorlist", "w") as f: print("Server = " + vanilla, file=f) cmd = "pacman -Syy --noconfirm" time = timestamp() cp = subprocess.run(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) log("command", cmd, cp.stdout.splitlines(), time) if cp.returncode: exit(1) cmd = "pacman -Su --noconfirm " + " ".join(bootstrap_packs) time = timestamp() cp = subprocess.run(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) log("command", cmd, cp.stdout.splitlines(), time) if cp.returncode: exit(1) run_cmd("useradd -m -s /bin/bash tuscan", as_root=True) # User 'tuscan' needs to be able to use sudo without being harassed # for passwords) and so does root (to su into tuscan) with open("/etc/sudoers", "a") as f: print("tuscan ALL=(ALL) NOPASSWD: ALL", file=f) print("root ALL=(ALL) NOPASSWD: ALL", file=f) # Download and install bear with tempfile.TemporaryDirectory() as d: url = "https://github.com/karkhaz/Bear/blob/master/" "bear-2.1.5-1-x86_64.pkg.tar.xz?raw=true" response = urllib.request.urlopen(url) tar_file = response.read() pkg_name = "bear.pkg.tar.xz" with open(os.path.join(d, pkg_name), "wb") as f: f.write(tar_file) os.chdir(d) cmd = "pacman -U --noconfirm %s" % pkg_name cp = subprocess.run(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) log("command", cmd, cp.stdout.splitlines()) if cp.returncode: exit(1) os.mkdir("/toolchain_root") shutil.chown("/toolchain_root", "tuscan") # Replace native tools with thin wrappers with open("/build/tool_redirect_rules.yaml") as f: transforms = yaml.load(f) execs = transforms["overwrite"] + list(transforms["replacements"].keys()) for e in set(execs): execs.remove(e) if execs: log( "error", ("The following executables have been specified " "twice in the tool_redirect_rules.yaml: %s" % str(execs)), ) exit(1) for e in transforms["overwrite"]: transforms["replacements"][e] = e transforms.pop("overwrite", None) jinja = jinja2.Environment(loader=jinja2.FileSystemLoader(["/build"])) wrapper_temp = jinja.get_template("tool_wrapper.c") with tempfile.TemporaryDirectory() as tmp_dir: for native, toolchain in transforms["replacements"].items(): wrapper = wrapper_temp.render( native_program=native, toolchain_prefix=transforms["prefix"], toolchain_program=toolchain ) with tempfile.NamedTemporaryFile("w", suffix=".c") as temp: temp.write(wrapper) temp.flush() cmd = "gcc -o %s %s" % (os.path.join(tmp_dir, native), temp.name) proc = subprocess.Popen( cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True ) out, _ = proc.communicate() if proc.returncode: body = "%s\n%s\n%s" % (cmd, out, wrapper) log("error", "Failed to compile compiler wrapper", body=body) exit(1) for wrapper in os.listdir(tmp_dir): shutil.move(os.path.join(tmp_dir, wrapper), os.path.join("/usr/bin", wrapper)) setup.toolchain_specific_setup(args) exit(0)
def withdraw(op): """ in production print_op is replaced with withdraw The user has returned some UIA to the issuer! upon hearing an on chain UIA transfer to the gateway with memo from this definition we trigger a gateway withdrawal event release the user's foreign chain funds to the memo and burn the returned UIA upon irreversible receipt """ # if its a transfer to gateway with a memo tgm = False if op[0] == 0: # transfer if op[1]["to"] in [ GATE["uia"]["eos"]["issuer_id"], GATE["uia"]["xrp"]["issuer_id"], ]: print(it("yellow", "gate uia transfer")) if "memo" in op[1].keys(): print( it("red", "TRANSFER TO GATEWAY WITH MEMO\n\n"), it("yellow", op), "\n", ) tgm = True else: print(it("red", "WARN: transfer to gateway WITHOUT memo")) if tgm: timestamp() line_number() order = {} # extract the asset_id of the transfer uia_id = op[1]["amount"]["asset_id"] print("uia_id", uia_id, "\n") # EOS specific parameters if uia_id == GATE["uia"]["eos"]["asset_id"]: network = "eos" verify = verify_eosio_account listen = listener_eosio transfer = eos_transfer # eos transfers require a url order["url"] = eosio_nodes()[ 0] # FIXME what happens if node fails? # XRP specific parameters elif uia_id == GATE["uia"]["xrp"]["asset_id"]: network = "xrp" verify = verify_ripple_account listen = listener_ripple transfer = xrp_transfer memo = op[1][ "memo"] # dict with keys("from", "to", "nonce", "message") order["private"] = GATE[network][0]["private"] order["public"] = GATE[network][0]["public"] # convert graphene operation amount to human readable order["quantity"] = (op[1]["amount"]["amount"] / 10**GATE["uia"][network]["asset_precision"]) # decode the client's memo using the issuers private key order["to"] = ovaltine(memo, GATE["uia"][network]["issuer_private"]) print(f"decoded {network} client", order["to"], "\n") # confirm we're dealing with a legit client address if verify(order["to"]): listener = Process( target=listen, args=( 0, order["quantity"], "reserve", # issuer_action None, # # always None for reserve ), ) # upon hearing real foreign chain transfer, reserve the uia equal listener.start() print( it( "red", f"STARTING {network} LISTENER TO RESERVE {order['quantity']}\n", )) # wait for listener subprocess to warm up then transfer the order time.sleep(30) timestamp() line_number() print(transfer(order)) else: print( it("red", f"WARN: memo is NOT a valid {network} account name\n"))
def listener_ripple(account_idx=0, amount=None, issuer_action=None, client_id=None, nonce=0): """ for every block from initialized until detected check for transaction to the gateway issue or reserve uia upon receipt of gateway transfer :param int(account_idx) # from gateway_state.py :param float(amount) :param str(issuer_action) # None in unit test case :param str(client_id) #1.2.X :return None: """ gateway = GATE["xrp"][account_idx]["public"] uia = GATE["uia"]["xrp"]["asset_name"] start_ledger_num = get_validated_ledger() checked_ledgers = [start_ledger_num] timestamp() line_number() print(f"nonce {nonce}", "Start ledger:", start_ledger_num, "\n") start = time.time() while 1: elapsed = time.time() - start if elapsed > DEPOSIT_TIMEOUT: print(f"nonce {nonce}", it("red", "XRP GATEWAY TIMEOUT"), gateway) # after timeout, release the address if issuer_action == "issue": unlock_address("ripple", account_idx, DEPOSIT_PAUSE) break # get the latest validated ledger number current_ledger = get_validated_ledger() # get the latest ledger number we checked max_checked_ledger = max(checked_ledgers) # if there are any new validated ledgers if current_ledger > max_checked_ledger + 1: # check every ledger from last check till now for ledger_num in range(max_checked_ledger + 1, current_ledger): print( f"nonce {nonce}", it("green", "Ripple Validated Ledger"), it("yellow", ledger_num), time.ctime()[11:19], ) # get each new validated ledger transactions = get_ledger(ledger_num) # iterate through all transactions in the list of transactions for trx in transactions: if not isinstance(trx["Amount"], dict): # localize data from the transaction amount = int( trx["Amount"]) / 10**6 # convert drops to xrp trx_from = trx["Account"] trx_to = trx["Destination"] # during unit testing if issuer_action is None: print(f"nonce {nonce}", ledger_num, trx, "\n") # determine if it is a transfer to or from the gateway if gateway in [trx_from, trx_to]: timestamp() line_number() # establish gateway transfer direction direction = "INCOMING" if gateway == trx_from: direction = "OUTGOING" print( f"nonce {nonce}", it( "red", f"{direction} XRP GATEWAY TRANSFER DETECTED\n", ), f"amount {amount}\n", f"from {trx_from}\n", f"to {trx_to}\n", ) # the client_id was assigned deposit gateway address # issue UIA to client_id upon receipt of their foreign funds if issuer_action == "issue" and trx_to == gateway: print( f"nonce {nonce}", it( "red", f"ISSUING {amount} {uia} to {client_id}\n", ), ) issue("xrp", amount, client_id) # in subprocess unlock the deposit address after wait delay = DEPOSIT_TIMEOUT - elapsed + DEPOSIT_PAUSE unlock_address("xrp", account_idx, delay) return # but immediately kill the listener # the parent process will soon send foreign funds to client_id # reserve UIA upon hearing proof of this transfer if issuer_action == "reserve" and trx_from == gateway: print( f"nonce {nonce}", it("red", f"RESERVING {amount} {uia}\n"), ) reserve("xrp", amount) return # kill the listener # append this ledger number to the list of checked numbers if ledger_num not in checked_ledgers: checked_ledgers.append(ledger_num)
def submit_problem(tid, request, is_zju_user): """Handle problem submission. Gets the key and pid from the submitted problem, calls the respective grading function if the values aren't empty. If correct all relevant cache values are cleared. The submission is the inserted into the database (an attempt is made). A relevant message is returned if the problem has already been solved or the answer has been tried. """ # Nginx Configuration Fixed --libmaru """ import common common.log('Hello, '+request.remote_addr, 'ERROR') """ """ response = captcha.submit( request.form.get('recaptcha_challenge', ''), request.form.get('recaptcha_response', ''), '6LcPFPESAAAAAIkncbbAOfUi6sTSrMMxKVA9EcMq', request.remote_addr ) if not response.is_valid: return {"status": 0, "points": 0, "message": "验证码不正确."} """ t_interval = 10 last_submitted = cache.get('last_submitted_' + tid) if not last_submitted: cache.set('last_submitted_' + tid, True, t_interval) else: return {"status": 0, "points": 0, "message": "相邻提交之间隔须多于%d秒, 请稍后再试." % t_interval} pid = request.form.get('pid', '') key = request.form.get('key', '') if pid == '': return {"status": 0, "points": 0, "message": "题目名字不能为空."} if key == '': return {"status": 0, "points": 0, "message": "答案不能为空."} #if pid not in [p['pid'] for p in load_unlocked_problems(tid)]: # return {"status": 0, "points": 0, "message": "You cannot submit problems you have not unlocked."} pid = pid.encode('utf8').strip() # key = key.encode('utf8').strip() prob = cache.get('problem_' + pid) if prob is None: prob = db.problems.find_one({"pid": pid}) if prob is None: return {"status": 0, "points": 0, "message": "未找到题目'%s'." %pid} del prob['_id'] cache.set('problem_' + pid, json.dumps(prob), 60 * 60) else: prob = json.loads(prob) correct = False grader_type = prob.get('grader-type', 'key') if grader_type == 'file': (correct, message) = imp.load_source(prob['grader'][:-3], "./graders/" + prob['grader']).grade(tid, key) elif grader_type == 'key': correct = prob['key'] == key message = prob.get('correct_msg', '回答正确!') if correct else prob.get('wrong_msg', '回答错误!') message = message.encode('utf8') tstamp = utilities.timestamp(datetime.utcnow()) submission = {'tid': tid, 'timestamp': tstamp, 'pid': pid, 'ip': request.headers.get('X-Real-IP', None), 'key': key, 'correct': correct} if correct: #cache.delete('unlocked_' + tid) # Clear the unlocked problem cache as it needs updating cache.delete('solved_' + tid) # Clear the list of solved problems cache.delete('problems_' + tid) if is_zju_user: cache.delete('scoreboard_zju') else: cache.delete('scoreboard_public') cache.delete('teamscore_' + tid) # Clear the team's cached score cache.delete('lastsubdate_' + tid) try: db.submissions.insert(submission) except DuplicateKeyError: return {"status": 0, "points": 0, "message": "你已解决此题!"} else: try: db.submissions.insert(submission) except DuplicateKeyError: return {"status": 0, "points": 0, "message": "你已提交过这一错误答案!"} return {"status": 1 if correct else 0, "points": prob.get('basescore', 0), "message": message}
def on_get(self, req, resp): """ When there is a get request made to the deposit server api User GET request includes the client_id's BitShares account_name Select a gateway wallet from list currently available; remove it from the list the available address list will be stored in a json_ipc text pipe Server RESPONSE is deposit address and timeout After timeout or deposit return address to text pipe list """ confirm_time = { "eos": 30, "xrp": 2, } # create a millesecond nonce to log this event nonce = milleseconds() # extract the incoming parameters to a dictionary data = dict(req.params) timestamp() line_number() print(it("red", "DEPOSIT SERVER RECEIVED A GET REQUEST"), "\n") call(["hostname", "-I"]) print(data, "\n") client_id = data["client_id"] uia = data["uia_name"] # translate the incoming uia request to the appropriate network network = "" if uia == GATE["uia"]["xrp"]["asset_name"]: network = "xrp" elif uia == GATE["uia"]["eos"]["asset_name"]: network = "eos" print("network", network, "\n") if network in ["xrp", "eos"]: # lock an address until this transaction is complete gateway_idx = lock_address(network) print("gateway index", gateway_idx, "\n") if gateway_idx is not None: timestamp() line_number() deposit_address = GATE[network][gateway_idx]["public"] print("gateway address", deposit_address, "\n") # format a response json msg = json_dumps({ "response": "success", "server_time": nonce, "deposit_address": deposit_address, "gateway_timeout": "30 MINUTES", "msg": (f"Welcome {client_id}, please deposit your gateway issued " + f"{network} asset, to the {uia} gateway 'deposit_address' " + "in this response. Make ONE transfer to this address, " + "within the gateway_timeout specified. Transactions on " + f"this network take about {confirm_time[network]} " + "minutes to confirm."), }) print( it("red", f"STARTING {network} LISTENER TO ISSUE to {client_id}"), "\n", ) # dispatch the appropriate listener protocol listen = {"eos": listener_eosio, "xrp": listener_ripple} # in subprocess listen for payment from client_id to gateway[idx] # upon receipt issue asset, else timeout listener = Process( target=listen[network], args=(gateway_idx, None, "issue", client_id, nonce), ) listener.start() print(f"{network}listener started", "\n") else: msg = json_dumps({ "response": "error", "server_time": nonce, "msg": f"all {uia} gateway addresses are in use, " + "please try again later", }) else: msg = json_dumps({ "response": "error", "server_time": nonce, "msg": f"{uia} is an invalid gateway UIA, please try again", }) # log the response and build the response body with a data dictionary doc = str(nonce) + "_" + uia + "_" + client_id + ".txt" json_ipc(doc=doc, text=msg) time.sleep( 5) # allow some time for listener to start before offering address print(msg, "\n") resp.body = msg resp.status = HTTP_200
def listener_eosio( account_idx=0, amount=None, issuer_action=None, client_id=None, nonce=0 ): """ for every block from initialized until detected check for transaction to the gateway issue or reserve uia upon receipt of gateway transfer :param int(account_idx) # from gateway_state.py :param float(amount) :param str(issuer_action) # None in unit test case :param str(client_id) #1.2.X :return None: """ gateway = GATE["eos"][account_idx]["public"] uia = GATE["uia"]["eos"]["asset_name"] start_block_num = get_irreversible_block() checked_blocks = [start_block_num] print("Start Block:", start_block_num, "\n") # block["transactions"][0]["trx"]["transaction"]["actions"][0] holds: # ["name"] # str("transfer") etc. # ["data"] # dict.keys() [to, from, quantity] start = time.time() while 1: elapsed = time.time() - start if elapsed > DEPOSIT_TIMEOUT: print( f"nonce {nonce}", it("red", f"{nonce} EOS GATEWAY TIMEOUT"), gateway, "\n", ) # 10 minutes after timeout, release the address if issuer_action == "issue": unlock_address("eos", account_idx, DEPOSIT_PAUSE) break # get the latest irreversible block number current_block = get_irreversible_block() # get the latest block number we checked max_checked_block = max(checked_blocks) # if there are any new irreversible blocks if current_block > max_checked_block + 1: new_blocks = range(max_checked_block + 1, current_block) # eosio has a 0.5 second block time, to prevail over network latency: # *concurrently* fetch all new blocks block_processes = {} # dictionary of multiprocessing "Process" events blocks_pipe = {} # dictionary of multiprocessing "Value" pipes # spawn multpiple processes to gather the "new" blocks for block_num in new_blocks: manager = Manager() blocks_pipe[block_num] = manager.Value(c_wchar_p, "") block_processes[block_num] = Process( target=get_block, args=(block_num, blocks_pipe,) ) block_processes[block_num].start() # join all subprocess back to main process; wait for all to finish for block_num in new_blocks: block_processes[block_num].join() # extract the blocks from each "Value" in blocks_pipe blocks = {} for block_num, block in blocks_pipe.items(): # create block number keyed dict of block data dicts blocks[block_num] = block.value # with new cache of blocks, check every block from last check till now for block_num in new_blocks: print( f"nonce {nonce}", it("purple", "Eosio Irreversible Block"), it("yellow", block_num), time.ctime()[11:19], it("purple", int(time.time())), "\n", ) # get each new irreversible block block = blocks[block_num] transactions = [] try: transactions = block["transactions"] except Exception: pass # iterate through all transactions in the list of transactions for trx in transactions: actions = [] try: actions = trx["trx"]["transaction"]["actions"] except Exception: pass # if there are any, iterate through the actions for action in actions: try: # sort by tranfer ops if ( action["name"] == "transfer" # SECURITY: ensure it is the correct contract!!! and action["account"] == "eosio.token" ): # extract transfer op data qty = action["data"]["quantity"] trx_to = action["data"]["to"] trx_from = action["data"]["from"] trx_asset = qty.split(" ")[1].upper() trx_amount = float(qty.split(" ")[0]) # sort again by > nil amount of eos if trx_amount > 0.0001 and trx_asset == "EOS": # during unit testing # if issuer_action is None: if DEV: print(f"nonce {nonce}", block_num, action, "\n") # if there are any transfers listed if gateway in [trx_from, trx_to]: timestamp() line_number() print( f"nonce {nonce}", it("red", "GATEWAY TRANSFER DETECTED\n"), f"amount {trx_amount} {trx_asset}\n", f"from {trx_from}\n", f"to {trx_to}\n", ) # issue UIA to client_id # upon receipt of their foreign funds if ( issuer_action == "issue" and trx_to == gateway ): print( f"nonce {nonce}", it( "red", f"ISSUING {trx_amount} {uia} to " + f"{client_id}\n", ), ) issue("eos", trx_amount, client_id) # unlock the deposit address after some time delay = ( DEPOSIT_TIMEOUT - elapsed + DEPOSIT_PAUSE ) unlock_address("eos", account_idx, delay) return # when returning foreign funds to client, # upon receipt, reserve equal in UIA if ( issuer_action == "reserve" and trx_from == gateway and trx_amount == amount ): print( f"nonce {nonce}", it( "red", f"RESERVING {amount} {uia}\n" ), ) reserve("eos", trx_amount) return except Exception: print(f"nonce {nonce}", "action", action, "\n") print(traceback.format_exc(), "\n") if block_num not in checked_blocks: checked_blocks.append(block_num)
__email__ = ["*****@*****.**", "*****@*****.**"] __status__ = "Production" from datetime import datetime import time import json import group from common import db from common import cache from common import esc import problem import utilities ctf_start = utilities.timestamp(datetime(2014, 4, 5, 0)) ctf_end = utilities.timestamp(datetime(2014, 4, 6, 16)) # # For debugging only # ctf_start = utilities.timestamp(datetime(2014, 04, 01, 00) - datetime.utcnow() + datetime.now()) def get_group_scoreboards(tid): """Gets the group scoreboards. Because of the multithreaded implementation we rebuild the scoreboard in the aggregator, this call can only return a value from cache. This prevents multiple page requests from invoking a scoreboard rebuild simultaneously. Get all groups a users is a member of and look for group scoreboards for each of these groups. """ group_scoreboards = [] groups = group.get_group_membership(tid) for g in groups:
def copy_and_build(args): try: shutil.copytree(args.permanent_source_dir, args.build_dir) except shutil.Error as e: # e.args will be a list, containing a single list of 3-tuples. # We are interested in the third item of each tuple. errors = [err[2] for err in e.args[0]] die(Status.failure, "No source directory in source volume: %s" % args.permanent_source_dir, output=errors) recursive_chown(args.build_dir) os.chdir(args.build_dir) # Add the --host option to invocations of ./configure with open("PKGBUILD", encoding="utf-8", errors="ignore") as f: pkgbuild = f.read().splitlines() if args.toolchain == "android": pkgbuild = [ re.sub(r"configure\s", ("configure --build=x86_64-unknown-linux " "--host=arm-linux-androideabi "), line) for line in pkgbuild ] else: pkgbuild = [ re.sub(r"configure\s", "configure --host=x86_64-unknown-linux ", line) for line in pkgbuild ] with open("PKGBUILD", "w", encoding="utf-8") as f: f.write("\n".join(pkgbuild)) # This invocation of makepkg has the --noextract flag, because # sources should already have been extracted during the creation of # the base image (see stages/create_base_image/getpkgs.py). We still # need to perform all other stages of package building, including # the prepare() function that is called just before the build() # function. # # The invocation also has the --syncdeps flag; this is fine, because # anything that this package depends on should already have been # built and its hybrid package will have been installed. if args.env_vars == None: args.env_vars = [] command_env = os.environ.copy() for pair in args.env_vars: var, val = pair.split("=") command_env[var] = val command = ("sudo -u tuscan " + " ".join(args.env_vars) + " red makepkg --noextract --syncdeps" " --skipinteg --skippgpcheck --skipchecksums" " --noconfirm --nocolor --log --noprogressbar" " --nocheck") time = timestamp() proc = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=command_env) stdout_data, _ = proc.communicate() output = codecs.decode(stdout_data, errors="replace") log("command", command, output.splitlines(), time) # Measure LOC loc_proc = subprocess.Popen( ["/usr/bin/sloccount", "--addlang", "makefile", "src"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out, _ = loc_proc.communicate() output = codecs.decode(out, errors="replace") if loc_proc.returncode: log("die", "SLOCCount failed", output.splitlines()) else: log_sloc(output.splitlines()) # Pick up output left by red try: if os.path.exists("compile_commands.json"): with open("compile_commands.json") as f: red_output = json.load(f) log("red", "red", output=red_output) else: log("die", "No red output found in dir '%s'" % os.getcwd()) except json.decoder.JSONDecodeError as e: log("red", "red", output=[]) red_errors = [] for native in glob("/tmp/red-error-*"): with open(native) as f: lines = f.readlines() red_errors.append({ "category": lines[0].strip(), "pid": lines[1].strip(), "info": "\n".join(lines[2:]) }) os.unlink(native) log("red_errors", "red_errors", output=red_errors) return proc.returncode