def run(self):
try:
wolf.logger.debug('Listening on %s:%s' %
(wolf.config.webaddr, wolf.config.webport))
run(host=wolf.config.webaddr,
port=wolf.config.webport,
quiet=True,
app=AccessLog(app()))
wolf.logger.debug('Proxying /net to %s' % wolf.config.netslave)
mount('/net', HostProxy(wolf.config.netslave))
except OSError as e:
wolf.logger.error('Cannot start %s: %s' % (self.name, str(e)))
def servicio_Rest(): # creamos el servicio servicio = ControladorWS(webpath = WEBPATH) servicio.addprotocol(PROTOCOL) bottle.mount(WEBPATH, servicio.wsgiapp()) logging.basicConfig(level=logging.DEBUG) database2 = SqliteDatabase(DATABASE, threadlocals=True) # Arrancamos el servcio web para la aplicacion bottle.run(host=DIRECCION_WS, port=PUERTO_WS)
resposta['servico'] = provider
resposta['codigo'] = track
resposta['historico'] = result
return format_result(resposta)
except AttributeError:
message = "404 Pacote %s nao encontrado" % track
logger.exception(message)
else:
message = '404 Servico %s nao encontrado' % provider
logger.warning(message)
return make_error(message)
bottle.mount('/v1', app_v1)
@route('/crossdomain.xml')
def crossdomain():
response.content_type = 'application/xml'
return template('crossdomain')
def _standalone(port=9876):
run(host='0.0.0.0', port=port)
if __name__ == "__main__":
_standalone()
from bottle import run
from bottle import mount
from bottle import debug
from controllers import *
from apps.uploader import uploader
mount('/uploader', uploader, name='uploader')
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--host",
default='localhost',
dest='host',
help="Host name to listen to")
parser.add_argument("--port",
default='8000',
type=int,
dest='port',
help='Port to listen to'),
parser.add_argument("--server",
default='wsgiref',
dest='server',
help='Server adapter to use'),
parser.add_argument("--debug",
action='store_true',
help='Enable dubug mode'),
parser.add_argument("--reload",
action="store_true",
help="auto-reload on file changes."),
import metadata_webtool.app
if __name__ == "__main__":
import bottle
@bottle.route("/static/<path:path>")
def static(path):
return bottle.static_file(path, "static")
bottle.mount("/metadata-webtool/", metadata_webtool.app.app)
bottle.run()
p.lastname = u('Green')
r.append(p)
print r
return r
@expose(Person)
@validate(Person)
def setperson(self, person):
return person
@expose([Person])
@validate([Person])
def setpersons(self, persons):
print persons
return persons
root = DemoRoot(webpath='/ws')
root.addprotocol('soap',
tns='http://example.com/demo',
typenamespace='http://example.com/demo/types',
baseURL='http://127.0.0.1:8080/ws/')
root.addprotocol('restjson')
bottle.mount('/ws/', root.wsgiapp())
logging.basicConfig(level=logging.DEBUG)
bottle.run()
from bottle import run
from bottle import mount
from bottle import debug
from controllers import *
from apps.uploader import uploader
mount("/uploader", uploader, name="uploader")
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--host", default="localhost", dest="host", help="Host name to listen to")
parser.add_argument("--port", default="8000", type=int, dest="port", help="Port to listen to"),
parser.add_argument("--server", default="wsgiref", dest="server", help="Server adapter to use"),
parser.add_argument("--debug", action="store_true", help="Enable dubug mode"),
parser.add_argument("--reload", action="store_true", help="auto-reload on file changes."),
args = parser.parse_args()
debug(args.debug)
run(host=args.host, port=args.port, server=args.server, reloader=args.reload)
else:
# Change working directory so relative paths (and template lookup) work again
import os
import os.path
os.chdir(os.path.dirname(__file__))
from bottle import app
def get_sender():
return request.get_header("uniqys-sender")
@app.route('/hello')
def hello():
return 'Hello Uniqys!'
@app.route('/set', method='POST')
def set():
sender = get_sender()
if sender is None:
return ('error', 400)
value = request.json.get('value')
print(value, flush=True)
db.set('value', str(value))
@app.route('/get')
def get():
return db.get('value')
mount('/api', app)
run(host='0.0.0.0',
port=56080,
debug=True,
reloader=True)
@route("/fail/<report>/<graph>")
def show_fragment(report, graph):
abort(404, "This page does not exist")
@route("/static/<filepath:path>")
def static(filepath):
return static_file(filepath, root="./static/")
###############################
#
# Mount API on /api/
#
###############################
from jsonapi import app as api_app
mount("/api/", api_app)
###############################
#
# Handle Errors
#
###############################
@error(404)
def error404(error):
return renderfile("404")
#
# Main. To run in developer mode simply pass --run
#
def main(debug=False, reloader=False, host="0.0.0.0"):
bottle.debug(debug)
bottle.mount(bottle.app(), "/mips")
bottle.run(reloader=reloader, host=host)
from bottle import mount, route, run, static_file, redirect
import sushi
import gari
from util import get_config
config = get_config()
static_dir_path = '/static'
@route('/')
def index():
return static_file('index.html', root=static_dir_path)
@route('/<path:path>')
def file_path(path):
return static_file(path, root=static_dir_path)
mount('/sushi', sushi.app)
mount('/gari', gari.app)
run(server=config['SERVER'],
workers=config['WORKER_NUM'],
host=config['HOST'],
port=config['PORT'],
debug=config['DEBUG'],
reloader=config['AUTO_RELOAD'])
# -*- coding: utf-8 -*-
from prism_controller import FrontController
import bottle
import logging
import prism_config as config
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p',
filename='/tmp/prism.log',
level=logging.DEBUG)
root = FrontController(webpath='/prism')
root.addprotocol(
'soap',
tns='http://example.com/demo',
typenamespace='http://example.com/demo/types',
baseURL='http://' + config.bind_address + ':' + str(config.bind_port) +
'/prism/',
)
root.addprotocol('restjson')
bottle.mount('/prism/', root.wsgiapp())
logging.basicConfig(level=logging.DEBUG)
#bottle.run()
logging.info("PRISM Starting...")
bottle.run(host=config.bind_address, port=config.bind_port)
def _mount(name):
mount(name, import_module('.' + name, __name__).app)
ws_ms_old = ''
while 1:
try:
if ws_ms != ws_ms_old or first_time:
wsock.send(ws_ms)
ws_ms_old = ws_ms
if first_time:
first_time = False
sleep(ws_maker_sleep)
except WebSocketError:
#wsock.close()
break
mount('/seekbar/', app)
# This creates a queue object for every request.
@app.route('/websocket')
def handle_websocket():
worker_success = 0
while worker_success == 0:
try:
body = queue.Queue()
worker = ws_maker()
worker.on_data(body.put)
worker.on_finish(lambda: body.put(StopIteration))
worker.start()
worker_success = 1
return body
def __init__(self, datebase_name, static_file_path=None, data_dir='./data', loggly_token=None):
cork_dir = os.path.join(data_dir, 'cork')
beaker_dir = os.path.join(data_dir, 'beaker')
bottle.TEMPLATE_PATH.insert(0,'webapi/views/')
#vars which must be visible across all webapi modules
shared.static_dir = static_file_path
shared.plug = bottle.ext.mongo.MongoPlugin(uri="localhost", db=datebase_name, json_mongo=True)
#install mongo plugin for root app
install(shared_state.plug)
#check if cork files exists
cork_files = ['users.json', 'roles.json', 'register.json']
if not set(cork_files).issubset(set(os.listdir(cork_dir))):
#if not, create them
logger.info('Cork authentication files not found, creating new files.')
shared.auth = self.populate_conf_directory(cork_dir)
else:
shared.auth = Cork(cork_dir)
#admin depends on shared.auth
import admin
#import and mount api version 1 (stable)
from webapi.api.v1 import app as api_v1
mount('/api/v1/', api_v1.app)
#import and mount development version (unstable)
from webapi.api.d import app as api_d
mount('/api/d/', api_d.app)
#must be imported AFTER mounts.
if shared.static_dir is not None:
import default_routes
#wrap root app in beaker middleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': False,
'session.data_dir': beaker_dir,
'session.auto': True,
#set secure attribute on cookie
'session.secure': True
}
self.app = bottle.app()
if loggly_token:
self.app = Loggly(bottle.app(), loggly_token)
self.app = SessionMiddleware(self.app, session_opts)
root_app = bottle.app()
#setup logging hooks
@root_app.hook('before_request')
@api_d.app.hook('before_request')
@api_v1.app.hook('before_request')
def log_request():
user_agent = ""
if 'HTTP_USER_AGENT' in bottle.request.environ:
user_agent = bottle.request.environ['HTTP_USER_AGENT']
if 'REMOTE_ADDR' in bottle.request.environ:
remote_addr = bottle.request.environ['REMOTE_ADDR']
else:
remote_addr = ""
if 'beaker.session' in bottle.request.environ:
session = bottle.request.environ.get('beaker.session')
username = session.get('username', None)
else:
username = "******"
logger.info("[{0}/{1}] {2} {3} ({4})".format(remote_addr, username, request.method, request.fullpath, user_agent))
def return_text(self, e):
return e.status
#make sure error pages for API are pure text
api_d.app.default_error_handler = types.MethodType(return_text, self)
api_v1.app.default_error_handler = types.MethodType(return_text, self)
resposta = dict()
result = []
for status in encomenda.status:
historico = dict()
historico['data'] = status.data
historico['local'] = status.local
historico['situacao'] = status.situacao
historico['detalhes'] = status.detalhes
result.append(historico)
resposta['servico'] = provider
resposta['codigo'] = track
resposta['historico'] = result
return json.dumps(resposta)
except AttributeError:
response.status = '404 O pacote %s informado nao pode ser localizado' % track
else:
response.status = '404 O Servico %s nao pode ser encontrado' % provider
bottle.mount('/v1', app_v1)
def _standalone(port=9876):
run(host='localhost', port=port)
print r
return r
@expose(Person)
@validate(Person)
def setperson(self, person):
return person
@expose([Person])
@validate([Person])
def setpersons(self, persons):
print persons
return persons
root = DemoRoot(webpath='/ws')
root.addprotocol(
'soap',
tns='http://example.com/demo',
typenamespace='http://example.com/demo/types',
baseURL='http://127.0.0.1:8080/ws/',
)
root.addprotocol('restjson')
bottle.mount('/ws/', root.wsgiapp())
logging.basicConfig(level=logging.DEBUG)
bottle.run()
