def hoitovuorot():
"""Jaa ja näytä hoitovuorot. Jakaa hoitovuorot ainoastaan niiden
lukumäärän perusteella. Voisi tehdä myös keston perusteella mutta
käyntien kestot ovat pääsääntöisesti lyhyitä joten paikasta toiseen
kulkemisen viemä aika on huomattava.
"""
loginVaaditaan()
# jakaa hoitovuoron mahdollisista hoitajista aina sille, jolla on
# vähiten käyntejä. Voisi jakaa ajan perusteella mutta käynnit
# ovat lyhyitä verrattuna liikkumisaikaan
hoitokerrat = {h: 0 for h in map(lambda h: h.nimi, app().hoitajat.kaikki())}
hoitovuorot = {h: [] for h in map(lambda h: h.nimi, app().hoitajat.kaikki())}
vaillaHoitajaa = []
virheviesti = None
for k in app().asiakkaat.kaikkiKaynnit():
sopivat = app().hoitajat.haeSopivatKaynnilla(k.kayntiid)
if not sopivat: #ei löytynyt sopivia hoitajia
vaillaHoitajaa.append(k.asiakasnimi + ": " + str(k))
continue
hoitaja = min(sopivat, key=lambda k: hoitokerrat[k.nimi])
hoitokerrat[hoitaja.nimi] += 1
hoitovuorot[hoitaja.nimi].append(k)
if vaillaHoitajaa:
virheviesti = "Seuraaville käynneille ei lyötynyt hoitajaa: " + "; ".join(vaillaHoitajaa)
return template("hoitovuorot", hoitajat=hoitovuorot, virheviesti=virheviesti)
def hoitajat():
"""Hoitajien hallintasivu"""
loginVaaditaan()
virheviesti = virheViesti()
hoitsut = app().hoitajat.kaikki()
luvat = app().vakiot.luvat()
return template("hoitajat", hoitajat=hoitsut, luvat=luvat, virheviesti=virheviesti)
def get_middleware_app(self):
if not self._auth_method:
return None
if not self._multi_tenancy:
return None
# keystone middleware is needed for fetching objects
# app = bottle.app()
app = AuthPostKeystone(bottle.app(), {'auth_svc': self})
auth_middleware = auth_token.AuthProtocol(app, self._conf_info)
self._auth_middleware = auth_middleware
while True:
try:
self._auth_token = auth_middleware.get_admin_token()
break
except auth_token.ServiceError as e:
self._server_mgr.config_log_error(
"Error in getting admin token: " + str(e))
time.sleep(2)
# open access for troubleshooting
self._open_app = AuthOpen('127.0.0.1', '8095', bottle.app())
gevent.spawn(self._open_app.start_http_server)
app = auth_middleware
# allow multi tenancy to be updated dynamically
app = AuthPreKeystone(auth_middleware,
{'admin_token': self._auth_token},
self._multi_tenancy)
return app
def get_middleware_app(self):
if not self._auth_method:
return None
if not self._multi_tenancy:
return None
# keystone middleware is needed for fetching objects
# app = bottle.app()
app = AuthPostKeystone(bottle.app(), {'auth_svc': self})
auth_middleware = auth_token.AuthProtocol(app, self._conf_info)
self._auth_middleware = auth_middleware
# open access for troubleshooting
admin_port = self._conf_info['admin_port']
self._local_auth_app = LocalAuth(bottle.app(), self._conf_info)
vnc_greenlets.VncGreenlet("VNC Auth Keystone", self._local_auth_app.start_http_server)
app = auth_middleware
# allow multi tenancy to be updated dynamically
app = AuthPreKeystone(
auth_middleware,
None,
self._multi_tenancy)
return app
def testWithBottle(self):
bottle.app.push()
bottle.response.bind(bottle.app())
bottle.response.set_cookie('key', dict(value=5), secret=tob('1234'))
cheader = [v for k, v in bottle.response.wsgiheader() if k == 'Set-Cookie'][0]
bottle.request.bind({'HTTP_COOKIE': cheader.split(';')[0]}, bottle.app())
self.assertEqual(repr(dict(value=5)), repr(bottle.request.get_cookie('key', secret=tob('1234'))))
bottle.app.pop()
def __call__(self, env, start_response):
if (env.get('PATH_INFO') and
env['PATH_INFO'].startswith('/documentation')):
app = bottle.app()
else:
app = self.app if self.mt else bottle.app()
return app(env, start_response)
def poistaKaynti():
kayntiId = request.forms.getunicode("kayntiid")
asiakasId = request.forms.getunicode("asiakasid")
if kayntiId:
app().asiakkaat.poistaKaynti(kayntiId)
if asiakasId:
app().asiakkaat.poistaAsiakas(asiakasId)
redirect("/asiakkaanHallinta")
def login_post():
name = request.forms.getunicode("name")
password = request.forms.getunicode("password")
try:
app().auth.login(name, password)
# Innokas except jottei loginin epäonnistumisviesti anna vihjeitä hyökkääjälle
except Exception:
asetaVirheViesti("Kirjautuminen epäonnistui")
redirect("/login")
redirect("/")
def hoitajat_post():
loginVaaditaan()
nimi = request.forms.getunicode("nimi")
luvat = request.forms.getall("lupa")
# ei ole getallunicode()-metodia, muuta kaikki unicodeksi
luvat = [l.encode("latin-1").decode("utf8") for l in luvat]
try:
app().hoitajat.uusi(nimi, luvat)
except Exception:
asetaVirheViesti("Hoitajan lisäys epäonnistui")
redirect("/hoitajat")
redirect("/hoitajat")
def asiakkaat_post():
"""Luo uusi asiakas"""
loginVaaditaan()
nimi = request.forms.getunicode("nimi")
if not nimi:
asetaVirheViesti("Asiakkaalla tulee olla nimi")
redirect("asiakkaanHallinta")
try:
app().asiakkaat.uusi(nimi)
except Exception:
asetaVirheViesti("Asiakkaan lisäys epäonnistui")
redirect("/asiakkaanHallinta")
def asiakkaanHallinta():
"""Asiakkaiden hallintasivu"""
virheviesti = virheViesti()
loginVaaditaan()
asiakkaat = app().asiakkaat.kaikki()
luvat = app().vakiot.luvat()
paivat = app().vakiot.paivat()
ajat = app().vakiot.ajat()
kestot = app().vakiot.kestot()
return template("asiakkaanHallinta", asiakkaat=asiakkaat, luvat=luvat, ajat=ajat,
kestot=kestot, paivat=paivat, virheviesti=virheviesti)
def foris_403_handler(error):
if isinstance(error, CSRFValidationError):
try:
# maybe the session expired, if so, just redirect the user
redirect_unauthenticated()
except bottle.HTTPResponse as e:
# error handler must return the exception, otherwise it would
# be raised and not handled by Bottle
return e
# otherwise display the standard error page
bottle.app().default_error_handler(error)
def register_post():
name = request.forms.getunicode("name")
password1 = request.forms.getunicode("password1")
password2 = request.forms.getunicode("password2")
if password1 != password2:
asetaVirheViesti("Salasanat eivät täsmää")
redirect("/register")
try:
app().auth.register(name, password1)
except IntegrityError:
asetaVirheViesti("Valitsemasi käyttäjätunnus on jo käytössä")
redirect("/register")
return template("rekOK")
def test_1_2_plugins(self):
print ''
print 'test plugins'
print 'plugins count:', self.alignak_webui.plugins_count
for plugin in self.alignak_webui.plugins:
print "Plugin:", plugin
print 'get plugins routes - route name is present'
for s_route in [r for r in bottle.app().routes if r.name]:
print "Plugin route:", s_route.name, s_route.rule, s_route.callback
print 'get plugins static files routes - rule starts with /plugins'
for s_route in [r for r in bottle.app().routes if r.rule.startswith('/plugins')]:
print "Plugin static files route:", s_route.rule
def test_503(self):
""" WSGI: Server stopped (HTTP 503) """
@bottle.route('/')
def test(): return 'bla'
self.assertStatus(200, '/')
bottle.app().serve = False
self.assertStatus(503, '/')
def static(filename):
""" return static file
:param filename: url path
:type filename: str
:return: http response
"""
def prepare_response(filename, fs_root):
response = bottle.static_file(filename, root=fs_root)
response.add_header("Cache-Control", "public, max-age=31536000")
return response
if not bottle.DEBUG:
logger.warning("Static files should be handled externally in production mode.")
match = re.match(r"/*plugins/+(\w+)/+(.+)", filename)
if match:
plugin_name, plugin_file = match.groups()
# find correspoding plugin
for plugin in bottle.app().foris_plugin_loader.plugins:
if plugin.PLUGIN_NAME == plugin_name:
return prepare_response(plugin_file, os.path.join(plugin.DIRNAME, "static"))
return bottle.HTTPError(404, "File does not exist.")
match = re.match(r"/*generated/+([a-z]{2})/+(.+)", filename)
if match:
filename = "/".join(match.groups())
return prepare_response(
filename, os.path.join(current_state.assets_path, current_state.app)
)
return prepare_response(filename, os.path.join(BASE_DIR, "static"))
def startServer():
import bottle
app = bottle.default_app() # create bottle app
loadErrors(app)
loadWebUI(app)
app = bottle.app()
session_opts = {
'session.type': 'file',
'session.cookie_expires': 9000,
'session.data_dir': 'data',
'session.auto': True
}
app = SessionMiddleware(app, session_opts)
bottle.run(app=app,
server='paste',
host="0.0.0.0",
port=8030,
debug=True,
interval=1,
quiet=False)
def start_web_service():
change_to_web_mapset()
rt.start()
mdig_worker_process.start()
# setup and run webapp
global app
app = bottle.app()
app.catchall = False
try:
import paste.evalexception
myapp = paste.evalexception.middleware.EvalException(app)
except ImportError:
myapp = app
myapp = RestoreMapset(myapp)
c = config.get_config()
# Don't check replicates are complete, since this will make the web service
# too slow if there are lots of replicates
if "replicate" not in c:
c["replicate"] = {}
c["replicate"]["check_complete"] = "false"
# for testing ports available in windows
# c["WEB"]["port"] = 8080
bottle.run(app=myapp, host=c["WEB"]["host"], port=int(
c["WEB"]["port"]), reloader=reloader)
def application(environ, start_response):
try:
application = bottle.app()
application.catchall = False
application = JsonApiMiddleware(application)
return application(environ, start_response)
except:
rollbar.report_exc_info(sys.exc_info(), webob.Request(environ))
# Bare bones 500 handler
content = b""
if environ.get("JSON"):
content = '{"__status_code__": 500}'
content_type = "application/json; charset=UTF-8"
else:
dirname = os.path.dirname(__file__)
five_hundred_path = os.path.join(dirname, "app/html/five_hundred.html")
with open(five_hundred_path, "r", encoding="utf-8") as f:
content = f.read()
content_type = "text/html; charset=UTF-8"
content = content.encode("utf-8")
start_response(
"500 Internal Server Error",
[("Content-Type", content_type), ("Content-Length", str(len(content)))],
sys.exc_info(),
)
environ["wsgi.errors"] = content
return [content]
def setUp(self):
super(TestCase, self).setUp()
global cov_handle
if not cov_handle:
cov_handle = coverage.coverage(source=['./'], omit=['.venv/*'])
#cov_handle.start()
cfgm_common.zkclient.LOG_DIR = './'
gevent.wsgi.WSGIServer.handler_class = FakeWSGIHandler
setup_common_flexmock()
self._api_server_ip = socket.gethostbyname(socket.gethostname())
self._api_server_port = get_free_port()
http_server_port = get_free_port()
self._api_admin_port = get_free_port()
self._api_svr_greenlet = gevent.spawn(launch_api_server,
self.id(),
self._api_server_ip, self._api_server_port,
http_server_port, self._api_admin_port,
self._config_knobs)
block_till_port_listened(self._api_server_ip, self._api_server_port)
extra_env = {'HTTP_HOST':'%s%s' %(self._api_server_ip,
self._api_server_port)}
self._api_svr_app = TestApp(bottle.app(), extra_environ=extra_env)
self._vnc_lib = VncApi('u', 'p', api_server_host=self._api_server_ip,
api_server_port=self._api_server_port)
FakeNovaClient.vnc_lib = self._vnc_lib
self._api_server_session = requests.Session()
adapter = requests.adapters.HTTPAdapter()
self._api_server_session.mount("http://", adapter)
self._api_server_session.mount("https://", adapter)
self._api_server = vnc_cfg_api_server.server
self._api_server._sandesh.set_logging_level(level="SYS_DEBUG")
self.addCleanup(self.cleanUp)
def setUp(self):
super(TestCase, self).setUp()
global cov_handle
if not cov_handle:
cov_handle = coverage.coverage(source=['./'], omit=['.venv/*'])
cov_handle.start()
setup_flexmock()
api_server_ip = socket.gethostbyname(socket.gethostname())
api_server_port = get_free_port()
http_server_port = get_free_port()
self._web_host = api_server_ip
self._web_port = api_server_port
self._api_svr_greenlet = gevent.spawn(launch_api_server,
api_server_ip, api_server_port,
http_server_port)
block_till_port_listened(api_server_ip, api_server_port)
extra_env = {'HTTP_HOST':'%s%s' %(api_server_ip,
api_server_port)}
self._api_svr_app = TestApp(bottle.app(), extra_environ=extra_env)
#FakeRequestsSession._api_svr_app = self._api_svr_app
self._vnc_lib = VncApi('u', 'p', api_server_host=api_server_ip,
api_server_port=api_server_port)
self._api_server_session = requests.Session()
adapter = requests.adapters.HTTPAdapter()
self._api_server_session.mount("http://", adapter)
self._api_server_session.mount("https://", adapter)
self._api_server = vnc_cfg_api_server.server
self._api_server._sandesh.set_logging_params(level="SYS_WARN")
def start():
""" Start the decider
"""
host = cc.conf['decider']['host']
managers = cc.conf['compute']['managers']
whoami = cc.conf['whoami']
port = None
for m in managers:
if m['realhost'] == whoami:
port = m['decider_port']
ipc.set('self_port', port)
hostlist = []
for m in managers:
if m['realhost'] != whoami:
hostlist.append(m)
ipc.set('hostlist', json.dumps(hostlist))
bottle.debug(True)
app = bottle.app()
app.state = {
'machine': state_machine.get_machine()
}
app.error_handler = aux.bottle_errors.ERRORS_HANDLERS
log_api.info('Starting the decider, listening to %s:%s, pid:%s',
host, port, str(os.getpid()))
quiet = cc.conf['decider']['log']['level'] != "DEBUG"
bottle.run(host=host, port=port,
quiet=quiet, reloader=cc.conf['development'])
def bottle_underload():
machine = bottle.app().state['machine']
log_api.info('RECV: Underload')
return 'Notification received'
# retrieve body
try:
data = json.load(bottle.request.body)
except ValueError:
log_api.error('Retrieving: ValueError')
raise HTTPError(400)
# validate the data
try:
parser.validate(machine.whoami_host, data)
except KeyError:
log_api.error('Validating: KeyError')
raise HTTPError(400)
except exc.NotMyAlarm:
log_api.error('Validating: NotMyAlarm')
raise HTTPError(400)
# execute data
try:
machine.underload()
except transitions.MachineError:
log.error('Machine: MachineError, state=%s' % machine.state)
raise HTTPError(409)
return 'Notification received'
def loadRoutes():
routesPath = os.path.join( DIRAC.rootPath, "WebAPIDIRAC", "WebAPISystem", "private", "routes" )
lastRoutesLoaded = 0
for fileName in os.listdir( routesPath ):
match = gRoutesRE.match( fileName )
if match:
pythonClass = match.groups()[0]
objPythonPath = "WebAPIDIRAC.WebAPISystem.private.routes.%s" % pythonClass
try:
objModule = __import__( objPythonPath,
globals(),
locals(), pythonClass )
except:
DIRAC.gLogger.exception( "Could not load %s" % fileName )
routesLoaded = 0
rules = bottle.app().router.rules
for rule in rules:
for method in rules[ rule ]:
routesLoaded += 1
routesLoaded -= lastRoutesLoaded
DIRAC.gLogger.info( "Loaded %s routes for %s" % ( routesLoaded, pythonClass ) )
lastRoutesLoaded += routesLoaded
if 'initialize' in dir( objModule ):
DIRAC.gLogger.notice( "Initializing %s" % pythonClass )
getattr( objModule, 'initialize' )()
def service():
params = get_params(bottle.request)
state = bottle.app().state
validate_params(state['state']['hashed_username'],
state['state']['hashed_password'],
params)
log.info('Received a request from %s: %s',
get_remote_addr(bottle.request),
str(params))
try:
if params['reason'] == 0:
log.info('Processing an underload of a host %s', params['host'])
execute_underload(
state['config'],
state['state'],
params['host'])
else:
log.info('Processing an overload, VMs: %s', str(params['vm_uuids']))
execute_overload(
state['config'],
state['state'],
params['host'],
params['vm_uuids'])
except:
log.exception('Exception during request processing:')
raise
def test_basicmounting(self):
bottle.app().mount(self.subapp, '/test')
self.assertStatus(404, '/')
self.assertStatus(404, '/test')
self.assertStatus(404, '/test/')
self.assertStatus(404, '/test/test/bar')
@self.subapp.route('/')
@self.subapp.route('/test/:test')
def test(test='foo'):
return test
self.assertStatus(404, '/')
self.assertStatus(404, '/test')
self.assertStatus(200, '/test/')
self.assertBody('foo', '/test/')
self.assertStatus(200, '/test/test/bar')
self.assertBody('bar', '/test/test/bar')
def start():
""" Start the global manager web service.
"""
config = read_and_validate_config([DEFAILT_CONFIG_PATH, CONFIG_PATH],
REQUIRED_FIELDS)
common.init_logging(
config['log_directory'],
'global-manager.log',
int(config['log_level']))
state = init_state(config)
switch_hosts_on(state['db'],
config['ether_wake_interface'],
state['host_macs'],
state['compute_hosts'])
bottle.debug(True)
bottle.app().state = {
'config': config,
'state': state}
host = config['global_manager_host']
port = config['global_manager_port']
log.info('Starting the global manager listening to %s:%s', host, port)
bottle.run(host=host, port=port)
def main(argv=None):
"""Main Block - Configure and run the Bottle Web Server."""
cmd_opts = parse_cmdline(argv)[0]
if cmd_opts.confpath is not None:
if os.path.exists(cmd_opts.confpath):
conf_paths = [cmd_opts.confpath,]
else:
return "Configuration file not found: %s" % cmd_opts.confpath
else:
conf_paths = [os.path.join(path, defaultConfFilename)
for path in ('/etc', '.',)]
try:
conf.update(parse_conf_files(conf_paths))
except ConfigurationError:
return(sys.exc_info()[1])
if cmd_opts.bindport is not None:
conf['bindport'] = cmd_opts.bindport
if cmd_opts.bindaddr is not None:
conf['bindaddr'] = cmd_opts.bindaddr
if cmd_opts.baseurl is not None:
conf['baseurl'] = cmd_opts.baseurl
if cmd_opts.devel:
from bottle import debug
debug(True)
app = SessionMiddleware(bottle.app(), sessionOpts)
bottle.run(app=app, host=conf['bindaddr'], port=conf['bindport'],
reloader=cmd_opts.devel)
def create_api_server_instance(test_id, config_knobs):
ret_server_info = {}
allocated_sockets = []
ret_server_info['ip'] = socket.gethostbyname(socket.gethostname())
ret_server_info['service_port'] = get_free_port(allocated_sockets)
ret_server_info['introspect_port'] = get_free_port(allocated_sockets)
ret_server_info['admin_port'] = get_free_port(allocated_sockets)
ret_server_info['allocated_sockets'] = allocated_sockets
ret_server_info['greenlet'] = gevent.spawn(launch_api_server,
test_id, ret_server_info['ip'], ret_server_info['service_port'],
ret_server_info['introspect_port'], ret_server_info['admin_port'],
config_knobs)
block_till_port_listened(ret_server_info['ip'],
ret_server_info['service_port'])
extra_env = {'HTTP_HOST': ret_server_info['ip'],
'SERVER_PORT': str(ret_server_info['service_port'])}
ret_server_info['app'] = TestApp(bottle.app(), extra_environ=extra_env)
ret_server_info['api_conn'] = VncApi('u', 'p',
api_server_host=ret_server_info['ip'],
api_server_port=ret_server_info['service_port'])
FakeNovaClient.vnc_lib = ret_server_info['api_conn']
ret_server_info['api_session'] = requests.Session()
adapter = requests.adapters.HTTPAdapter()
ret_server_info['api_session'].mount("http://", adapter)
ret_server_info['api_session'].mount("https://", adapter)
ret_server_info['api_server'] = vnc_cfg_api_server.server
ret_server_info['api_server']._sandesh.set_logging_level(level="SYS_DEBUG")
return ret_server_info
def setUp(self):
super(TestCase, self).setUp()
global cov_handle
if not cov_handle:
cov_handle = coverage.coverage(source=["./"], omit=[".venv/*"])
cov_handle.start()
cfgm_common.zkclient.LOG_DIR = "./"
gevent.wsgi.WSGIServer.handler_class = FakeWSGIHandler
setup_common_flexmock()
self._api_server_ip = socket.gethostbyname(socket.gethostname())
self._api_server_port = get_free_port()
http_server_port = get_free_port()
self._api_admin_port = get_free_port()
self._api_svr_greenlet = gevent.spawn(
launch_api_server,
self._api_server_ip,
self._api_server_port,
http_server_port,
self._api_admin_port,
self._config_knobs,
)
block_till_port_listened(self._api_server_ip, self._api_server_port)
extra_env = {"HTTP_HOST": "%s%s" % (self._api_server_ip, self._api_server_port)}
self._api_svr_app = TestApp(bottle.app(), extra_environ=extra_env)
self._vnc_lib = VncApi("u", "p", api_server_host=self._api_server_ip, api_server_port=self._api_server_port)
FakeNovaClient.vnc_lib = self._vnc_lib
self._api_server_session = requests.Session()
adapter = requests.adapters.HTTPAdapter()
self._api_server_session.mount("http://", adapter)
self._api_server_session.mount("https://", adapter)
self._api_server = vnc_cfg_api_server.server
self._api_server._sandesh.set_logging_params(level="SYS_WARN")
response.status = HttpStatus.Ok
return result
return endpoint
def hello_world():
return "OUT!"
def t():
return {"a": "b"}
api = app()
# api.install(CORSPlugin())
api.add_hook("after_request", cors)
api.route("/", "GET", hello_world)
api.route("/p", "POST", build_prediction_endpoint(resnet50))
api.route("/r50/p", "POST", build_prediction_endpoint(resnet50))
api.route("/r34/p", "POST", build_prediction_endpoint(resnet34))
api.route("/r34/vocab", "GET",
lambda: {"vocab": [l for l in resnet34.vocab()]})
api.route("/r50/vocab", "GET",
lambda: {"vocab": [l for l in resnet50.vocab()]})
api.run(port=5000)
def test_http_get_routes(self):
"""Test that session ids are not authenticated with non-post routes."""
self.mock_database.sessions.find_one.return_value = None
route = bottle.Route(bottle.app(), "/", "GET", self.route)
self.assertEqual(self.success, route.call())
CLIENT_ID = client_secrets["web"]["client_id"]
CLIENT_SECRET = client_secrets["web"]["client_secret"]
SCOPE = client_secrets["web"][
"auth_uri"] #"https://accounts.google.com/o/oauth2/auth"
REDIRECT_URI = client_secrets["web"]["redirect_uris"][0]
GOOGLE_SCOPE = 'https://www.googleapis.com/auth/plus.me https://www.googleapis.com/auth/userinfo.email'
# Configure the SessionMiddleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': 300,
'session.data_dir': './data',
'session.auto': True
}
app = SessionMiddleware(
bottle.app(), session_opts
) # app is now a replacement of original bottle.app(); if not specified in run() at bottom, default app
scope = 'https://www.googleapis.com/auth/plus.me https://www.googleapis.com/auth/userinfo.email'
"""@route('/home')
def login_page():
flow = flow_from_clientsecrets("client_secret.json", scope, redirect_uri=redirect_uri_)
uri = flow.step1_get_authorize_url()
print "@login:redirecting to google"
redirect(uri)
return
@route('/redirect')
def login_done_redirect():
global redirect_search_uri
global user_email
def test_module_shortcuts_with_different_name(self):
self.assertWraps(bottle.url, bottle.app().get_url)
def __init__(self, args):
self._homepage_links = []
self._args = args
self.service_config = args.service_config
self.cassandra_config = args.cassandra_config
self._debug = {
'hb_stray': 0,
'msg_pubs': 0,
'msg_subs': 0,
'msg_query': 0,
'msg_hbt': 0,
'ttl_short': 0,
'policy_rr': 0,
'policy_lb': 0,
'policy_fi': 0,
'db_upd_hb': 0,
'throttle_subs': 0,
'503': 0,
'count_lb': 0,
}
self._ts_use = 1
self.short_ttl_map = {}
self._sem = BoundedSemaphore(1)
self._base_url = "http://%s:%s" % (self._args.listen_ip_addr,
self._args.listen_port)
self._pipe_start_app = None
bottle.route('/', 'GET', self.homepage_http_get)
# heartbeat
bottle.route('/heartbeat', 'POST', self.api_heartbeat)
# publish service
bottle.route('/publish', 'POST', self.api_publish)
self._homepage_links.append(
LinkObject('action', self._base_url, '/publish',
'publish service'))
bottle.route('/publish/<end_point>', 'POST', self.api_publish)
# subscribe service
bottle.route('/subscribe', 'POST', self.api_subscribe)
self._homepage_links.append(
LinkObject('action', self._base_url, '/subscribe',
'subscribe service'))
# query service
bottle.route('/query', 'POST', self.api_query)
self._homepage_links.append(
LinkObject('action', self._base_url, '/query', 'query service'))
# collection - services
bottle.route('/services', 'GET', self.show_all_services)
self._homepage_links.append(
LinkObject('action', self._base_url, '/services',
'show published services'))
bottle.route('/services.json', 'GET', self.services_json)
self._homepage_links.append(
LinkObject('action', self._base_url, '/services.json',
'List published services in JSON format'))
# show a specific service type
bottle.route('/services/<service_type>', 'GET', self.show_all_services)
# api to perform on-demand load-balance across available publishers
bottle.route('/load-balance/<service_type>', 'POST',
self.api_lb_service)
# update service
bottle.route('/service/<id>', 'PUT', self.service_http_put)
# get service info
bottle.route('/service/<id>', 'GET', self.service_http_get)
bottle.route('/service/<id>/brief', 'GET', self.service_brief_http_get)
# delete (un-publish) service
bottle.route('/service/<id>', 'DELETE', self.service_http_delete)
# collection - clients
bottle.route('/clients', 'GET', self.show_all_clients)
bottle.route('/clients/<service_type>/<service_id>', 'GET',
self.show_all_clients)
self._homepage_links.append(
LinkObject('action', self._base_url, '/clients',
'list all subscribers'))
bottle.route('/clients.json', 'GET', self.clients_json)
self._homepage_links.append(
LinkObject('action', self._base_url, '/clients.json',
'list all subscribers in JSON format'))
# show config
bottle.route('/config', 'GET', self.show_config)
self._homepage_links.append(
LinkObject('action', self._base_url, '/config',
'show discovery service config'))
# show debug
bottle.route('/stats', 'GET', self.show_stats)
self._homepage_links.append(
LinkObject('action', self._base_url, '/stats',
'show discovery service stats'))
# cleanup
bottle.route('/cleanup', 'GET', self.cleanup_http_get)
self._homepage_links.append(
LinkObject('action', self._base_url, '/cleanup',
'Purge inactive publishers'))
if not self._pipe_start_app:
self._pipe_start_app = bottle.app()
# sandesh init
self._sandesh = Sandesh()
module = Module.DISCOVERY_SERVICE
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = self._args.worker_id
disc_client = discovery_client.DiscoveryClient(
'127.0.0.1', self._args.listen_port,
ModuleNames[Module.DISCOVERY_SERVICE])
self._sandesh.init_generator(
module_name,
socket.gethostname(),
node_type_name,
instance_id,
self._args.collectors,
'discovery_context',
int(self._args.http_server_port), ['sandesh'],
disc_client,
logger_class=self._args.logger_class,
logger_config_file=self._args.logging_conf)
self._sandesh.set_logging_params(enable_local_log=self._args.log_local,
category=self._args.log_category,
level=self._args.log_level,
file=self._args.log_file)
self._sandesh.trace_buffer_create(name="dsHeartBeatTraceBuf",
size=1000)
# DB interface initialization
self._db_connect(self._args.reset_config)
# build in-memory subscriber data
self._sub_data = {}
for (client_id, service_type) in self._db_conn.subscriber_entries():
self.create_sub_data(client_id, service_type)
def log(ip, msg):
print("[%s] (%s) %s" % (get_time_now(), ip, msg))
return msg
def get_client_ip():
x_forwarded_for = request.environ.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ip = x_forwarded_for.split(',')[0]
else:
ip = request.environ.get('REMOTE_ADDR')
return ip
app = app()
@app.get('/confirm/<uuid>')
def get_confirm(uuid):
return """<html><body><p>If you're here, you were meant to click this link
many months ago, and the page no longer exists.</p>
<p>Please email [email protected] for further
assistance.</p></body></html>"""
@app.get('/admin/update/<uuid>')
@app.get('/update/<uuid>')
@app.get('/update')
@app.get('/new')
@app.get('/')
def get_main(uuid=None):
import bottle
from bottle import get, static_file
import requests
import json
@get("/css/<filepath:re:.*\.css>")
def css(filepath):
return static_file(filepath, root="css/")
@get("/js/<filepath:re:.*\.js>")
def css(filepath):
return static_file(filepath, root="js/")
@bottle.route("/")
@bottle.view("ipinfo.tpl")
def index():
info = requests.get('http://ipinfo.io/')
j = json.loads(info.text)
return {"title": "IP informations", "ip": j['ip'], "country": j['country']}
bottle.run(bottle.app(), host='0.0.0.0', port=80, debug=True, reloader=True)
join(PYLOAD_DIR, "locale"),
languages=[config.get("general", "language"), "en"],
fallback=True)
translation.install(True)
env.install_gettext_translations(translation)
from beaker.middleware import SessionMiddleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': False,
'session.data_dir': './tmp',
'session.auto': False
}
web = StripPathMiddleware(SessionMiddleware(app(), session_opts))
web = GZipMiddleWare(web)
if PREFIX:
web = PrefixMiddleware(web, prefix=PREFIX)
import pyload.webui.app
def run_simple(host="0.0.0.0", port="8000"):
run(app=web, host=host, port=port, quiet=True)
def run_lightweight(host="0.0.0.0", port="8000"):
run(app=web, host=host, port=port, server="bjoern", quiet=True)
# App
from ClinicalTrials.mngobject import MNGObject
from ClinicalTrials.trial import Trial
from ClinicalTrials.runner import Runner
from ClinicalTrials.umls import SNOMEDLookup
# bottle, beaker and Jinja setup
session_opts = {
'session.type': 'file',
'session.timeout': 3600,
'session.cookie_expires': 3600,
'session.data_dir': './session_data',
'session.auto': True
}
app = application = SessionMiddleware(
bottle.app(),
session_opts) # "application" is needed for some services like AppFog
_jinja_templates = Environment(loader=PackageLoader('wsgi', 'templates'),
trim_blocks=True)
# ------------------------------------------------------------------------------ Utilities
def _get_session():
return bottle.request.environ.get('beaker.session')
# only used for SMART v0.6+
def _get_smart():
if not USE_SMART:
return None
def bottle_patch(path=None, **options):
"""Convenience decorator of the same form as @get and @post in the
Bottle module.
"""
return app().route(path, 'PATCH', **options)
def initRest(self):
self.addRoutes(self.baseUrl)
self.app = bottle.app()
import tempfile
import json
import html
import yaml
import bcrypt
import requests
import shutil
from bottle import app, route, template, static_file, redirect, abort, request, response
from beaker.middleware import SessionMiddleware
from steam_buddy.config import PLATFORMS, SSH_KEY_HANDLER, AUTHENTICATOR, SETTINGS_HANDLER, STEAMGRID_HANDLER, FTP_SERVER, RESOURCE_DIR, BANNER_DIR, CONTENT_DIR, SHORTCUT_DIR, SESSION_OPTIONS
from steam_buddy.functions import load_shortcuts, sanitize, upsert_file, delete_file
from steam_buddy.auth_decorator import authenticate
from steam_buddy.platforms.epic_store import EpicStore
from steam_buddy.platforms.flathub import Flathub
server = SessionMiddleware(app(), SESSION_OPTIONS)
tmpfiles = {}
PLATFORM_HANDLERS = {
"epic-store": EpicStore(),
"flathub": Flathub(),
}
def authenticate_platform(platform):
if platform in PLATFORM_HANDLERS:
if not PLATFORM_HANDLERS[platform].is_authenticated():
redirect('/platforms/{platform}'.format(platform=platform))
return False
return True
def __call__(self, env, start_response):
app = self.app if self.mt else bottle.app()
return app(env, start_response)
import bottle
import random
import string
import time
from bottle import request, response, HTTPResponse, template
from peewee_session import PeeweeSessionPlugin
from util import authenticator, generate_token
from peewee import SqliteDatabase
db = SqliteDatabase('test.db')
CONFIG = {'db': db}
app = bottle.app()
app.config.update(CONFIG)
session_plugin = PeeweeSessionPlugin(cookie_lifetime='10 seconds',
db_conn=db,
cookie_secret='very-s3kr3t-s4lt')
app.install(session_plugin)
csrf_token = generate_token(20)
username = "******"
PASSWORD = "******"
class User:
def test_module_shortcuts(self):
for name in '''route get post put delete error mount
hook install uninstall'''.split():
short = getattr(bottle, name)
original = getattr(bottle.app(), name)
self.assertWraps(short, original)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
import bottle
import os
from bottle import get, run, route, template, static_file, request, response
from os import environ
application = bottle.app()
@route('/assets/<filepath:path>')
def server_static(filepath):
return static_file(filepath, root='./public')
@application.route('/', method=['GET'])
def home():
return template('./public/ThanhDuyen.html')
if __name__ == "__main__":
application.run(host='0.0.0.0', port=int(environ.get('PORT', 8000)))
return "Restricted area <br> <a href='/logout'>Log out</a>"
else:
return "Aðgangur bannaður"
@route('/logout')
def logout():
response.set_cookie('user', "", expires=0)
return "Þú hefur verið skráður út. <br> <a href='/login'>Login</a>"
#Session lausn
session_options = {'session.type': 'file', 'session.data_dir': './data/'}
my_session = SessionMiddleware(app(), session_options)
products = [{
'pid': 1,
'name': 'Vara 1',
'price': 100
}, {
'pid': 2,
'name': 'Vara 2',
'price': 400
}, {
'pid': 3,
'name': 'Vara 3',
'price': 200
}, {
'pid': 4,
def tearDown(self):
"""Override to remove the plugins and reset the logging."""
bottle.app().uninstall(True)
logging.disable(logging.NOTSET)
from bottle import run,route,redirect,request,post,template,app,response,static_file
from sys import argv
import pymysql
from beaker.middleware import SessionMiddleware
session_opts = {
'session.type': 'file',
'session.data_dir': './data',
'session.auto': True
}
app = SessionMiddleware(app(), session_opts)
products = [{"pid": 1, "name": "Billy", "price": 100.000},
{"pid": 2, "name": "Stefán Kristinn", "price": 150.250},
{"pid": 3, "name": "Gamli Nói", "price": 24.999},
{"pid": 4, "name": "Jackie Chan", "price": 750.001},
{"pid": 5, "name": "Markús Sápa", "price": 59.999},
{"pid": 6, "name": "Marthin Luther King", "price": 749.999},
{"pid": 7, "name": "Terry Crews", "price": 999.999},
{"pid": 8, "name": "Siggi Sæti", "price": 20},
]
@route("/")
def homepage():
return template("home.tpl")
@route('/nyskra')
def nyr():
return template('newlogin.tpl')
@route('/donyskra', method='POST')
def nyr():
user = request.forms.get('user')
password = request.forms.get('pass')
from collections import defaultdict
import webbrowser
import argparse
import logging
import bottle
from bottle import get, post, request, hook, response
from doorstop import common, build, publisher
from doorstop.common import HelpFormatter
from doorstop.server import utilities
from doorstop import settings
log = common.logger(__name__)
app = utilities.StripPathMiddleware(bottle.app())
tree = None # set in `run`, read in the route functions
numbers = defaultdict(int) # cache of next document numbers
def main(args=None):
"""Process command-line arguments and run the program."""
from doorstop import SERVER, VERSION
# Shared options
debug = argparse.ArgumentParser(add_help=False)
debug.add_argument('-V', '--version', action='version', version=VERSION)
debug.add_argument('--debug', action='store_true', help=argparse.SUPPRESS)
debug.add_argument('--launch', action='store_true', help=argparse.SUPPRESS)
shared = {'formatter_class': HelpFormatter, 'parents': [debug]}
from mybot import config
# Add view paths to the Bottle template path
TEMPLATE_SUB_PATHS = next(os.walk(config.BASE_TEMPLATE_PATH))[1]
TEMPLATE_PATH.append(config.BASE_TEMPLATE_PATH)
for templatePath in TEMPLATE_SUB_PATHS:
TEMPLATE_PATH.append(os.path.join(config.BASE_TEMPLATE_PATH, templatePath))
session_opts = {
'session.type': 'file',
'session.cookie_expires': 30, # Время в сек через которое закончится текущая сессия
'session.data_dir': './data', # Директория для хранения сесии
'session.auto': True
}
# app = Bottle()
app = SessionMiddleware(bottle.app(), session_opts)
from .controllers import *
# if config.DEBUG:
# print("ROOT_PATH: %s" % config.ROOT_PATH)
# print("Template Paths:")
#
# for it in bottle.TEMPLATE_PATH:
# print(" %s" % it)
def homepage():
"""Render the home page."""
return {'sample': 'graphrest'}
@bottle.route('/login')
def login():
"""Prompt user to authenticate."""
MSGRAPH.login('/graphcall')
@bottle.route('/login/authorized')
def authorized():
"""Handler for the application's Redirect Uri."""
MSGRAPH.redirect_uri_handler()
@bottle.route('/graphcall')
@bottle.view('graphcall.html')
def graphcall():
"""Confirm user authentication by calling Graph and displaying some data."""
endpoint = MSGRAPH.api_endpoint('me')
graphdata = MSGRAPH.get(endpoint).json()
return {'graphdata': graphdata, 'endpoint': endpoint, 'sample': 'graphrest'}
@bottle.route('/static/<filepath:path>')
def server_static(filepath):
"""Handler for static files, used with the development server."""
root_folder = os.path.abspath(os.path.dirname(__file__))
return bottle.static_file(filepath, root=os.path.join(root_folder, 'static'))
if __name__ == '__main__':
bottle.run(app=bottle.app(), server='wsgiref', host='localhost', port=5000)
from bottle import route, run, template, request, response, redirect, \
static_file
from bottle.ext import beaker
from Activity import ActivityList, AggregationPeriod
from Chart import Chart
from Strava import Strava, Authentication, AuthenticationException, \
CookieTokenStorage
session_opts = {
'session.type': 'memory',
'session.cookie_expires': 300,
'session.auto': True
}
application = beaker.middleware.SessionMiddleware(bottle.app(), session_opts)
@route('/favico/<file:re:.*\\.(ico|png|webmanifest)$>')
@route('/<file:re:favicon.ico$>')
def favico(file):
return static_file(file, root="favico/")
@route('/ping')
def ping():
return 'pong'
@route('/dump')
def main():
from gevent import monkey
monkey.patch_all()
import bottle
# def do_compute():
# i = 0
# for _ in range(90000):
# i += 1
@bottle.get('/')
def home_page():
# do_compute()
return 'Hello World'
if '__main__' == __name__:
ws_port = 8082
debug = False
host = '0.0.0.0'
bottle.run(app=bottle.app(),
host=host,
port=ws_port,
debug=debug,
server="gevent")
#! /usr/bin/env python2
from bottle import route, run, template, request, app, redirect, static_file
from beaker.middleware import SessionMiddleware
import sys
session_opts = {
'session.type': 'file',
'session.cookie_expires': 300000,
'session.data_dir': '/tmp/session',
'session.auto': True,
'session.key': "sessionid"
}
app = application = myapp = SessionMiddleware(app(), session_opts)
@route('/')
def root_page():
session = request.environ.get('beaker.session')
if ('log_in' in session and session['log_in'] == True):
return template("welcome.html", name=session['login'])
else:
session['log_in'] = False
redirect("/login")
@route('/login')
def authentication():
username = request.params.get('username')
password = request.params.get('password')
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
application = app()
except Exception as e:
return bottle.redirect('/routes?{0}'.format(urlencode({'msg': str(e)})))
return {"title": "DockerAnon | Routes",
"proxy": list(Data.get('proxies').keys()),
"msg": bottle.request.query.msg}
@bottle.route("/dns/add", method=('POST', 'GET'))
@bottle.view('views/dns_add.html')
def routes_add():
if bottle.request.forms.get('name') is not None:
dns_entry = {}
dns_entry['name'] = bottle.request.forms.get('name')
dns_entry['type'] = bottle.request.forms.get('dtype')
dns_entry['value'] = bottle.request.forms.get('value')
if dns_entry['value'] is None or dns_entry['value'] == '':
return bottle.redirect('/dns/add?{0}'.format(urlencode({'msg': 'Value field is mandatory'})))
new_dns = Data.get('dns')[:]
new_dns.append(dns_entry)
Data.set('dns', new_dns)
Data.save()
DNS.ask_for_reload()
return bottle.redirect('/dns')
return {"title": "DockerAnon | DNS",
"msg": bottle.request.query.msg}
bottle.run(bottle.app(), host='0.0.0.0', port=80, debug=False, reloader=False)
def setUp(self):
self.app = webtest.TestApp(bottle.app())
"""
This script runs the application using a development server.
"""
import bottle
import os
import sys
from bottle import route, run, response, request
import json
import opsCenter
import nodes
bottle.app().catchall = False
@route('/')
def hello():
response.headers['Content-Type'] = 'application/json'
# This python script generates an ARM template that deploys DSE across multiple datacenters.
with open('clusterParameters.json') as inputFile:
clusterParameters = json.load(inputFile)
locations = request.query['locations'].split(",")
vmSize = request.query['vmSize']
nodeCount = int(request.query['nodeCount'])
adminUsername = request.query['adminUsername']
adminPassword = request.query['adminPassword']
# This is the skeleton of the template that we're going to add resources to
generatedTemplate = {
def test_missing_session(self):
"""Test that the session is invalid when it's missing."""
self.mock_database.sessions.find_one.return_value = None
route = bottle.Route(bottle.app(), "/", "POST", self.route)
self.assertRaises(bottle.HTTPError, route.call)
