#!/usr/bin/env python # Author: Ocean <*****@*****.**> # Created Time: 日 3/ 5 17:47:22 2017 # coding=utf-8 ## Last Modified : 一 3 06 11:20:37 2017 from japronto import Application app = Application() r = app.router # Requests with the path set exactly to '/' and whatever method # will be directed here. def slash(request): return request.Response(text='Hello {} /!'.format(request.method)) r.add_route('/', slash) # Requests with the path set exactly to '/love' and the method # set exactly to 'GET' will be directed here. def get_love(request): return request.Response(text='Got some love') r.add_route('/love', get_love, 'GET') # Requests with the path set exactly to '/methods' and the method
def basic_view(request): return json_response(request, {'hello':'Hello world!'}) def get_query_data(request): if request.body: if request.mime_type == "application/graphql": return { 'query': request.body.decode("utf-8"), 'operationName': request.query.get('operationName') } return get_json_body(request) backend = GraphQLCachedBackend(GraphQLCoreBackend()) def graphql_view(request): data = get_query_data(request) query = data.get('query') operation_name = data.get('operationName') result = graphql(schema, query, backend=backend, operation_name=operation_name, validate=False) return json_response(request, result.to_dict()) if __name__ == '__main__': app = Application() app.router.add_route('/basic', basic_view) app.router.add_route('/graphql', graphql_view) app.run()
"""python japronto_app.py""" from japronto import Application def hello(request): return request.Response(text='Hello world!') # 150000 app = Application() app.router.add_route('/', hello) app.run(debug=False, worker_num=4, port=8000)
import sys from japronto import Application async def hello(request): return request.Response(text='hello world') class Application(Application): @property def _log_request(self): return False @_log_request.setter def _log_request(self, value): pass port = int(sys.argv[1]) app = Application() app.router.add_route('/', hello) app.run(debug=False, port=port)
pass conn = sqlite3.connect('example.sqlite') c = conn.cursor() c.execute(''' CREATE TABLE product ( product_id INTEGER PRIMARY KEY, description TEXT)''') for product_id in range(1, NUMBER_OF_PRODUCTS + 1): description = ''.join( random.choice(string.ascii_letters + string.digits) for n in range(NUMBER_OF_RANDOM_LETTERS_IN_DESCRIPTION)) c.execute('INSERT INTO product VALUES (?, ?)', (product_id, description)) conn.commit() def params(request): product_id = request.match_dict['product_id'] # actually discard `product_id` and use random product_id = random.randint(1, NUMBER_OF_PRODUCTS) c = conn.cursor() c.execute('SELECT description FROM product WHERE product_id=?', (product_id, )) description, = c.fetchone() return request.Response(text=description) app = Application() app.router.add_route('/{product_id}', params) app.run(debug=False)
from japronto import Application import time # from time import time import aiotarantool import tarantool from tarantool import const import traceback import asyncio import uvloop loop = uvloop.new_event_loop() asyncio.set_event_loop(loop) app = Application() app._loop = loop class TarantoolDriver(): def __init__(self, host=None, port=None): if host and port: self.taran = aiotarantool.connect(str(host), int(port), user='******', password="******") else: self.taran = aiotarantool.connect("127.0.0.1", 3311, user='******', password="******") async def close(self): print('Close {}'.format(str(self.__hash__)))
loginId = data["loginId"] password = data["password"] if authenticate(loginId, password, authMap): token = createToken() executor.submit(lambda: loginTokenProcess(token, loginId, loginToTokenMap, tokenToLoginIdMap)) return request.Response(json={ "token": token }) return request.Response(json='Rejected', code=401) async def next(request): global loginToTokenMap, tokenToLoginIdMap, authMap, executor token = request.json["token"] if not token in tokenToLoginIdMap: return request.Response(json=["TokenExpired", "TokenTampered", "InvalidToken"], code=401) loginId = tokenToLoginIdMap[token] if loginToTokenMap[loginId] != token: return request.Response(json=["MiddlemanPresent", "MightBeDesignError"], code=401) # Fit a reverse proxy newToken = createToken() executor.submit(lambda: loginTokenProcess(newToken, loginId, loginToTokenMap, tokenToLoginIdMap)) return request.Response(json={ "token": newToken }) app = Application() app.router.add_route('/', hello) app.router.add_route('/login', login) app.router.add_route('/next', next) app.run(port=8001)
# -*- coding: utf-8 -*- from japronto import Application from module.item_module import TempRecord port = 7011 app = Application() async def query_func(request): mes = {"message": "success"} args = request.query form = request.match_dict sn = form['sn'] if form.get('sn') else args.get("sn", "") f = {"sn": sn} r = TempRecord.find_one(filter_dict=f) if r is None: mes['message'] = "Not Found!" else: mes['result'] = str(r['_id']) resp = request.Response(text="ok") return resp app.router.add_route(pattern="/query", handler=query_func) if __name__ == "__main__": """ 和mongodb有兼容性问题,会报错:
from japronto import Application, RouteNotFoundException from base.qiniu_cli import * from helloword.ymlinks_basic import * from helloword.ymlinks_body import * from helloword.ymlinks_exception import * from helloword.ymlinks_html import * from helloword.ymlinks_req_extend import * from helloword.ymlinks_todo import * from wechat.wechat_gate import * app = Application() r = app.router r.add_route('/', hello) r.add_route('/sync', synchronous) r.add_route('/async', asynchronous) r.add_route('/love', get_love, 'GET') r.add_route('/methods', methods, methods=['POST', 'DELETE']) r.add_route('/params/{p1}/{p2}', params) r.add_route('/basic', basic) r.add_route('/body', body) r.add_route('/misc', misc) r.add_route('/text', text) r.add_route('/encoding', encoding) r.add_route('/mime', mime) r.add_route('/qrcode/{p1}', generate_qrcode, method='GET') r.add_route('/body', body) r.add_route('/json', json) r.add_route('/code', code) r.add_route('/headers', headers) r.add_route('/cookies', cookies)
import json from japronto import Application # Views handle logic, take request as a parameter and # returns Response object back to the client def hello(request): return request.Response(text=json.dumps({'foo': 'bar'})) # The Application instance is a fundamental concept. # It is a parent to all the resources and all the settings # can be tweaked here. app = Application() # The Router instance lets you register your handlers and execute # them depending on the url path and methods app.router.add_route('/', hello) # Finally start our server and handle requests until termination is # requested. Enabling debug lets you see request logs and stack traces. app.run(debug=False, port=8085)
json["numberOfNearbyNeutralCreeps"], json["lowestEnemyCreepHealth"], ) # Reward of choosing previous action reward = json["reward"] # Update the Deep Q Net with new state and the reward transitioning from # the previou state to this new state # Note: + 1 because Lua index starts at 1 action = net.update(json["team"], reward, signal) + 1 # Printing out some stats print(action, reward) except (JSONDecodeError, AttributeError) as e: print("Error") action = 1 return req.Response(json={"action": action}) return req.Response("hi") def save(req): net.save() return req.Response("Saved") app = Application() app.router.add_route("/", main) app.router.add_route("/save", save) app.run(reload=True, debug=True)
try: fp = 'files/' + request.query['fp'] async with aiofiles.open(fp) as f: return request.Response(text=await f.read()) except (FileNotFoundError, NotADirectoryError): return request.Response(text=f'No such file found: {fp}', code=404) ## Other useful stuff ## async def b64(request): '''Encodes and decodes your given text''' mode = request.query.get('mode') message = request.query.get('message') if mode and message: if mode == 'encode': return request.Response(json={'response':base64.b64encode(message)}) elif mode == 'decode': try: return request.Response(json={'response':base64.b64decode(message)}) except: return request.Response(json={'response':'Invalid Base64 String to decode'}, status=400) else: return request.Response(json={'response':'Unknown mode'}, status=400) return request.Response(json={'response':'Invalid Call'}, status=400) app = Application() app.router.add_route('/', main) app.router.add_route('/file', get_file) app.router.add_route('/base64', b64) app.run(port=int(os.getenv('PORT')))
rec_list = rec_list[:return_size] #保留前n个 except Exception as e: print(e) return_dict = {'status': 610, 'info': e, 'data': ['']} return request.Response(json=return_dict) if len(rec_list) > 0: for i in rec_list: pipe.execute_command('bf.add', user_id + '_bloom', i) tmp_result = pipe.execute() # 给进布隆过滤器 redis1.zremrangebyrank(user_id + md5_content, 0, return_size - 1) # 已返回的就从redis表中移除 #print(rec_list) return_dict = {'status': 200, 'info': 'success', 'data': rec_list} return request.Response(json=return_dict) return request.Response(text='穿山甲到底说了什么?') app = Application() app.router.add_route('/tuijian/v3.4', tuijian) app.run(host='127.0.0.1', port=14593, debug=True)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from japronto import Application def index(request): return request.Response(text='') def create_user(request): return request.Response(text='') def get_user(request): return request.Response(text=str(request.match_dict['id'])) app = Application() app.router.add_route('/', index) app.router.add_route('/user', create_user, 'POST') app.router.add_route('/user/{id}', get_user, 'GET') app.run(debug=False, host='0.0.0.0', port=3000)
# into 200 responses by the handlers registered later def cat(request): raise KittyError() def dog(request): raise DoggieError() # This handler raises ZeroDivisionError which doesnt have an error # handler registered so it will result in 500 Internal Server Error def unhandled(request): 1 / 0 app = Application() r = app.router r.add_route('/cat', cat) r.add_route('/dog', dog) r.add_route('/unhandled', unhandled) # These two are handlers for `Kitty` and `DoggyError`s. def handle_cat(request, exception): return request.Response(text='Just a kitty, ' + exception.greet) def handle_dog(request, exception): return request.Response(text='Just a doggie, ' + exception.greet)
# into 200 responses by the handlers registered later def cat(request): raise KittyError() def dog(request): raise DoggieError() # This handler raises ZeroDivisionError which doesn't have an error # handler registered so it will result in 500 Internal Server Error def unhandled(request): 1 / 0 app = Application() r = app.router r.add_route('/cat', cat) r.add_route('/dog', dog) r.add_route('/unhandled', unhandled) # These two are handlers for `Kitty` and `DoggyError`s. def handle_cat(request, exception): return request.Response(text='Just a kitty, ' + exception.greet) def handle_dog(request, exception): return request.Response(text='Just a doggie, ' + exception.greet)
# A view can read HTML from a file def index(request): with open('index.html') as html_file: return request.Response(text=html_file.read(), mime_type='text/html') # A view could also return a raw HTML string def example(request): return request.Response(text='<h1>Some HTML!</h1>', mime_type='text/html') template = Template('<h1>Hello {{ name }}!</h1>') # A view could also return a rendered jinja2 template def jinja(request): return request.Response(text=template.render(name='World'), mime_type='text/html') # Create the japronto application app = Application() # Add routes to the app app.router.add_route('/', index) app.router.add_route('/example', example) app.router.add_route('/jinja2', jinja) # Start the server app.run(debug=True)
from japronto import Application from routes import routes app = Application() routes.add_routes(app.router) app.run(debug=True, port=9002)
import asyncio import time from japronto import Application async def get_sync(request): time.sleep(5) return request.Response(text='OK') async def get_async(request): await asyncio.sleep(5) return request.Response(text='OK') app = Application() app.router.add_route('/sync', get_sync) app.router.add_route('/async', get_async) app.run(port=5000)
if i not in service_to_remove: service_to_remove.append(i) except Exception as e: print(e) try: for stack in stack_to_remove: print(f"remove {stack.name}") stack.remove() for service in service_to_remove: print(f"remove {service.stack().name}/{service.name}") service.remove() except Exception as e: print(e) async def connect_scheduler(): scheduler = AsyncIOScheduler(timezone="UTC") scheduler.add_job(get_project_and_stacks, 'interval', seconds=int(os.getenv('get_project_and_stacks', 1800))) scheduler.add_job(find_old_containers, 'interval', seconds=int(os.getenv('find_old_containers', 1200))) scheduler.add_job(clean_old_ss, 'interval', seconds=int(os.getenv('remove_old_ss', 600))) scheduler.start() app = Application() app.loop.run_until_complete(get_project_and_stacks()) app.loop.run_until_complete(find_old_containers()) app.loop.run_until_complete(clean_old_ss()) app.loop.run_until_complete(connect_scheduler()) router = app.router router.add_route('/', index) app.run(debug=bool(int(os.getenv('DEBUG', 0))))
DB_FILE = os.path.abspath( os.path.join(os.path.dirname(__file__), 'todo.sqlite')) db_connect = partial(sqlite3.connect, DB_FILE) def maybe_create_schema(): db = db_connect() db.execute(""" CREATE TABLE IF NOT EXISTS todos (id INTEGER PRIMARY KEY, todo TEXT)""") db.close() maybe_create_schema() app = Application() def cursor(request): def done_cb(request): request.extra['conn'].close() if 'conn' not in request.extra: request.extra['conn'] = db_connect() request.add_done_callback(done_cb) return request.extra['conn'].cursor() app.extend_request(cursor, property=True) router = app.router
import sys from japronto import Application def index(request): return request.Response(text='') def create_user(request): return request.Response(text='') def get_user(request): return request.Response(text=str(request.match_dict['id'])) app = Application() app.router.add_route('/', index) app.router.add_route('/user', create_user, 'POST') app.router.add_route('/user/{id}', get_user, 'GET') app.run(host='0.0.0.0', worker_num=int(sys.argv[1]), port=3000)
request.add_done_callback(cb) return request.Response(text='cb') # This is a body for reversed_agent property def reversed_agent(request): return request.headers['User-Agent'][::-1] # This is a body for host_startswith method # Custom methods and properties always accept request # object. def host_startswith(request, prefix): return request.headers['Host'].startswith(prefix) app = Application() # Finally register out custom property and method # By default the names are taken from function names # unelss you provide `name` keyword parameter. app.extend_request(reversed_agent, property=True) app.extend_request(host_startswith) r = app.router r.add_route('/', extended_hello) r.add_route('/callback', with_callback) app.run()
import sys from multiprocessing import cpu_count from japronto import Application def naked(request): return request.Response(b'Naked!') app = Application() app.router.add_route('/', naked, method='GET') app.run(debug=False) if __name__ == '__main__': app.run(host=sys.argv[1], workers=cpu_count(), debug=False, port=int(sys.argv[2]))
this_catalog = REGISTRY.query(f"{registry_url}/v2/_catalog", 'get')['repositories'] if len(this_catalog) != len(CATALOG): print(f"Found {len(this_catalog)} repositories") CATALOG = this_catalog async def connect_scheduler(): scheduler = AsyncIOScheduler(timezone="UTC") scheduler.add_job(get_catalog, 'interval', seconds=int(os.getenv('DRIC_SECONDS_CATALOG', 300)), max_instances=1) scheduler.start() async def index(request): global CATALOG return request.Response(json=CATALOG) app = Application() app.extend_request(lambda x: REGISTRY, name='registry', property=True) app.loop.run_until_complete(get_catalog(first_load=True)) app.loop.run_until_complete(connect_scheduler()) router = app.router router.add_route('/{project_namespace}/{project_name}/{tag}', batch_remove) router.add_route('/extra_path', single_remove) router.add_route('/', index) app.run(host='0.0.0.0', port=80, debug=True)
def start(current_bot): global bot bot = current_bot server = Application() server.router.add_route('/', handle_all_activity) server.run(debug=True)
return plyvel.DB(path, create_if_missing=True) def env(request): result = "remote_addr: " + request.remote_addr + "\n" + \ "hostname: " + request.hostname + "\n" + \ "port: " + str(request.port) + "\n\n" if request.headers: for name, value in request.headers.items(): result += " {0}: {1}\n".format(name, value) return request.Response(text=result) def db(request): result = "open" if DB.closed: result = "closed" else: DB.close() result = "close the DB" return request.Response(text=result) DB = open_leveldb(leveldb_path) app = Application() app.router.add_route("/env", env) app.router.add_route("/db", db) app.run(debug=True, host=host_name, port=port_number)
import json from app.utils import rule_util import traceback from app.config.logging_config import config as log_config_dict # Setup logging logging.config.dictConfig(log_config_dict) info_logger = logging.getLogger('info_logger') debug_logger = logging.getLogger('debug_logger') error_logger = logging.getLogger('error_logger') application = Application() def ping(request): info_logger.info('/ping') return request.Response(code=200, text=json.dumps({'message': 'Hey, I\'m running'}), mime_type='application/json') def get_rule_type(request): try: match_dict = request.match_dict info_logger.info('REQ: {}'.format(str(match_dict))) res = rule_util.get_rule_type(match_dict) info_logger.info('RES: {}'.format(str(res)))
def init(loop_param=None, port_param=None): """Init Janpronto server in like-oop style.""" global loop, port, app loop = loop_param port = port_param app = Application()
#!/usr/bin/env python from japronto import Application def index(request): return request.Response(text='') def create_user(request): return request.Response(text='') def get_user(request): return request.Response(text=str(request.match_dict['id'])) app = Application() app.router.add_route('/', index) app.router.add_route('/user', create_user, 'POST') app.router.add_route('/user/{id}', get_user, 'GET') app.run(debug=False, port=3000)
from japronto import Application def ping(request): return request.Response(json={'message': 'pong'}) app = Application() app.router.add_route('/', ping) app.run(debug=False, worker_num=8)
await mongoHandler.set_db_and_collection('beepaste', 'texts') inited = 1 body = request.json ret = await mongoHandler.insert(body) return request.Response(json={'id': str(ret.inserted_id)}) async def fetch(request): global inited if not inited: await mongoHandler.get_connection() await mongoHandler.set_db_and_collection('beepaste', 'texts') inited = 1 body = request.json['id'] ret = await mongoHandler.findById(body) return request.Response(json={ 'id': str(ret['_id']), 'text': str(ret['text']) }) app = Application() r = app.router r.add_route('/save', save, methods=['POST']) r.add_route('/fetch', fetch, methods=['POST']) app.run(port=8080)
async def connect_scheduler(): scheduler = AsyncIOScheduler(timezone="UTC") scheduler.add_job(add_registry_path, CronTrigger.from_crontab( os.getenv('DRS3GC_CRON_PATH', '0 0 * * 0')), max_instances=1) scheduler.add_job(cleanup_tag, 'interval', seconds=int(os.getenv('DRS3GC_SECONDS_CLEANUP', 5)), max_instances=10) scheduler.add_job(scan_bucket, 'interval', seconds=int(os.getenv('DRS3GC_SECONDS_SCAN', 1)), max_instances=10) scheduler.start() async def index(request): global REGISTRY_LATEST return request.Response(json=REGISTRY_LATEST) app = Application() app.loop.run_until_complete(scan_bucket()) app.loop.run_until_complete(connect_scheduler()) router = app.router router.add_route('/', index) app.run(host='0.0.0.0', port=80, debug=True)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from japronto import Application def index(request): return request.Response(text='') def create_user(request): return request.Response(text='') def get_user(request): return request.Response(text=str(request.match_dict['id'])) app = Application() app.router.add_route('/', index) app.router.add_route('/user', create_user, 'POST') app.router.add_route('/user/{id}', get_user, 'GET') app.run(debug=False, port=3000)
from japronto import Application def hello(request): return request.Response(text='Hello world!') app = Application() r = app.router r.add_route('/', hello, method='GET') app.run()
request.add_done_callback(cb) return request.Response(text='cb') # This is a body for reversed_agent property def reversed_agent(request): return request.headers['User-Agent'][::-1] # This is a body for host_startswith method # Custom methods and properties always accept request # object. def host_startswith(request, prefix): return request.headers['Host'].startswith(prefix) app = Application() # Finally register the custom property and method # By default the names are taken from function names # unelss you provide `name` keyword parameter. app.extend_request(reversed_agent, property=True) app.extend_request(host_startswith) r = app.router r.add_route('/', extended_hello) r.add_route('/callback', with_callback) app.run()