def test_runTCP6(self, reactor, mock_sfs, mock_log, mock_kr): """ L{Klein.run} called with tcp6 endpoint description. """ app = Klein() interface = "2001\:0DB8\:f00e\:eb00\:\:1" spec = "tcp6:8080:interface={0}".format(interface) app.run(endpoint_description=spec) reactor.run.assert_called_with() mock_sfs.assert_called_with(reactor, spec) mock_log.startLogging.assert_called_with(sys.stdout) mock_kr.assert_called_with(app)
def test_runSSL(self, reactor, mock_sfs, mock_log, mock_kr): """ L{Klein.run} called with SSL endpoint specification. """ app = Klein() key = "key.pem" cert = "cert.pem" dh_params = "dhparam.pem" spec_template = "ssl:443:privateKey={0}:certKey={1}" spec = spec_template.format(key, cert, dh_params) app.run(endpoint_description=spec) reactor.run.assert_called_with() mock_sfs.assert_called_with(reactor, spec) mock_log.startLogging.assert_called_with(sys.stdout) mock_kr.assert_called_with(app)
def test_runWithLogFile(self, reactor, mock_log, mock_site, mock_kr): """ L{Klein.run} logs to the specified C{logFile}. """ app = Klein() logFile = Mock() app.run("localhost", 8080, logFile=logFile) reactor.listenTCP.assert_called_with(8080, mock_site.return_value, interface="localhost") reactor.run.assert_called_with() mock_site.assert_called_with(mock_kr.return_value) mock_kr.assert_called_with(app) mock_log.startLogging.assert_called_with(logFile)
def test_runWithLogFile(self, reactor, mock_log, mock_site, mock_kr): """ L{Klein.run} logs to the specified C{logFile}. """ app = Klein() logFile = Mock() app.run("localhost", 8080, logFile=logFile) reactor.listenTCP.assert_called_with( 8080, mock_site.return_value, interface="localhost") reactor.run.assert_called_with() mock_site.assert_called_with(mock_kr.return_value) mock_kr.assert_called_with(app) mock_log.startLogging.assert_called_with(logFile)
def test_run(self, reactor, mock_log, mock_site, mock_kr): """ L{Klein.run} configures a L{KleinResource} and a L{Site} listening on the specified interface and port, and logs to stdout. """ app = Klein() app.run("localhost", 8080) reactor.listenTCP.assert_called_with(8080, mock_site.return_value, interface="localhost") reactor.run.assert_called_with() mock_site.assert_called_with(mock_kr.return_value) mock_kr.assert_called_with(app) mock_log.startLogging.assert_called_with(sys.stdout)
def test_run(self, reactor, mock_log, mock_site, mock_kr): """ L{Klein.run} configures a L{KleinResource} and a L{Site} listening on the specified interface and port, and logs to stdout. """ app = Klein() app.run("localhost", 8080) reactor.listenTCP.assert_called_with( 8080, mock_site.return_value, interface="localhost") reactor.run.assert_called_with() mock_site.assert_called_with(mock_kr.return_value) mock_kr.assert_called_with(app) mock_log.startLogging.assert_called_with(sys.stdout)
def webserver(pq): webapp = Klein() @webapp.route('/') def home(request): return 'Hello, World!' @webapp.route('/ip/<ip>') def getIP(request, ip): # We only need ipv4 dotted-quad. Quick regex check, then test the validity of the IP if re.match(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", ip): try: socket.inet_aton(ip) pq.put(ip) print "ip is: {}".format(ip) return "ip is: {}".format(ip) except socket.error: print "input is not an IP." return "This is an IP! Read the RFC 791: https://tools.ietf.org/html/rfc791" else: print "input is not an IP." return "This is not an IP! Read the RFC 791: https://tools.ietf.org/html/rfc791" webapp.run(host="0.0.0.0", port=8080)
target=kafka_consumer_worker, args=( t_stop_event, bootstrap_servers, "heartbeat", region, __product__, threads_mq, ), ) threads.append(t_kafka_hb_consumer_worker) ########################################################### # Starting threads for t in threads: t.start() print("[" + region + "] " + __product__ + " version " + __version__ + " (" + env + ') is listening "' + host + ":" + port + '"') # Http server # log = open('app.log', 'a') # if env == 'production': # log = open('/dev/null', 'a') # app.run(host, port, log) app.run(host, port) exit(0)
Converts audio files to wav files """ print("in ffmpeg") args = [] if codec: args += ["-acodec", "pcm_s16le"] elif channel: args += ["-ac", "1"] elif bitrate: args += ["-at", "16000"] if len(args) == 0: return None print(f"Running FMPEG with:{args}") process = subprocess.run(args=["ffmpeg", "-i", fname] + args + [cvtfname], stdout=PIPE, stderr=PIPE) if process.returncode != 0: return (False, process.stderr) else: return (True, process.stdout) app.run(ADDRESS, PORT)
def send_now(app_key, request): app = Application(key=app_key).auth() message = request.args.get('message')[0] sound = request.args.get('sound')[0] or 'default' badge = request.args.get('badge') or 0 token = request.args.get('token')[0] extra = request.args.get('extra')[0] request.setHeader('Content-Type', 'application/json') content = dict(alert=message, sound=sound, badge=badge, extra=json.loads(extra)) if app: log.msg('application found: %s' % app.name) notification = Notification(token=token, app=app, content=content) notification.send() else: log.msg('No application found with key %s' % app_key[1], logLevel=logging.WARNING) yield 'OK' if __name__ == "__main__": log.startLogging(sys.stdout) app.run("0.0.0.0", 8080)
@app.route("/updates") @close_session def updates(request): request.setHeader("Content-Type", "application/json; charset=UTF-8") num_queries = getQueryNum(request.args.get("queries")[0]) worlds = [] rp = partial(randint, 1, 10000) ids = [rp() for _ in xrange(num_queries)] ids.sort() for id in ids: world = db_session.query(World).get(id) world.randomNumber = rp() worlds.append(world.serialize()) db_session.commit() return json.dumps(worlds) @app.route("/fortune") @close_session def fortune(request): request.setHeader("Content-Type", "text/html; charset=UTF-8") fortunes = db_session.query(Fortune).all() fortunes.append(Fortune(id=0, message="Additional fortune added at request time.")) fortunes.sort(key=attrgetter("message")) template = env.get_template("fortunes.html") return template.render(fortunes=fortunes) if __name__ == "__main__": app.run("0.0.0.0", 8080) # vim: set expandtab sw=4 sts=4 ts=4 :
from klein import Klein from twisted.internet import defer, reactor app = Klein() @app.route('/interrupted') def interruptRoute(request): d = defer.Deferred() d.addCallback(_delayedRender) reactor.callLater(5, d.callback, request) request.notifyFinish().addErrback(_responseFailed, d) return d def _responseFailed(error, call): print('Cancelled!') call.cancel() def _delayedRender(request): request.write('Sorry for the delay'.encode('utf-8')) if __name__ == '__main__': app.run('localhost', 9000)
def turnOnTheLights(states, timeoutFlag = False): for pixel in xrange(len(states)): current_state = states[pixel] if current_state.lower() == 'ok': ok(pixel, timeoutFlag) elif current_state.lower() == 'warning': warning(pixel, timeoutFlag) elif current_state.lower() == 'critical': critical(pixel, timeoutFlag) else: unknown(pixel) def init(): global states global leds global timeout number_of_lights = 32 timeout = reactor.callLater(SHIFTTIME,shiftOne) states = deque(['unknown']*number_of_lights) spidev = file("/dev/spidev0.0", "wb") leds = ledstrip.LEDStrip(pixels=number_of_lights, spi=spidev) if __name__ == "__main__": #app.config['DEBUG'] = True init() app.run(host='::', port=5000)
resource = app.resource mode = release https = False for v in sys.argv: if v.lower() == "test": mode = test if v.lower() == "debug": mode = debug if v.lower() == 'https': https = True endpointdesc = 'ssl:8084:privateKey=' + privateKeyPath + ':certKey=' + certificatePath if not https: endpointdesc = '' if mode == test: print("Testing mode, no server running.") print("to start server: app.run(<local/0.0.0.0>',<port>)") ##local test elif mode == debug: print("Running on localhost") app.run('localhost', 8084, endpoint_description=endpointdesc) ##release elif mode == release: print("Running on 0.0.0.0") app.run('0.0.0.0', 8084, endpoint_description=endpointdesc)
return dfd def item_scraped(self, item, response, spider): self.items.append(item) def return_items(self, result): return self.items def return_spider_output(output): """ :param output: items scraped by CrawlerRunner :return: json with list of items """ # this just turns items into dictionaries # you may want to use Scrapy JSON serializer here return json.dumps([dict(item) for item in output]) @application.route("/api") def schedule(request): settings = get_project_settings() runner = MyCrawlerRunner(settings) deferred = runner.crawl(CovidSpider) deferred.addCallback(return_spider_output) return deferred application.run("localhost", 8080)
d = xmltodict.parse(content) if 'offers' in d: return read_ceneo_v2(d) else: return read_google_shopping(d) elif url.endswith('.csv'): return read_csv(content, delim=',') else: return read_csv(content, delim='\t') @defer.inlineCallbacks def return_info(response): text = yield response.content() v = read_any_feed(text, response.request.absoluteURI.decode('utf-8')) return json.dumps(v) @app.route("/read", methods=['POST']) def get_category(request): content = json.loads(request.content.read()) url = content['url'] d = treq.get(url) d.addCallback(return_info) return d resource = app.resource app.run("0.0.0.0", 5007)
'd': DownloadHandler, 'download': DownloadHandler, 'v': VersionHandler, 'version': VersionHandler, 'wheel': WheelHandler, 'egg': EggHandler, 'license': LicenseHandler, 'format': FormatHandler, 'py_versions': PythonVersionsHandler, 'implementation': ImplementationHandler, 'status': StatusHandler, } @app.route('/<string:generator>/<string:package>/badge.<string:extension>') def shield(request, generator, package, extension): gc.collect() ext = mimetypes.types_map[".{0}".format(extension)] request.headers.update({'content-type': ext}) klass = generators[generator]() img = klass.get(request, package, extension) return img if __name__ == '__main__': if not os.path.exists(FILE_CACHE): os.mkdir(FILE_CACHE) if '.svg' not in mimetypes.types_map: mimetypes.add_type("image/svg+xml", ".svg") app.run("localhost", 8888)
request.setHeader('Access-Control-Allow-Headers', 'x-prototype-version,x-requested-with') request.setHeader('Access-Control-Max-Age', 2520) content = json.loads(request.content.read().decode("utf8")) print(content) command = content['command'] DID = content['deviceID'] if DID != "00000000": toSend={"CMD":"HMOD","MODE":command, "TS": str(int(time.time()))} remote_device = RemoteXBeeDevice(device, XBee64BitAddress.from_hex_string(DID)) # Send data using the remote object. device.send_data_async(remote_device, json.dumps(toSend)) else: toSend={"CMD":"HMOD","MODE":command, "TS": str(int(time.time()))} print("broadcasting command " + json.dumps(toSend)) device.send_data_broadcast(json.dumps(toSend)) return json.dumps({"result":"success"}) device = DigiMeshDevice(PORT, BAUD_RATE) device.open() device.add_data_received_callback(my_data_received_callback) app.run("0.0.0.0", 5001)
for ch0, ch2 in zip(text0, Y_pred_text): ch = ch0 if ch0.lower() != ch2.lower() and ch2 != " ": ch = "<span class='mod'>" + ch2 + "</span>" rez.append(ch) rez_str = "".join(rez).strip() return rez_str #DBG() app = Klein() @app.route("/ajax") def generate_ajax(request): txt = request.content.read().decode("utf-8") print("GOT TXT=", txt, type(txt)) request.setHeader('Content-Type', 'text/html; charset=utf-8') request.write(predict(model, txt).encode("utf-8")) @app.route("/", branch=True) def generate_index(request): return File("./app") if __name__ == '__main__': print " * Web API started" app.run(host='0.0.0.0', port=5080)
elif edit_permission is LOCKED_EDITS: return perform_locked_edit(article_id, request) else: request.setResponseCode(400) return "ERROR: Article requested for edit is in an invalid state. Contact the administrator if this error message persists." # Again, apologies for the abysmal security, but due to time constrains this was necessary - in the real world this would either be a proper user/pass auth schema, OAuth2, or a specialty api key @app.route( '/change_article_permissions/<article_id>/<permission>/<username>/<password>' ) def change_article_permissions(request, article_id, permission, username, password): """ This endpoint allows qualified users to change the editing permissions of an article """ print article_id, permission, username, password if not validate_user(username, password): request.setResponseCode(401) return "User is not authorized to access the requested resource." return "Article Permissions updated" if update_article_permissions( article_id, permission) else "There was a problem updating the permissions" if __name__ == '__main__': app.debug = True app.run(host='0.0.0.0', port=8888)
if __name__ == '__main__': args = parser.parse_args() # Command line arguments. # Tell Twisted how to serve websockets: factory = WebSocketServerFactory( f'ws://{args.interface}:{args.websocket_port}' ) # Set up the default name from the command line. factory.default_name = args.default_name names.add(factory.default_name) # factory.protocol will be returned by factory.buildProtocol. # This is a shortcut instead of subclassing WebSocketServerFactory and # defining our own buildProtocol method. # If you wanted to disallow connections from certain hosts then you could # subclass WebSocketServerFactory and create your own buildProtocol method # that returned None when the hostname was blacklisted. factory.protocol = WebSocketProtocol # Create kwargs for use with the index method. By doing things this way we # don't hard code anything in javascript. index_kwargs.update( hostname=getfqdn(), http_port=args.http_port, websocket_port=args.websocket_port ) listenWS(factory, interface=args.interface) # Listen for websockets. app.run(host=args.interface, port=args.http_port) # Main loop.
d.addCallback(mainpage) return d @app.route('/login', methods=['GET', 'POST']) def login(request): if request.method == 'POST': qs_dict = getFieldDict(request) email = qs_dict['email'] password = qs_dict['password'] session = request.getSession() login = ILogin(session) login.email = email login.password = password return request.redirect('/') return render_template('login.html') @app.route('/success') def success(request): return 'Your message was sent!!!!!!!!!!!!!!!!!!' app.run('localhost', 8080)
from klein import Klein from twisted.internet import task, reactor from twisted.web.resource import Resource import Sequential app = Klein() def delayedCall(n): return 'Delayed for %d seconds' % n @app.route('/delay/<int:t>') def delay(requests, t): """ Delay the response by t seconds """ if t > 0: d = task.deferLater(reactor, t, delayedCall, t) return d else: return delayedCall(0) @app.route('/upload', branch=True) def sequential(request): return Sequential.app.resource() app.run('localhost', 8000)
returnValue( jsonify( request, { '_total': (yield User.count()), '_page': page, '_per_page': 10, '_items': [dump_user_no_pass(u) for u in users] })) @app.route('/users', methods=['POST']) @locale_from_request @inlineCallbacks def create_user(request): payload = get_json(request) if payload is None: raise Error( 400, 'Request body must be json with Content-type: application/json') try: user = User(**payload) yield user.commit() except ValidationError as ve: raise Error(400, jsonify(request, message=ve.args[0])) returnValue(jsonify(request, dump_user_no_pass(user))) if __name__ == '__main__': reactor.callWhenRunning(populate_db) app.run('localhost', 5000)
""" Base endpoint to get current counter value :param request: :return: JSON representation of response """ return json.dumps({"counter": int(storage.read())}) @app.route('/increment', methods=['POST']) def increment(request): """ Endpoint to increment the counter :param request: :return: JSON representation of response """ return json.dumps({"counter": int(storage.incr())}) @app.route('/increment', methods=['DELETE']) def reset(request): """ Endpoint to reset the counter :param request: :return: JSON representation of response """ return json.dumps({"counter": int(storage.reset())}) if __name__ == "__main__": app.run(settings.SERVER_HOST, settings.SERVER_PORT)
""" How to test using curl: ?> curl localhost:9000/branch/hello ?> curl localhost:9000/branch/blue/first ?> curl localhost:9000/branch/blue/second ?> curl localhost:9000/branch/blue/third """ from klein import Klein from twisted.web.static import File import blueprints app = Klein() @app.route('/branch', branch=True) def branchOff(request): return blueprints.app.resource( ) # get the Resource object from the Klein app in the blueprints module if __name__ == '__main__': app.run(host='localhost', port=9000)
from klein import Klein app = Klein() @app.route('/') def pg_root(request): return 'I am the root2 page!' @app.route('/about2') def pg_about(request): return 'I am a Klein application2!' app.run("localhost", 8089)
class Reflector: ''' main class that does all the work ''' def __init__(self, args, config): self.args = args self.config = config self.http_server = Klein() self.handler_threads = [] self.server_threads = [] self._log('Instantiated class Reflector', 'info') # simple healthcheck URI to check if the app is up @self.http_server.route('/__hc', methods=['GET']) def healthcheck(request): return str(200) @self.http_server.route('/') @self.http_server.route('/<uri>') def handle_get(request): ''' handle incoming requests ''' tpool = [] for s in range(0, len(self.config['upstream'])): tpool.append( self._spawn(target=self._http_redirect, req=request, thread_list=self.handler_threads, index=s)) for t in tpool: t.join() return str(request.content.read()) # private methods def _log(self, msg, level='info'): ''' logging function, writes to stdout ''' out = { 'timestamp': str(datetime.now()), 'level': level.upper(), 'message': str(msg) } if self.args.debug: print json.dumps(out) def _spawn(self, **kwargs): ''' spawn threads ''' if 'req' in kwargs: t = Thread(target=kwargs['target'], args=(kwargs['index'], kwargs['req'])) else: t = Thread(target=kwargs['target']) t.start() return t def _http_redirect(self, index, req): '''forward http to upstream''' if '?' in req.uri: params == True params = req.uri.split('?')[1] else: params = '' if self.config['upstream'][index]['uri']: if params == True: url = 'http://{}:{}{}?{}'.format( self.config['upstream'][index]['host'], self.config['upstream'][index]['port'], self.config['upstream'][index]['uri'] + req.uri, params) else: url = 'http://{}:{}{}'.format( self.config['upstream'][index]['host'], self.config['upstream'][index]['port'], self.config['upstream'][index]['uri'] + req.uri) else: url = 'http://{}:{}{}'.format( self.config['upstream'][index]['host'], self.config['upstream'][index]['port'], req.uri) headers = req.getAllHeaders() body = req.content if req.method.lower() in ['get', 'options']: r = requests.get(url, headers=headers, timeout=5) elif req.method.lower() in ['post', 'put', 'delete']: r = requests.post(url, headers=headers, data=body, timeout=5) # public methods def start(self): ''' start listening for connections ''' self._log('Starting Reflector') self.http_server.run(self.args.host, self.args.port) return
return path, expire raise Fail('uuid not found') app = Klein() with app.subroute(BASEURL) as app: @app.route('/<uuid>/<filename>', methods=['GET', 'HEAD']) def serve_files(request, uuid, filename): UUID(uuid) # just create it to see if it validates path, expiry_date = get_file_info(uuid) if datetime.now(timezone.utc) > expiry_date: raise Fail('expired') if filename != os.path.basename(path): raise Fail('path does not match') return File(os.path.join(BASEDIR, path)) @app.route('/<uuid>/<filename>/', methods=['GET', 'HEAD'], branch=True) def serve_dir(request, uuid, filename): return serve_files(request, uuid, filename) @app.handle_errors def handle_errors(request, failure): print('Fail:', failure.getErrorMessage()) #failure.printBriefTraceback() return File.childNotFound if __name__ == '__main__': app.run("localhost", PORT)
result = yield db.runQuery("SELECT title, thumb, nc, nv FROM tst ORDER BY id DESC LIMIT 10") data = result and [dict(title=r[0], thumb=r[1], nc=r[2], nv=r[3]) for r in result] or None resp = dict(list=data) elif coin < 8: title = randstr(140) thumb = randstr(140) nc = randint(0, 1000) nv = randint(0, 5000) yield db.runOperation("INSERT INTO tst(title, thumb, nc, nv) VALUES (%s, %s, %s, %s)", (title, thumb, nc, nv,)) resp = dict(action="insert", title=title, thumb=thumb, nc=nc, nv=nv) else: title = randstr(140) thumb = randstr(140) nc = randint(0, 1000) nv = randint(0, 5000) yield db.runOperation("UPDATE tst SET title=%s, thumb=%s, nc=%s, nv=%s " "WHERE id=(SELECT max(id) as m FROM tst LIMIT 1)", (title, thumb, nc, nv,)) resp = dict(action="update", title=title, thumb=thumb, nc=nc, nv=nv) request.setHeader('Content-Type', 'application/json') returnValue(json.dumps(resp)) resource = app.resource if __name__ == "__main__": app.run("localhost", 8080, logFile=open('/dev/null'))
tags.td(slot("rating"), " stars")), tags.tr(tags.td("Carbs:"), tags.td(slot("carbohydrates"))))) def one_food(request, food): random = random_from_string(food) return {"name": food, "pageTitle": "Food: {}".format(food), "rating": random.randint(1, 5), "carbohydrates": random.randint(0, 100)} @myStyle.routed( app.route("/places/<place>"), tags.div(style="color: green")( tags.h1("Place: ", slot("name")), tags.div(slot("latitude"), "° ", slot("longitude"), "°"), tags.div(tags.h2("Foods Found Here:"), tags.ul(tags.li(render="foods:list")( tags.a(href=["/foods/", slot("item")])(slot("item"))))))) def one_place(request, place): random = random_from_string(place) possible_foods = ["hamburgers", "cheeseburgers", "hot dogs", "pizza", "叉烧", "皮蛋", "foie gras"] random.shuffle(possible_foods) return {"name": place, "pageTitle": "Place: {}".format(place), "latitude": random.uniform(-90, 90), "longitude": random.uniform(-180, 180), "foods": possible_foods[:3]} app.run("localhost", 8080)
#PYTHONPATH=/Users/Standard/Documents/gitsrc/Python/Useful/HTTP twistd -n web --class=simple_server.resource # or #./exc.sh simepl_server (or whatever you decide to name this file) # # I don't know why it's so complicated to run... # I think it has to do with the fact that I'm running a twisted server and klein is an extension of twisted from klein import Klein app = Klein() @app.route('/') def home(request): return "Welcome!" @app.route('/<Id>') def print_id(request, Id): return Id app.run("localhost", 8081)
#!/usr/bin/python3 # -*- coding: utf-8 -*- from klein import run, route from twisted.web.template import tags, slot from klein import Klein, Plating from input_handler import handle_input app = Klein() myStyle = Plating( tags=tags.html( tags.head(tags.title(slot("pageTitle"))), tags.body(tags.h1(slot("pageTitle"), Class="titleHeading"), tags.div(slot(Plating.CONTENT))) ) ) @myStyle.routed( app.route("/input/"), tags.div()) def input(request): return {"r":['Hello, world!']} if __name__ == '__main__': app.run("localhost", 8080)
from twisted.web.static import File from klein import Klein import time app = Klein() @app.route('/hello') def hello(request): time.sleep(2) return File('./templates/hello.html') if __name__ == '__main__': app.run('localhost', 9090)
import json import codecs from tflearn.data_utils import to_categorical, pad_sequences from klein import Klein import predict import train app = Klein() @app.route('/api/ai/getSentimentPrediction/<comment>', methods=['GET']) def prediction(request, comment): # comment = request.args.get('comment', )[0] prediction = predict.prediction_module(comment) return prediction @app.route('/api/ai/trainAIEngine', methods=['GET']) def training(request): training = train.training_module() return training @app.route('/api/ai/getSentimentSummary', methods=['GET']) def summary(request): summary = predict.prediction_summary() return summary app.run("localhost", 9080)
@inlineCallbacks def list_users(request): page = int(request.args.get('page', 1)) users = yield User.find(limit=10, skip=(page - 1) * 10) returnValue(jsonify(request, { '_total': (yield User.count()), '_page': page, '_per_page': 10, '_items': [dump_user_no_pass(u) for u in users] })) @app.route('/users', methods=['POST']) @locale_from_request @inlineCallbacks def create_user(request): payload = get_json(request) if payload is None: raise Error(400, 'Request body must be json with Content-type: application/json') try: user = User(**payload) yield user.commit() except ValidationError as ve: raise Error(400, jsonify(request, message=ve.args[0])) returnValue(jsonify(request, dump_user_no_pass(user))) if __name__ == '__main__': reactor.callWhenRunning(populate_db) app.run('localhost', 5000)
def main(): parser = argparse.ArgumentParser() group = parser.add_mutually_exclusive_group(required=True) group.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") group.add_argument("-t", "--testnet", action="store_true", default=False, help="Use TestNett instead of the default TestNet") group.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") group.add_argument("--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") group.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument("--port-rpc", type=int, help="port to use for the json-rpc api (eg. 10332)") parser.add_argument("--port-rest", type=int, help="port to use for the rest api (eg. 80)") args = parser.parse_args() if not args.port_rpc and not args.port_rest: print("Error: specify at least one of --port-rpc / --port-rest") parser.print_help() return if args.port_rpc == args.port_rest: print("Error: --port-rpc and --port-rest cannot be the same") parser.print_help() return # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.testnet: settings.setup_testnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() # Write a PID file to easily quit the service write_pid_file() # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) # Disable logging smart contract events settings.set_log_smart_contract_events(False) # Start the notification db instance ndb = NotificationDB.instance() ndb.start() # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() # Run reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() host = "0.0.0.0" if args.port_rpc: logger.info("Starting json-rpc api server on http://%s:%s" % (host, args.port_rpc)) api_server_rpc = JsonRpcApi(args.port_rpc) endpoint_rpc = "tcp:port={0}:interface={1}".format(args.port_rpc, host) endpoints.serverFromString(reactor, endpoint_rpc).listen(Site(api_server_rpc.app.resource())) if args.port_rest: logger.info("Starting notification api server on http://%s:%s" % (host, args.port_rest)) api_server_rest = NotificationRestApi() endpoint_rest = "tcp:port={0}:interface={1}".format(args.port_rest, host) endpoints.serverFromString(reactor, endpoint_rest).listen(Site(api_server_rest.app.resource())) app = Klein() app.run(host, 9999)
if price is not None: product['offers'] = [price] return product except Exception as e: print(e) return {} @defer.inlineCallbacks def return_info(response): text = yield response.content() url = response.request.absoluteURI.decode("utf-8") v = get_products_details(text, url) #response.request.absoluteURI) return json.dumps(v) @app.route("/parse", methods=['POST']) def get_category(request): content = json.loads(request.content.read()) url = content['url'] d = treq.get(url) d.addCallback(return_info) return d resource = app.resource app.run("0.0.0.0", 5005)
log.msg(e,logLevel=logging.DEBUG) # response.close() # abort(404) pass # print response2.status_code try: content = yield response.content() soup = BeautifulSoup(content,"html.parser") details = soup.find_all("table",{"class":"table"}) basic_details = details[0].find_all("tr") personl_details = details[1].find_all("tr") outdict = {} for idx,lines in enumerate(basic_details): outdict[clean_text(lines,'th')] = clean_text(lines,'td') # print clean_text(lines,'td') for lines in personl_details: outdict[clean_text(lines,'th')] = clean_text(lines,'td') returnValue(json.dumps(outdict)) except KeyError: # abort(400) pass if __name__ == '__main__': app.run(host='localhost',port=5000) observer = log.PythonLoggingObserver() observer.start()
parser.add_argument('-p', '--port', nargs='?', help="Specify the port the node will listen on") parser.add_argument('-c', '--config', default='', help="The config file. Only for the controller node") parser.add_argument('-i', '--inventory', default='', help="The inventory file") parser.add_argument('-f', '--function', default='regular', help="The function of the node") args = parser.parse_args() address = str(args.address) port = int(args.port) config = args.config inventory = args.inventory function = args.function node = Simnode(args.nodetype, config, inventory) app.run(address, port) ''' routes: /<node-id> /<node-id>/status/<http status code> /<node-id>/latency</latency> /<node-id>/info /<node-id>/text/<text payload> /<node-id>/file/<absolute or relative file payload> ... We should also be able to POST files to a certain location on the filesystem and retrieve that file with GET /<node-id>/method/<custom simnode method to call>/<csv-separated args> NOTE: Should probably set limits on these...cpu, mem, I/O, and disk space to 75% max /<node-id>/cpu/<cpu percentage> ... can probably use this: http://people.seas.harvard.edu/~apw/stress/ /<node-id>/mem/<memory percentage>