def configure_bottle(supervisor):
supervisor.app.install(bottle.JSONPlugin(json_dumps=json_dumps))
bottle.debug(supervisor.config['app.debug'])
bottle.BaseTemplate.defaults.update({
'DEBUG':
bottle.DEBUG,
'request':
bottle.request,
'h':
html,
'esc':
html_escape,
'aesc':
attr_escape,
'th':
template_helper,
'url':
supervisor.app.get_url,
'csrf_tag':
csrf.csrf_tag,
'_':
lambda x: x,
'REDIRECT_DELAY':
supervisor.config.get('app.redirect_delay', 5),
'u':
to_unicode,
})
def get_app(config):
"""
Get a Bottle app instance with all the routes set-up.
:return: The built bottle app.
"""
get_session = database.init_db(config["database"], config["search_index"])
app = bottle.default_app()
app.install(DatabasePlugin(get_session))
app.install(ConfigPlugin(config))
app.config.setdefault("canister.log_level", logging.root.level)
app.config.setdefault("canister.log_path", None)
app.config.setdefault("canister.debug", False)
app.install(canister.Canister())
# Use DateAwareJSONEncoder to dump JSON strings
# From http://stackoverflow.com/questions/21282040/bottle-framework-how-to-return-datetime-in-json-response#comment55718456_21282666. pylint: disable=locally-disabled,line-too-long
bottle.install(
bottle.JSONPlugin(
json_dumps=functools.partial(json.dumps, cls=DateAwareJSONEncoder)
)
)
# API v1 routes
app.route("/api/v1/", "GET", api_routes.index_v1)
app.route("/api/v1/time_to_places", "GET",
api_routes.time_to_places_v1)
app.route("/api/v1/flats", "GET", api_routes.flats_v1)
app.route("/api/v1/flats/status/:status", "GET",
api_routes.flats_by_status_v1)
app.route("/api/v1/flat/:flat_id", "GET", api_routes.flat_v1)
app.route("/api/v1/flat/:flat_id/status", "POST",
api_routes.update_flat_status_v1)
app.route("/api/v1/flat/:flat_id/notes", "POST",
api_routes.update_flat_notes_v1)
app.route("/api/v1/flat/:flat_id/notation", "POST",
api_routes.update_flat_notation_v1)
app.route("/api/v1/search", "POST", api_routes.search_v1)
# Index
app.route("/", "GET", lambda: _serve_static_file("index.html"))
# Static files
app.route("/favicon.ico", "GET",
lambda: _serve_static_file("favicon.ico"))
app.route(
"/assets/<filename:path>", "GET",
lambda filename: _serve_static_file("/assets/{}".format(filename))
)
app.route(
"/img/<filename:path>", "GET",
lambda filename: _serve_static_file("/img/{}".format(filename))
)
return app
def init():
db.connect()
db.create_tables([Report])
if not db.is_closed():
db.close()
# Use DateAwareJSONEncoder to dump JSON strings
# From http://stackoverflow.com/questions/21282040/bottle-framework-how-to-return-datetime-in-json-response#comment55718456_21282666. pylint: disable=locally-disabled,line-too-long
bottle.install(
bottle.JSONPlugin(json_dumps=functools.partial(
json.dumps, cls=DateAwareJSONEncoder)))
def __init__(
self,
mongo_host=None,
mongo_port=None,
mongo_replica_set=None,
emailer=None,
metrics=None,
):
super().__init__()
self.__mongo = mongo_connection(mongo_host=mongo_host,
mongo_port=mongo_port,
mongo_replica_set=mongo_replica_set)
self.__boulders = {}
api.register(self)
self.__emailer = emailer
self.__metrics = metrics
def json_bson_dumps(body):
import bson.json_util
return bottle.json_dumps(body, default=bson.json_util.default)
self.install(bottle.JSONPlugin(json_bson_dumps))
Gary Bishop May 2020
"""
import bottle
from bottle import view
from db import with_db, insert
import json
import os.path as osp
from datetime import datetime
# startup bottle
# allow returning datetime objects in json
app = application = bottle.Bottle(autojson=False)
app.install(bottle.JSONPlugin(json_dumps=lambda s: json.dumps(s, default=str)))
# make get_url available in all templates
def get_url(name, user=None, **kwargs):
"""get_url for use from templates"""
url = app.get_url(name, **kwargs)
return url
bottle.SimpleTemplate.defaults["get_url"] = get_url
def allow_json(func):
""" Decorator: renders as json if requested """
log = logging.getLogger("detector")
metrics = setup_metrics(name="detector")
db_conn = None # Set by detector.py or during functional testing
asn_db = None # Set by detector.py
def _datetime_handler(x):
if isinstance(x, datetime):
return x.isoformat()
raise TypeError("unknown type")
bottle.install(
bottle.JSONPlugin(json_dumps=lambda o: json.dumps(o, default=_datetime_handler))
)
def generate_chart(start_d, end_d, msmts, changes, title):
"""Render measurements and changes into a SVG chart
:returns: dict
"""
assert isinstance(msmts[0][0], datetime)
x1 = 100
x2 = 1100
y1 = 50
y2 = 300
# scale x
delta = (end_d - start_d).total_seconds()
assert delta != 0
# app is for campability for gunicorn
app = bottle.default_app()
# application is for compability for uwsgi
application = app
class AvroEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, bytes):
try:
return obj.decode('utf8')
except:
return obj.decode('base64')
return json.JSONEncoder.default(self, obj)
app.install(
bottle.JSONPlugin(json_dumps=lambda s: json.dumps(s, cls=AvroEncoder))
)
@app.post('/avro/decode')
def decode_evh_capture():
#import pdb;pdb.set_trace()
reader = fastavro.reader(request.body)
ret = []
for l in reader:
ret.append(l)
return {'content': ret}
if __name__ == "__main__":
app.run(host='localhost', port=8080, reloader=True)
from BroControl import version
from BroControl.ser import dumps
import os
import bottle
import json
app = bottle.Bottle(autojson=False)
app.install(
bottle.JSONPlugin(json_dumps=lambda s: json.dumps(s, default=dumps)))
@app.route('/start')
def start():
i = app.daemon.call("start")
return {"id": i}
@app.route('/stop')
def start():
i = app.daemon.call("stop")
return {"id": i}
@app.route('/restart')
def restart():
i = app.daemon.call("restart")
return {"id": i}
@app.route('/nodes')
def nodes():
def main():
bottle.install(
bottle.JSONPlugin(
json_dumps=lambda s: json.dumps(s, cls=CustomJsonEncoder)))
bottle.run(host='0.0.0.0', port=8888, server='gevent')
def __init__(self, app):
app.install(
bottle.JSONPlugin(
json_dumps=lambda s: json.dumps(s, cls=JsonDatetimeZEncoder)))
self.app = app
def __init__(self, robot, host='localhost', port=8080):
AbstractServer.__init__(self, robot)
self.host = host
self.port = port
self.app = bottle.Bottle()
self.app.install(
bottle.JSONPlugin(
json_dumps=lambda s: json.dumps(s, cls=self.json_encoder)))
@self.app.get('/motor/list.json')
def get_motor_list():
req = {
'get': {
'': [
'motors',
]
}
}
return self.request_handler.handle_request(req)['get']['']
@self.app.get('/primitive/list.json')
def get_primitive_list():
req = {
'get': {
'': [
'attached_primitives_name',
]
}
}
return self.request_handler.handle_request(req)['get']['']
@self.app.get('/<name>/register.json')
@self.app.get('/motor/<name>/register.json')
def get_motor_register(name):
req = {
'get': {
name: [
'registers',
]
}
}
return self.request_handler.handle_request(req)['get'][name]
@self.app.get('/<name>/<register>')
@self.app.get('/motor/<name>/<register>')
def get_object_register(name, register):
req = {
'get': {
name: [
register,
]
}
}
return self.request_handler.handle_request(req)['get'][name]
@self.app.post('/<name>/<register>')
@self.app.post('/motor/<name>/<register>')
def set_object_register(name, register):
req = {'set': {name: {register: bottle.request.json}}}
return self.request_handler.handle_request(req)
@self.app.post('/<prim_name>/call/<meth_name>')
@self.app.post('/primitive/<prim_name>/call/<meth_name>')
def call_prim_meth(prim_name, meth_name):
req = {'call': {prim_name: {meth_name: bottle.request.json}}}
return self.request_handler.handle_request(req)['call'][prim_name]
@self.app.post('/request.json')
def request():
return self.request_handler.handle_request(bottle.request.json)
logger.info('Starting HTTPServer on http://%s:%s', host, port)
try:
body = callback(session, *args, **kwargs)
except sqlalchemy.exc.SQLAlchemyError as exc:
session.rollback()
raise bottle.HTTPError(500, "A database error occurred.", exc)
finally:
session.close()
return body
return wrapper
app.install(create_sqlalchemy_session)
app.install(bottle.JSONPlugin())
def send_bytes(bytes_, mimetype):
"""Bottle method for sending bytes objects."""
headers = dict()
headers["Content-Type"] = mimetype
headers["Content-Length"] = len(bytes_)
body = "" if bottle.request.method == "HEAD" else bytes_
return bottle.HTTPResponse(body, **headers)
##################
# Error handling #
##################
def __init__(self, robot, host, port):
AbstractServer.__init__(self, robot, host, port)
self.app = bottle.Bottle()
jd = lambda s: json.dumps(s, cls=MyJSONEncoder)
self.app.install(bottle.JSONPlugin(json_dumps=jd))
rr = self.restfull_robot
# Motors route
@self.app.get('/motor/list.json')
@self.app.get('/motor/<alias>/list.json')
def get_motor_list(alias='motors'):
return {alias: rr.get_motors_list(alias)}
@self.app.get('/sensor/list.json')
def get_sensor_list():
return {'sensors': rr.get_sensors_list()}
@self.app.get('/motor/alias/list.json')
def get_motor_alias():
return {'alias': rr.get_motors_alias()}
@self.app.get('/motor/<motor_name>/register/list.json')
@self.app.get('/sensor/<motor_name>/register/list.json')
def get_motor_registers(motor_name):
return {'registers': rr.get_motor_registers_list(motor_name)}
@self.app.get('/motor/<motor_name>/register/<register_name>')
@self.app.get('/sensor/<motor_name>/register/<register_name>')
def get_register_value(motor_name, register_name):
return {
register_name:
rr.get_motor_register_value(motor_name, register_name)
}
@self.app.post(
'/motor/<motor_name>/register/<register_name>/value.json')
@self.app.post(
'/sensor/<motor_name>/register/<register_name>/value.json')
def set_register_value(motor_name, register_name):
rr.set_motor_register_value(motor_name, register_name,
bottle.request.json)
return {}
# Sensors route
# Primitives route
@self.app.get('/primitive/list.json')
def get_primitives_list(self):
return {'primitives': rr.get_primitives_list()}
@self.app.get('/primitive/running/list.json')
def get_running_primitives_list(self):
return {'running_primitives': rr.get_running_primitives_list()}
@self.app.get('/primitive/<prim>/start.json')
def start_primitive(self, prim):
rr.start_primitive(prim)
@self.app.get('/primitive/<prim>/stop.json')
def stop_primitive(self, prim):
rr.stop_primitive(prim)
@self.app.get('/primitive/<prim>/pause.json')
def pause_primitive(self, prim):
rr.pause_primitive(prim)
@self.app.get('/primitive/<prim>/resume.json')
def resume_primitive(self, prim):
rr.resume_primitive(prim)
@self.app.get('/primitive/<prim>/property/list.json')
def get_primitive_properties_list(self, prim):
return {'property': rr.get_primitive_properties_list(prim)}
@self.app.get('/primitive/<prim>/property/<prop>')
def get_primitive_property(self, prim, prop):
res = rr.get_primitive_property(prim, prop)
return {'{}.{}'.format(prim, prop): res}
@self.app.post('/primitive/<prim>/property/<prop>/value.json')
def set_primitive_property(self, prim, prop):
rr.set_primitive_property(prim, prop, bottle.request.json)
@self.app.get('/primitive/<prim>/method/list.json')
def get_primitive_methods_list(self, prim):
return {'methods': rr.get_primitive_methods_list(self, prim)}
@self.app.post('/primitive/<prim>/method/<meth>/args.json')
def call_primitive_method(self, prim, meth):
res = rr.call_primitive_method(prim, meth, bottle.request.json)
return {'{}:{}'.format(prim, meth): res}
def registra_plugins():
from bottle_cerberus import CerberusPlugin
bottle.install(CerberusPlugin())
bottle.install(bottle.JSONPlugin(json_dumps=lambda s: simplejson.dumps(s, cls=CustomEncoder)))
import bottle
from bottle import route
# from bottle.ext import sqlalchemy
import bottle.ext.sqlalchemy
import latci.database
import functools
from latci import config
import latci.json
application = bottle.app()
application.uninstall(bottle.JSONPlugin)
application.install(bottle.JSONPlugin(json_dumps=functools.partial(latci.json.dumps, indent=True)))
# Install SQLAlchemy plguin
application.install(
bottle.ext.sqlalchemy.Plugin(
latci.database.engine, # SQLAlchemy engine created with create_engine function.
None, # SQLAlchemy metadata, required only if create=True.
keyword='db', # Keyword used to inject session database in a route (default 'db').
create=False, # If it is true, execute `metadata.create_all(engine)` when plugin is applied (default False).
commit=False, # If it is true, plugin commit changes after route is executed (default True).
use_kwargs=True # If it is true and keyword is not defined, plugin uses **kwargs argument to inject session database (default False).
)
)
# Required for proper initialization of routes. Can't be before bottle.app() calls.
import latci.views
from pyethereum.chainmanager import chain_manager
from pyethereum.peermanager import peer_manager
import pyethereum.dispatch as dispatch
from pyethereum.blocks import block_structure, Block
import pyethereum.signals as signals
from pyethereum.transactions import Transaction
import pyethereum.processblock as processblock
import pyethereum.utils as utils
import pyethereum.rlp as rlp
from ._version import get_versions
logger = logging.getLogger(__name__)
app = bottle.Bottle()
app.config['autojson'] = False
app.install(bottle.JSONPlugin(json_dumps=lambda s: json.dumps(s, sort_keys=True)))
class ApiServer(threading.Thread):
def __init__(self):
super(ApiServer, self).__init__()
self.daemon = True
self.listen_host = '127.0.0.1'
self.port = 30203
def configure(self, config):
self.listen_host = config.get('api', 'listen_host')
self.port = config.getint('api', 'listen_port')
# add api_path to bottle to be used in the middleware
api_path = config.get('api', 'api_path')
def __init__(self, robot, host='localhost', port=8080):
AbstractServer.__init__(self, robot)
self.host = host
self.port = port
self.app = bottle.Bottle()
self.app.install(
bottle.JSONPlugin(
json_dumps=lambda s: json.dumps(s, cls=MyJSONEncoder)))
#test index
# @self.app.get('/')
# def index(name='test'):
# # return bottle.template('<b>Hello {{name}}</b>!', name=name)
# idx = '/home/steve/Project/Repo/poppy-software/example/web/'
# return bottle.static_file('/',root = idx )
# test index
@self.app.get('/<filename>')
def index_static(filename):
# return bottle.template('<b>Hello {{name}}</b>!', name=name)
path = '/home/steve/Project/Repo/poppy-software/example/web/'
return bottle.static_file(filename, root=path)
@self.app.get('/flot/<filename>')
def index_static(filename):
# return bottle.template('<b>Hello {{name}}</b>!', name=name)
path = '/home/steve/Project/Repo/poppy-software/example/web/flot/'
return bottle.static_file(filename, root=path)
@self.app.get('/motor/list.json')
def get_motor_list():
req = {
'get': {
'': [
'motors',
]
}
}
return self.request_handler.handle_request(req)['get']['']
@self.app.get('/primitive/list.json')
def get_primitive_list():
req = {
'get': {
'': [
'attached_primitives_name',
]
}
}
return self.request_handler.handle_request(req)['get']['']
@self.app.get('/<name>/register.json')
@self.app.get('/motor/<name>/register.json')
def get_motor_register(name):
req = {
'get': {
name: [
'registers',
]
}
}
return self.request_handler.handle_request(req)['get'][name]
@self.app.get('/<name>/<register>')
@self.app.get('/motor/<name>/<register>')
def get_object_register(name, register):
req = {
'get': {
name: [
register,
]
}
}
return self.request_handler.handle_request(req)['get'][name]
@self.app.post('/<name>/<register>')
@self.app.post('/motor/<name>/<register>')
def set_object_register(name, register):
req = {'set': {name: {register: bottle.request.json}}}
return self.request_handler.handle_request(req)
@self.app.post('/<prim_name>/call/<meth_name>')
@self.app.post('/primitive/<prim_name>/call/<meth_name>')
def call_prim_meth(prim_name, meth_name):
req = {'call': {prim_name: {meth_name: bottle.request.json}}}
return self.request_handler.handle_request(req)['call'][prim_name]
@self.app.post('/request.json')
def request():
return self.request_handler.handle_request(bottle.request.json)
logger.info('Starting HTTPServer on http://%s:%s', host, port)
class JSONEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, model.Abstract):
value = o.pack()
elif isinstance(o, uuid.UUID):
value = str(o)
else:
value = super().default(o)
return value
app = bottle.Bottle(autojson=False)
app.install(
bottle.JSONPlugin(
json_dumps=functools.partial(json.dumps, cls=JSONEncoder)))
config_key = 'traffexam.{}'.format
@app.route('/address', methpd='GET')
def address_list():
context = get_context()
return address_response(context.service.address.list())
@app.route('/address', method='POST')
def address_create():
context = get_context()
payload = bottle.request.json
payload.pop('idnr', None)
get_related_posts,
payouts_total,
payouts_last_24h,
)
logger = logging.getLogger(__name__)
app = bottle.Bottle()
app.config['hive.MAX_BLOCK_NUM_DIFF'] = 10
app.config['hive.MAX_DB_ROW_RESULTS'] = 100000
app.config['hive.DB_QUERY_LIMIT'] = app.config['hive.MAX_DB_ROW_RESULTS'] + 1
app.config['hive.logger'] = logger
app.install(
bottle.JSONPlugin(json_dumps=lambda s: json.dumps(s, cls=ToStringJSONEncoder)))
app.install(ErrorsRestPlugin())
# Non JSON-RPC routes
# -------------------
@app.get('/health')
def health():
state = db_head_state()
if state['db_head_age'] > app.config['hive.MAX_BLOCK_NUM_DIFF'] * 3:
abort(
500,
'head block age (%ss) > max allowable (%ss); head block num: %s'
% (state['db_head_age'], app.config['hive.MAX_BLOCK_NUM_DIFF'] * 3,
state['db_head_block']))
else:
def get_app(config):
"""
Get a Bottle app instance with all the routes set-up.
:return: The built bottle app.
"""
get_session = database.init_db(config["database"], config["search_index"])
app = bottle.Bottle()
app.install(DatabasePlugin(get_session))
app.install(ConfigPlugin(config))
app.config.setdefault("canister.log_level", "DISABLED")
app.config.setdefault("canister.log_path", False)
app.config.setdefault("canister.debug", False)
app.install(canister.Canister())
# Use DateAwareJSONEncoder to dump JSON strings
# From http://stackoverflow.com/questions/21282040/bottle-framework-how-to-return-datetime-in-json-response#comment55718456_21282666. pylint: disable=locally-disabled,line-too-long
app.install(
bottle.JSONPlugin(json_dumps=functools.partial(
json.dumps, cls=DateAwareJSONEncoder)))
# Enable CORS
@app.hook("after_request")
def enable_cors():
"""
Add CORS headers at each request.
"""
# The str() call is required as we import unicode_literal and WSGI
# headers list should have plain str type.
bottle.response.headers[str("Access-Control-Allow-Origin")] = str("*")
bottle.response.headers[str("Access-Control-Allow-Methods")] = str(
"PUT, GET, POST, DELETE, OPTIONS, PATCH")
bottle.response.headers[str("Access-Control-Allow-Headers")] = str(
"Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token")
# API v1 routes
app.route("/api/v1", ["GET", "OPTIONS"], api_routes.index_v1)
app.route("/api/v1/time_to_places", ["GET", "OPTIONS"],
api_routes.time_to_places_v1)
app.route("/api/v1/flats", ["GET", "OPTIONS"], api_routes.flats_v1)
app.route("/api/v1/flats/:flat_id", ["GET", "OPTIONS"], api_routes.flat_v1)
app.route("/api/v1/flats/:flat_id", ["PATCH", "OPTIONS"],
api_routes.update_flat_v1)
app.route("/api/v1/ics/visits.ics", ["GET", "OPTIONS"],
api_routes.ics_feed_v1)
app.route("/api/v1/search", ["POST", "OPTIONS"], api_routes.search_v1)
app.route("/api/v1/opendata", ["GET", "OPTIONS"],
api_routes.opendata_index_v1)
app.route(
"/api/v1/opendata/postal_codes",
["GET", "OPTIONS"],
api_routes.opendata_postal_codes_v1,
)
app.route("/api/v1/metadata", ["GET", "OPTIONS"], api_routes.metadata_v1)
app.route("/api/v1/import", ["GET", "OPTIONS"], api_routes.import_v1)
# Index
app.route("/", "GET", lambda: _serve_static_file("index.html"))
# Static files
app.route("/favicon.ico", "GET", lambda: _serve_static_file("favicon.ico"))
app.route(
"/assets/<filename:path>",
"GET",
lambda filename: _serve_static_file("/assets/{}".format(filename)),
)
app.route(
"/img/<filename:path>",
"GET",
lambda filename: _serve_static_file("/img/{}".format(filename)),
)
app.route(
"/.well-known/<filename:path>",
"GET",
lambda filename: _serve_static_file("/.well-known/{}".format(filename)
),
)
app.route(
"/data/img/<filename:path>",
"GET",
lambda filename: bottle.static_file(
filename, root=os.path.join(config["data_directory"], "images")),
)
return app
def start_adminpanel(zigate_instance,
port=ADMINPANEL_PORT,
mount=None,
prefix=None,
autostart=True,
daemon=True,
quiet=True,
debug=False):
'''
mount: url prefix used to mount bottle application
prefix: special prefix added when using get_url in template, eg proxy.php
'''
app = bottle.Bottle()
app.install(
bottle.JSONPlugin(json_dumps=lambda s: dumps(s, cls=DeviceEncoder)))
def get_url(routename, **kwargs):
'''
customized get_url to allow additional prefix args
'''
redirect = kwargs.pop('redirect', False)
scriptname = bottle.request.environ.get('SCRIPT_NAME',
'').strip('/') + '/'
location = app.router.build(routename, **kwargs).lstrip('/')
url = bottle.urljoin(bottle.urljoin('/', scriptname), location)
if prefix and not redirect:
url = prefix + '?' + bottle.urlencode({'q': url})
append = '?'
if '?' in url:
append = '&'
url += '{}_={}'.format(append, time.time())
return url
def redirect(routename, **kwargs):
'''
convenient function to redirect using routename instead of url
'''
return bottle.redirect(get_url(routename, redirect=True, **kwargs))
bottle.BaseTemplate.defaults['get_url'] = get_url
bottle.BaseTemplate.defaults['zigate'] = zigate_instance
app.zigate = zigate_instance
@app.route('/', name='index')
@bottle.view('index')
def index():
connected = zigate_instance.connection and zigate_instance.connection.is_connected(
)
grouped_devices = {}
processed = []
def add_device_to_group(group, addr, endpoint=''):
name = 'Missing'
last_seen = ''
if addr == zigate_instance.addr:
name = 'ZiGate'
zdev = zigate_instance.get_device_from_addr(addr)
if zdev:
name = str(zdev)
last_seen = zdev.info.get('last_seen', '')
else:
name = '{} ({})'.format(name, addr)
group.append({
'addr': addr,
'endpoint': endpoint,
'name': name,
'last_seen': last_seen
})
for group, group_devices in zigate_instance.groups.items():
grouped_devices[group] = []
for device in group_devices:
addr = device[0]
endpoint = device[1]
processed.append(addr)
add_device_to_group(grouped_devices[group], addr, endpoint)
grouped_devices[''] = []
for device in zigate_instance.devices:
if device.addr not in processed:
add_device_to_group(grouped_devices[''], device.addr)
port = zigate_instance._port or 'auto'
if hasattr(zigate_instance, '_host'):
port = '{}:{}'.format(zigate_instance._host, port)
return {
'libversion': zigate_version.__version__,
'port': port,
'connected': connected,
'version': zigate_instance.get_version_text(),
'model': zigate_instance.model,
'groups': zigate_instance.groups,
'grouped_devices': grouped_devices,
}
@app.route('/networkmap', name='networkmap')
@bottle.view('networkmap')
def networkmap():
return
@app.route('/device/<addr>', name='device')
@bottle.view('device')
def device(addr):
device = zigate_instance.get_device_from_addr(addr)
if not device:
return redirect('index')
return {'device': device}
@app.route('/api/permit_join', name='api_permit_join')
def permit_join():
zigate_instance.permit_join()
return redirect('index')
@app.route('/api/led', name='api_led')
def set_led():
on = bottle.request.query.get('on', 'true') == 'true'
zigate_instance.set_led(on)
return redirect('index')
@app.route('/api/discover/<addr>', name='api_discover')
def api_discover(addr):
zigate_instance.discover_device(addr, True)
return redirect('device', addr=addr)
@app.route('/api/refresh/<addr>', name='api_refresh')
def api_refresh(addr):
zigate_instance.refresh_device(addr)
return redirect('device', addr=addr)
@app.route('/api/remove/<addr>', name='api_remove')
def api_remove(addr):
force = bottle.request.query.get('force', 'false') == 'true'
zigate_instance.remove_device(addr, force)
return redirect('index')
@app.route('/device/<addr>/save',
name='device_save',
method=['GET', 'POST'])
def device_save(addr):
device = zigate_instance.get_device_from_addr(addr)
if not device:
return redirect('index')
device.name = bottle.request.forms.name
return redirect('device', addr=addr)
@app.route('/api/devices', name='api_devices')
def devices():
devices = [{
'info': {
'addr': zigate_instance.addr,
'ieee': zigate_instance.ieee
},
'friendly_name': 'ZiGate'
}]
for d in zigate_instance.devices:
device = d.to_json()
device['friendly_name'] = str(d)
devices.append(device)
return {'devices': devices}
@app.route('/api/network_table', name='api_network_table')
def network_table():
force = bottle.request.query.get('force', 'false') == 'true'
return {'network_table': zigate_instance.build_neighbours_table(force)}
kwargs = {'host': '0.0.0.0', 'port': port, 'quiet': quiet, 'debug': debug}
if autostart:
r_app = app
if mount:
root_app = bottle.Bottle()
root_app.mount(mount, app)
r_app = root_app
if daemon:
t = threading.Thread(target=r_app.run, kwargs=kwargs, daemon=True)
t.start()
else:
r_app.run(**kwargs)
return app
def __init__(self, robot, host='0.0.0.0', port='8080', cross_domain_origin='*', quiet=True):
AbstractServer.__init__(self, robot, host, port)
self.quiet = quiet
self.app = bottle.Bottle()
jd = lambda s: json.dumps(s, cls=MyJSONEncoder)
self.app.install(bottle.JSONPlugin(json_dumps=jd))
if(cross_domain_origin):
self.app.install(EnableCors(cross_domain_origin))
rr = self.restfull_robot
@self.app.route("/", method=['OPTIONS'])
@self.app.route("/<p:path>", method=['OPTIONS'])
def options(p=""):
return ""
# Motors route
@self.app.get('/')
@self.app.get('/robot.json')
def robot():
out = {
'motors': [],
'primitives': []
}
for m in rr.get_motors_list('motors'):
motor = {}
for r in rr.get_motor_registers_list(m):
try:
motor[r] = rr.get_motor_register_value(m, r)
except AttributeError:
pass
out['motors'].append(motor)
running_primitives = rr.get_running_primitives_list()
for prim in rr.get_primitives_list():
primitve = {'primitive': prim,
'running': prim in running_primitives,
'properties': [],
'methods': rr.get_primitive_methods_list(prim)
}
for prop in rr.get_primitive_properties_list(prim):
primitve['properties'].append({'property': prop, 'value': rr.get_primitive_property(prim, prop)})
out['primitives'].append(primitve)
return out
@self.app.get('/motor/list.json')
@self.app.get('/motor/<alias>/list.json')
def get_motor_list(alias='motors'):
return {
alias: rr.get_motors_list(alias)
}
@self.app.get('/sensor/list.json')
def get_sensor_list():
return {
'sensors': rr.get_sensors_list()
}
@self.app.get('/motor/alias/list.json')
def get_motor_alias():
return {
'alias': rr.get_motors_alias()
}
@self.app.get('/motor/<motor_name>/register/list.json')
@self.app.get('/sensor/<motor_name>/register/list.json')
def get_motor_registers(motor_name):
return {
'registers': rr.get_motor_registers_list(motor_name)
}
@self.app.get('/motor/<motor_name>/register/<register_name>')
@self.app.get('/sensor/<motor_name>/register/<register_name>')
def get_register_value(motor_name, register_name):
return {
register_name: rr.get_motor_register_value(motor_name, register_name)
}
@self.app.post('/motor/<motor_name>/register/<register_name>/value.json')
@self.app.post('/sensor/<motor_name>/register/<register_name>/value.json')
def set_register_value(motor_name, register_name):
rr.set_motor_register_value(motor_name, register_name,
bottle.request.json)
return {}
# Sensors route
# Primitives route
@self.app.get('/primitive/list.json')
def get_primitives_list():
return {
'primitives': rr.get_primitives_list()
}
@self.app.get('/primitive/running/list.json')
def get_running_primitives_list():
return {
'running_primitives': rr.get_running_primitives_list()
}
@self.app.get('/primitive/<prim>/start.json')
def start_primitive(prim):
rr.start_primitive(prim)
@self.app.get('/primitive/<prim>/stop.json')
def stop_primitive(prim):
rr.stop_primitive(prim)
@self.app.get('/primitive/<prim>/pause.json')
def pause_primitive(prim):
rr.pause_primitive(prim)
@self.app.get('/primitive/<prim>/resume.json')
def resume_primitive(prim):
rr.resume_primitive(prim)
@self.app.get('/primitive/<prim>/property/list.json')
def get_primitive_properties_list(prim):
return {
'property': rr.get_primitive_properties_list(prim)
}
@self.app.get('/primitive/<prim>/property/<prop>')
def get_primitive_property(prim, prop):
res = rr.get_primitive_property(prim, prop)
return {
'{}.{}'.format(prim, prop): res
}
@self.app.post('/primitive/<prim>/property/<prop>/value.json')
def set_primitive_property(prim, prop):
rr.set_primitive_property(prim, prop,
bottle.request.json)
@self.app.get('/primitive/<prim>/method/list.json')
def get_primitive_methods_list(prim):
return {
'methods': rr.get_primitive_methods_list(self, prim)
}
@self.app.post('/primitive/<prim>/method/<meth>/args.json')
def call_primitive_method(prim, meth):
res = rr.call_primitive_method(prim, meth,
bottle.request.json)
return {
'{}:{}'.format(prim, meth): res
}
@self.app.get('/motors/register/<register_name>')
def get_motors_register_value(register_name):
motors_list = rr.get_motors_list('motors')
registers_motors = {}
for motor_name in motors_list:
registers_motors[motor_name] = {
register_name: rr.get_motor_register_value(motor_name, register_name)
}
return registers_motors
#
import collections
import functools
import json
import multiprocessing.pool
import uuid
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
import bottle
from kilda.traffexam import exc
from kilda.traffexam import model
app = bottle.Bottle(autojson=False)
app.install(bottle.JSONPlugin(
json_dumps=functools.partial(json.dumps, cls=model.JSONEncoder)))
config_key = 'traffexam.{}'.format
@app.route('/address', methpd='GET')
def address_list():
context = get_context()
return address_response(context.service.address.list())
@app.route('/address', method='POST')
def address_create():
context = get_context()
payload = bottle.request.json
payload.pop('idnr', None)
