def run():
"""Run gevent server"""
http_server = WSGIServer((core_settings.SERVER_ADDRESS, core_settings.SERVER_PORT), app)
try:
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
class GeventWSGIServer(object):
"""Adapter for a gevent.wsgi.WSGIServer."""
def __init__(self, *args, **kwargs):
from eden.web.patch import patch_cherrypy
patch_cherrypy()
self.args = args
self.kwargs = kwargs
self.ready = False
def start(self):
"""Start the GeventWSGIServer."""
# We have to instantiate the server class here because its __init__
from gevent.wsgi import WSGIServer
self.ready = True
LOGGER.debug('Starting Gevent WSGI Server...')
self.httpd = WSGIServer(*self.args, **self.kwargs)
self.httpd.serve_forever()
def stop(self):
"""Stop the HTTP server."""
LOGGER.debug('Stoping Gevent WSGI Server...')
self.ready = False
self.httpd.stop()
def main():
master = MasterServer()
server = WSGIServer(("0.0.0.0", 9090), master)
try:
logging.info("Server running on port %s. Ctrl+C to quit" % 9090)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
logging.info("Server stopped")
class ServiceGatewayService(BaseServiceGatewayService):
"""
The Service Gateway Service is the service that uses a gevent web server and Flask to bridge HTTP requests to AMQP RPC ION process service calls.
"""
def on_init(self):
#defaults
self.http_server = None
self.server_hostname = DEFAULT_WEB_SERVER_HOSTNAME
self.server_port = DEFAULT_WEB_SERVER_PORT
self.web_server_enabled = True
self.logging = None
#retain a pointer to this object for use in ProcessRPC calls
global service_gateway_instance
service_gateway_instance = self
#get configuration settings if specified
if 'web_server' in self.CFG:
web_server_cfg = self.CFG['web_server']
if web_server_cfg is not None:
if 'hostname' in web_server_cfg:
self.server_hostname = web_server_cfg['hostname']
if 'port' in web_server_cfg:
self.server_port = web_server_cfg['port']
if 'enabled' in web_server_cfg:
self.web_server_enabled = web_server_cfg['enabled']
if 'log' in web_server_cfg:
self.logging = web_server_cfg['log']
#need to figure out how to redirect HTTP logging to a file
if self.web_server_enabled:
self.start_service(self.server_hostname,self.server_port)
def on_quit(self):
self.stop_service()
def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT):
"""Responsible for starting the gevent based web server."""
if self.http_server is not None:
self.stop_service()
self.http_server = WSGIServer((hostname, port), app, log=self.logging)
self.http_server.start()
return True
def stop_service(self):
"""Responsible for stopping the gevent based web server."""
if self.http_server is not None:
self.http_server.stop()
return True
def main():
parser = argparse.ArgumentParser(description='Run a Senpy server')
parser.add_argument('--level',
'-l',
metavar='logging_level',
type=str,
default="INFO",
help='Logging level')
parser.add_argument('--debug',
'-d',
action='store_true',
default=False,
help='Run the application in debug mode')
parser.add_argument('--default-plugins',
action='store_true',
default=False,
help='Load the default plugins')
parser.add_argument('--host',
type=str,
default="127.0.0.1",
help='Use 0.0.0.0 to accept requests from any host.')
parser.add_argument('--port',
'-p',
type=int,
default=SERVER_PORT,
help='Port to listen on.')
parser.add_argument('--plugins-folder',
'-f',
type=str,
default='plugins',
help='Where to look for plugins.')
parser.add_argument('--only-install',
'-i',
action='store_true',
default=False,
help='Do not run a server, only install the dependencies of the plugins.')
args = parser.parse_args()
logging.basicConfig()
rl = logging.getLogger()
rl.setLevel(getattr(logging, args.level))
app = Flask(__name__)
app.debug = args.debug
sp = Senpy(app, args.plugins_folder, default_plugins=args.default_plugins)
if args.only_install:
sp.install_deps()
return
sp.activate_all()
http_server = WSGIServer((args.host, args.port), app)
try:
print('Senpy version {}'.format(senpy.__version__))
print('Server running on port %s:%d. Ctrl+C to quit' % (args.host,
args.port))
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
print('Bye!')
def run_gevent(app, host='127.0.0.1', port=8000, *args, **kwargs):
from gevent.wsgi import WSGIServer
server = WSGIServer((host, port), app)
server.backlog = 1024
try:
log.info("Server running on port %s:%d" % (host, port))
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def run(self, host='0.0.0.0', port=8000):
from gevent.wsgi import WSGIServer
server = WSGIServer((host, port), self)
server.backlog = 512
try:
log.info("Server running on %s:%d" % (host, port))
server.serve_forever()
except KeyboardInterrupt:
server.stop()
class GeventServer(CommonServer):
def __init__(self, app):
super(GeventServer, self).__init__(app)
self.port = config['longpolling_port']
self.httpd = None
def process_limits(self):
restart = False
if self.ppid != os.getppid():
_logger.warning("LongPolling Parent changed", self.pid)
restart = True
rss, vms = memory_info(psutil.Process(self.pid))
if vms > config['limit_memory_soft']:
_logger.warning('LongPolling virtual memory limit reached: %s', vms)
restart = True
if restart:
# suicide !!
os.kill(self.pid, signal.SIGTERM)
def watchdog(self, beat=4):
import gevent
self.ppid = os.getppid()
while True:
self.process_limits()
gevent.sleep(beat)
def start(self):
import gevent
from gevent.wsgi import WSGIServer
# Set process memory limit as an extra safeguard
_, hard = resource.getrlimit(resource.RLIMIT_AS)
resource.setrlimit(resource.RLIMIT_AS, (config['limit_memory_hard'], hard))
if os.name == 'posix':
signal.signal(signal.SIGQUIT, dumpstacks)
signal.signal(signal.SIGUSR1, log_ormcache_stats)
gevent.spawn(self.watchdog)
self.httpd = WSGIServer((self.interface, self.port), self.app)
_logger.info('Evented Service (longpolling) running on %s:%s', self.interface, self.port)
try:
self.httpd.serve_forever()
except:
_logger.exception("Evented Service (longpolling): uncaught error during main loop")
raise
def stop(self):
import gevent
self.httpd.stop()
gevent.shutdown()
def run(self, preload, stop):
self.start()
self.stop()
def runserver():
# Create the server
application = get_wsgi_application()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
def run_server():
server = WSGIServer(("", 5000), app)
@app.route("/stop")
def stop():
server.stop()
return "ok"
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def runserver():
"""Runs the Flask server"""
if app.debug:
app.run(host=app.config['HOST'], port=app.config['PORT'])
else:
app.wsgi_app = ProxyFix(app.wsgi_app)
address = app.config['HOST'], app.config['PORT']
server = WSGIServer(address, app)
try:
print("Server running on port %s:%d. Ctrl+C to quit" % address)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
print("\nBye bye")
class WebConsole(Console):
def __init__(self):
super(WebConsole, self).__init__()
self._app = Flask('WebConsole')
self._server = WSGIServer(('', 5000), self._app)
self._app.config.update(
DEBUG=True
)
self._app.add_url_rule('/', None, self.index)
def index(self):
sps = self._spiderman.get_spiders()
spinfo = []
for s in sps:
si = s.get_info()
info = {}
info['name'] = s.name
info['dcount'] = si[1]
info['qcount'] = si[0]
info['ccount'] = si[2]
spinfo.append(info)
return render_template('show_spider.html', spinfo=spinfo)
def stop(self):
super(WebConsole, self).stop()
self._server.stop()
def run(self):
print 'Running...'
if self._started == False:
self.start()
self._server.serve_forever()
class AdminUI(SimpleProcess):
"""
A simple Web UI to introspect the container and the ION datastores.
"""
def on_init(self):
self.http_server = None
self.server_hostname = self.CFG.get_safe(CFG_PREFIX + '.web_server.hostname', DEFAULT_WEB_SERVER_HOSTNAME)
self.server_port = self.CFG.get_safe(CFG_PREFIX + '.web_server.port', DEFAULT_WEB_SERVER_PORT)
self.url_prefix = self.CFG.get_safe(CFG_PREFIX + '.url_prefix') or ""
self.web_server_enabled = True
self.logging = None
self.interaction_observer = None
self.plugin = None
app.secret_key = self.__class__.__name__ # Enables sessions (for mscweb)
#retain a pointer to this object for use in ProcessRPC calls
global adminui_instance
adminui_instance = self
#Start the gevent web server unless disabled
if self.web_server_enabled:
self.start_service(self.server_hostname, self.server_port)
plugin_cls = CFG.get_safe(CFG_PREFIX + '.plugin')
if plugin_cls:
cls = named_any(plugin_cls)
self.plugin = cls(app, self)
def on_quit(self):
if self.interaction_observer and self.interaction_observer.started:
self.interaction_observer.stop()
self.stop_service()
def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT):
"""Responsible for starting the gevent based web server."""
if self.http_server is not None:
self.stop_service()
self.http_server = WSGIServer((hostname, port), app, log=self.logging)
self.http_server.start()
return True
def stop_service(self):
"""Responsible for stopping the gevent based web server."""
if self.http_server is not None:
self.http_server.stop()
return True
def run():
from gevent.wsgi import WSGIServer
http_server = WSGIServer(('', app.config['HTTP_PORT']), app)
if app.config['DEBUG']:
debugModeStr = '''Debug mode enabled!'''
else:
debugModeStr = ''
try:
print head.format(app.config['HTTP_HOST'],
str(app.config['HTTP_PORT']), debugModeStr)
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
print tail
def main():
parser = argparse.ArgumentParser(description='Run a Senpy server')
parser.add_argument('--level',
"-l",
metavar="logging_level",
type=str,
default="INFO",
help='Logging level')
parser.add_argument('--debug',
"-d",
action='store_true',
default=False,
help='Run the application in debug mode')
parser.add_argument('--default-plugins',
action='store_true',
default=False,
help='Load the default plugins')
parser.add_argument('--host',
type=str,
default="127.0.0.1",
help='Use 0.0.0.0 to accept requests from any host.')
parser.add_argument('--port',
'-p',
type=int,
default=5000,
help='Port to listen on.')
parser.add_argument('--plugins-folder',
'-f',
type=str,
default="plugins",
help='Where to look for plugins.')
args = parser.parse_args()
logging.basicConfig(level=getattr(logging, args.level))
app = Flask(__name__)
app.debug = args.debug
sp = Senpy(app, args.plugins_folder, default_plugins=args.default_plugins)
sp.activate_all()
http_server = WSGIServer((args.host, args.port), app)
try:
print("Server running on port %s:%d. Ctrl+C to quit" % (args.host,
args.port))
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
print("Bye!")
class RunServerInGreenlet(Greenlet):
def __init__(self, mock_server):
self._httpd = None
self._mock_server = mock_server
super(RunServerInGreenlet, self).__init__()
def run(self):
self._httpd = WSGIServer(
(self._mock_server.config.HOST, self._mock_server.config.PORT),
self._mock_server,
log='default' if self._mock_server.config.DEBUG else None,
)
self._httpd.start()
def stop(self):
if self._httpd:
self._httpd.stop()
class LightweightPyDAP(SimpleProcess):
def on_start(self):
super(LightweightPyDAP,self).on_start()
self.pydap_host = self.CFG.get_safe('server.pydap.host', 'localhost')
self.pydap_port = self.CFG.get_safe('server.pydap.port', '8001')
self.pydap_data_path = self.CFG.get_safe('server.pydap.data_path', 'RESOURCE:ext/pydap')
self.pydap_data_path = FileSystem.get_extended_url(self.pydap_data_path)
self.app = make_app(None, self.pydap_data_path, 'ion/core/static/templates/')
self.log = getLogger('pydap')
self.log.write = self.log.info
self.server = WSGIServer((self.pydap_host, int(self.pydap_port)), self.app, log=self.log)
self.server.start()
def on_quit(self):
self.server.stop()
super(LightweightPyDAP,self).on_quit()
class RunServerInGreenlet(Greenlet):
def __init__(self, mock_server):
self._httpd = None
self._mock_server = mock_server
super(RunServerInGreenlet, self).__init__()
def run(self):
self._httpd = WSGIServer(
(self._mock_server.host, self._mock_server.port),
self._mock_server,
log='default' if self._mock_server.debug else None,
)
self._httpd.start()
def stop(self):
if self._httpd:
self._httpd.stop()
class TestExtIPUtil(unittest.TestCase):
def setUp(self):
def application(environ, start_response):
headers = [("Content-Type", "text/html")]
start_response("200 OK", headers)
return ["127.0.0.1"]
self.server = WSGIServer(("localhost", 8000), application)
gevent.spawn(self.server.serve_forever)
def tearDown(self):
self.server.stop()
def test_ip_verify(self):
self.assertTrue(conpot.utils.ext_ip._verify_address("127.0.0.1") is True)
def test_ext_util(self):
ip_address = conpot.utils.ext_ip._fetch_data(urls=["http://127.0.0.1:8000"])
self.assertTrue(conpot.utils.ext_ip._verify_address(ip_address) is True)
class GeventServer(CommonServer):
def __init__(self, app):
super(GeventServer, self).__init__(app)
self.port = config['longpolling_port']
self.httpd = None
def watch_parent(self, beat=4):
import gevent
ppid = os.getppid()
while True:
if ppid != os.getppid():
pid = os.getpid()
_logger.info("LongPolling (%s) Parent changed", pid)
# suicide !!
os.kill(pid, signal.SIGTERM)
return
gevent.sleep(beat)
def start(self):
import gevent
from gevent.wsgi import WSGIServer
if os.name == 'posix':
signal.signal(signal.SIGQUIT, dumpstacks)
signal.signal(signal.SIGUSR1, log_ormcache_stats)
gevent.spawn(self.watch_parent)
self.httpd = WSGIServer((self.interface, self.port), self.app)
_logger.info('Evented Service (longpolling) running on %s:%s', self.interface, self.port)
try:
self.httpd.serve_forever()
except:
_logger.exception("Evented Service (longpolling): uncaught error during main loop")
raise
def stop(self):
import gevent
self.httpd.stop()
gevent.shutdown()
def run(self, preload, stop):
self.start()
self.stop()
def run():
from gevent.wsgi import WSGIServer
http_server = WSGIServer(('', app.config['HTTP_PORT']), app)
try:
print '''===========================================================================
__...____________________ ,
`(\ [ ===SPACEGDN===--|__|) ___..--"_`--.._____
`"""""""""""""""""| |""` [_""_-___________"_/
| | /..../`'-._.-'`
____| |__/::..'_
|\ ".`"` '_____//\\
`"'-. """"" \\\\/
`""""""""""`
===========================================================================
SpaceGDN developed by pyxld.com and is OSS under the MPL-2.0 at
https://github.com/connor4312/SpaceGDN. We're lifting off...
==========================================================================='''
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
print '''
class ContainerUI(StandaloneProcess):
"""
A simple Web UI to introspect the container and the ION datastores.
"""
def on_init(self):
# defaults
self.http_server = None
self.server_hostname = DEFAULT_WEB_SERVER_HOSTNAME
self.server_port = self.CFG.get_safe("container.flask_webapp.port", DEFAULT_WEB_SERVER_PORT)
self.web_server_enabled = True
self.logging = None
# retain a pointer to this object for use in ProcessRPC calls
global containerui_instance
containerui_instance = self
# Start the gevent web server unless disabled
if self.web_server_enabled:
self.start_service(self.server_hostname, self.server_port)
def on_quit(self):
self.stop_service()
def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT):
"""Responsible for starting the gevent based web server."""
if self.http_server is not None:
self.stop_service()
self.http_server = WSGIServer((hostname, port), app, log=self.logging)
self.http_server.start()
return True
def stop_service(self):
"""Responsible for stopping the gevent based web server."""
if self.http_server is not None:
self.http_server.stop()
return True
def run_server():
import socket
from gevent.wsgi import WSGIServer
from vnc.app import app
# websocket conflict: WebSocketHandler
if DEBUG:
# from werkzeug.debug import DebuggedApplication
app.debug = True
# app = DebuggedApplication(app, evalex=True)
try:
log.info('Listening on http://localhost:{}'.format(PORT))
http_server = WSGIServer(('localhost', PORT), app)
http_server.serve_forever()
# app.run(host='localhost', port=PORT)
except socket.error as e:
log.exception(e)
except KeyboardInterrupt:
pass
finally:
http_server.stop(timeout=10)
log.info('shutdown gracefully')
class ServiceGatewayService(BaseServiceGatewayService):
"""
The Service Gateway Service is the service that uses a gevent web server and Flask
to bridge HTTP requests to AMQP RPC ION process service calls.
"""
def on_init(self):
#defaults
self.http_server = None
#retain a pointer to this object for use in ProcessRPC calls
global service_gateway_instance
######
# to prevent cascading failure, here's an attempted hack
if service_gateway_instance is not None and service_gateway_instance.http_server is not None:
service_gateway_instance.http_server.stop()
# end hack
######
service_gateway_instance = self
self.server_hostname = self.CFG.get_safe(
'container.service_gateway.web_server.hostname',
DEFAULT_WEB_SERVER_HOSTNAME)
self.server_port = self.CFG.get_safe(
'container.service_gateway.web_server.port',
DEFAULT_WEB_SERVER_PORT)
self.web_server_enabled = self.CFG.get_safe(
'container.service_gateway.web_server.enabled', True)
self.web_logging = self.CFG.get_safe(
'container.service_gateway.web_server.log')
self.log_errors = self.CFG.get_safe(
'container.service_gateway.log_errors', True)
#Optional list of trusted originators can be specified in config.
self.trusted_originators = self.CFG.get_safe(
'container.service_gateway.trusted_originators')
if not self.trusted_originators:
self.trusted_originators = None
log.info(
"Service Gateway will not check requests against trusted originators since none are configured."
)
#Get the user_cache_size
self.user_cache_size = self.CFG.get_safe(
'container.service_gateway.user_cache_size',
DEFAULT_USER_CACHE_SIZE)
#Initialize an LRU Cache to keep user roles cached for performance reasons
#maxSize = maximum number of elements to keep in cache
#maxAgeMs = oldest entry to keep
self.user_role_cache = LRUCache(self.user_cache_size, 0, 0)
#Start the gevent web server unless disabled
if self.web_server_enabled:
log.info("Starting service gateway on %s:%s", self.server_hostname,
self.server_port)
self.start_service(self.server_hostname, self.server_port)
#Configure subscriptions for user_cache events
self.user_role_event_subscriber = EventSubscriber(
event_type=OT.UserRoleModifiedEvent,
origin_type="Org",
callback=self.user_role_event_callback)
self.add_endpoint(self.user_role_event_subscriber)
self.user_role_reset_subscriber = EventSubscriber(
event_type=OT.UserRoleCacheResetEvent,
callback=self.user_role_reset_callback)
self.add_endpoint(self.user_role_reset_subscriber)
def on_quit(self):
self.stop_service()
def start_service(self,
hostname=DEFAULT_WEB_SERVER_HOSTNAME,
port=DEFAULT_WEB_SERVER_PORT):
"""Responsible for starting the gevent based web server."""
if self.http_server is not None:
self.stop_service()
self.http_server = WSGIServer((hostname, port),
service_gateway_app,
log=self.web_logging)
self.http_server.start()
return True
def stop_service(self):
"""Responsible for stopping the gevent based web server."""
if self.http_server is not None:
self.http_server.stop()
return True
def is_trusted_address(self, requesting_address):
if self.trusted_originators is None:
return True
for addr in self.trusted_originators:
if requesting_address == addr:
return True
return False
def user_role_event_callback(self, *args, **kwargs):
"""
This method is a callback function for receiving Events when User Roles are modified.
"""
user_role_event = args[0]
org_id = user_role_event.origin
actor_id = user_role_event.actor_id
role_name = user_role_event.role_name
log.debug("User Role modified: %s %s %s" %
(org_id, actor_id, role_name))
#Evict the user and their roles from the cache so that it gets updated with the next call.
if service_gateway_instance.user_role_cache and service_gateway_instance.user_role_cache.has_key(
actor_id):
log.debug('Evicting user from the user_role_cache: %s' % actor_id)
service_gateway_instance.user_role_cache.evict(actor_id)
def user_role_reset_callback(self, *args, **kwargs):
'''
This method is a callback function for when an event is received to clear the user data cache
'''
self.user_role_cache.clear()
@virtualrest.route('/statics/<rtype>/<filename>')
def statics(rtype, filename):
if (rtype in ['imgs', 'fonts', 'css', 'js']):
return send_from_directory(virtualrest.static_folder + '/' + rtype,
filename,
as_attachment=True)
else:
abort(404)
if __name__ == '__main__':
localaddress = config.get('MAIN', 'local_address')
localport = config.getint('MAIN', 'local_port')
if (config.getboolean('MAIN', 'debug')):
virtualrest.run(host=localaddress, port=8080, debug=True)
else:
if (config.getboolean('MAIN', 'use_ssl')):
key_file = config.get('MAIN', 'ssl_key_file')
cert_file = config.get('MAIN', 'ssl_cert_file')
http_server = WSGIServer((localaddress, localport),
virtualrest,
keyfile=key_file,
certfile=cert_file)
else:
http_server = WSGIServer((localaddress, localport), virtualrest)
try:
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
class WebServer(object):
def __init__(self, server_name='Sola', host='127.0.0.1', port=8080, encoding='utf-8'):
self.httpd = None
self.ready = False
self.host = host
self.port = port
self.encoding = encoding
def bootstrap(self):
self.bootstrap_options()
self.boostrap_command_parse()
self.boostrap_database_configuration()
def bootstrap_options(self):
pass
def boostrap_database_configuration(self):
pass
def boostrap_command_parse(self):
pass
def new_route(self):
return cherrypy.dispatch.RoutesDispatcher()
def create_app(self):
raise NotImplemented('Must implement create_app in Subclass')
def _start_app(self):
ctl, routes = self.create_app()
patch_cherrypy()
conf = {
'engine.autoreload.on': False,
'log.screen': False,
'log.error_file': '',
'log.access_file': '',
'environment': 'embedded',
'tools.decode.on': unicode,
'tools.encode.on': unicode,
'tools.encode.encoding': self.encoding,
'tools.gzip.on': True,
'tools.log_headers.on': False,
'request.show_tracebacks': False,
}
config = {'/': {'request.dispatch': routes}, 'global': conf}
cherrypy.config.clear()
cherrypy.config.update(config)
app = cherrypy.tree.mount(ctl, '/', config)
cherrypy.server.unsubscribe()
self.httpd = WSGIServer((self.host, self.port), app)
def serve_forever(self):
self.ready = True
self._start_app()
try:
cherrypy.engine.start()
self.httpd.serve_forever()
except KeyboardInterrupt:
self.stop()
def stop(self):
cherrypy.engine.stop()
self.httpd.stop()
self.ready = False
class UIServer(SimpleProcess):
"""
Process to start a generic UI server that can be extended with content and service gateway
"""
def on_init(self):
# Retain a pointer to this object for use in routes
global ui_instance
ui_instance = self
# Main references to basic components (if initialized)
self.http_server = None
self.socket_io = None
self.service_gateway = None
self.oauth = oauth
# Configuration
self.server_enabled = self.CFG.get_safe(CFG_PREFIX + ".server.enabled") is True
self.server_debug = self.CFG.get_safe(CFG_PREFIX + ".server.debug") is True
# Note: this may be the empty string. Using localhost does not make the server publicly accessible
self.server_hostname = self.CFG.get_safe(CFG_PREFIX + ".server.hostname", DEFAULT_WEB_SERVER_HOSTNAME)
self.server_port = self.CFG.get_safe(CFG_PREFIX + ".server.port", DEFAULT_WEB_SERVER_PORT)
self.server_log_access = self.CFG.get_safe(CFG_PREFIX + ".server.log_access") is True
self.server_log_errors = self.CFG.get_safe(CFG_PREFIX + ".server.log_errors") is True
self.server_socket_io = self.CFG.get_safe(CFG_PREFIX + ".server.socket_io") is True
self.server_secret = self.CFG.get_safe(CFG_PREFIX + ".security.secret") or ""
self.session_timeout = int(self.CFG.get_safe(CFG_PREFIX + ".security.session_timeout") or DEFAULT_SESSION_TIMEOUT)
self.extend_session_timeout = self.CFG.get_safe(CFG_PREFIX + ".security.extend_session_timeout") is True
self.max_session_validity = int(self.CFG.get_safe(CFG_PREFIX + ".security.max_session_validity") or DEFAULT_SESSION_TIMEOUT)
self.remember_user = self.CFG.get_safe(CFG_PREFIX + ".security.remember_user") is True
self.set_cors_headers = self.CFG.get_safe(CFG_PREFIX + ".server.set_cors") is True
self.develop_mode = self.CFG.get_safe(CFG_PREFIX + ".server.develop_mode") is True
self.oauth_enabled = self.CFG.get_safe(CFG_PREFIX + ".oauth.enabled") is True
self.oauth_scope = self.CFG.get_safe(CFG_PREFIX + ".oauth.default_scope") or "scioncc"
self.has_service_gateway = self.CFG.get_safe(CFG_PREFIX + ".service_gateway.enabled") is True
self.service_gateway_prefix = self.CFG.get_safe(CFG_PREFIX + ".service_gateway.url_prefix", DEFAULT_GATEWAY_PREFIX)
self.extensions = self.CFG.get_safe(CFG_PREFIX + ".extensions") or []
self.extension_objs = []
# TODO: What about https?
self.base_url = "http://%s:%s" % (self.server_hostname or "localhost", self.server_port)
self.gateway_base_url = None
self.idm_client = IdentityManagementServiceProcessClient(process=self)
# One time setup
if self.server_enabled:
app.secret_key = self.server_secret or self.__class__.__name__ # Enables encrypted session cookies
if self.server_debug:
app.debug = True
if self.server_socket_io:
self.socket_io = SocketIO(app)
if self.has_service_gateway:
from ion.services.service_gateway import ServiceGateway, sg_blueprint
self.gateway_base_url = self.base_url + self.service_gateway_prefix
self.service_gateway = ServiceGateway(process=self, config=self.CFG, response_class=app.response_class)
app.register_blueprint(sg_blueprint, url_prefix=self.service_gateway_prefix)
for ext_cls in self.extensions:
try:
cls = named_any(ext_cls)
except AttributeError as ae:
# Try to nail down the error
import importlib
importlib.import_module(ext_cls.rsplit(".", 1)[0])
raise
self.extension_objs.append(cls())
for ext_obj in self.extension_objs:
ext_obj.on_init(self, app)
if self.extensions:
log.info("UI Server: %s extensions initialized", len(self.extensions))
# Start the web server
self.start_service()
log.info("UI Server: Started server on %s" % self.base_url)
else:
log.warn("UI Server: Server disabled in config")
def on_quit(self):
self.stop_service()
def start_service(self):
""" Starts the web server. """
if self.http_server is not None:
self.stop_service()
if self.server_socket_io:
self.http_server = SocketIOServer((self.server_hostname, self.server_port),
app.wsgi_app,
resource='socket.io',
log=None)
self.http_server._gl = gevent.spawn(self.http_server.serve_forever)
log.info("UI Server: Providing web sockets (socket.io) server")
else:
self.http_server = WSGIServer((self.server_hostname, self.server_port),
app,
log=None)
self.http_server.start()
if self.service_gateway:
self.service_gateway.start()
log.info("UI Server: Service Gateway started on %s", self.gateway_base_url)
for ext_obj in self.extension_objs:
ext_obj.on_start()
return True
def stop_service(self):
""" Responsible for stopping the gevent based web server. """
for ext_obj in self.extension_objs:
ext_obj.on_stop()
if self.http_server is not None:
self.http_server.stop()
if self.service_gateway:
self.service_gateway.stop()
# Need to terminate the server greenlet?
return True
# -------------------------------------------------------------------------
# Authentication
def auth_external(self, username, ext_user_id, ext_id_provider="ext"):
"""
Given username and user identifier from an external identity provider (IdP),
retrieve actor_id and establish user session. Return user info from session.
Convention is that system local username is ext_id_provider + ":" + username,
e.g. "ext_johnbean"
Return NotFound if user not registered in system. Caller can react and create
a user account through the normal system means
@param username the user name the user recognizes.
@param ext_user_id a unique identifier coming from the external IdP
@param ext_id_provider identifies the external IdP service
"""
try:
if ext_user_id and ext_id_provider and username:
local_username = "******" % (ext_id_provider, username)
actor_id = self.idm_client.find_actor_identity_by_username(local_username)
user_info = self._set_server_session(actor_id, local_username)
return build_json_response(user_info)
else:
raise BadRequest("External user info missing")
except Exception:
return build_json_error()
def login(self):
""" Explicit (non-token) login and creation of a server session (Cookie based). """
try:
username = get_arg("username")
password = get_arg("password")
if username and password:
actor_id = self.idm_client.check_actor_credentials(username, password)
user_info = self._set_server_session(actor_id, username)
return build_json_response(user_info)
else:
raise BadRequest("Username or password missing")
except Exception:
return build_json_error()
def _set_server_session(self, actor_id, username=None):
""" Sets server session based on user_id and ActorIdentity. """
actor_user = self.idm_client.read_identity_details(actor_id)
if actor_user.type_ != OT.UserIdentityDetails:
raise BadRequest("Bad identity details")
full_name = actor_user.contact.individual_names_given + " " + actor_user.contact.individual_name_family
valid_until = int(get_ion_ts_millis() / 1000 + self.session_timeout)
set_auth(actor_id, username, full_name, valid_until=valid_until, roles=actor_user.contact.roles)
user_info = get_auth()
return user_info
def get_session(self):
"""
Returns user session information for current authentication.
This can be polled regularly by client code to detect changes in session state and expiration.
"""
def call_extend_session_attrs(session_attrs, actor_user):
""" Call UI extensions to make additions to user session """
for ext_obj in self.extension_objs:
func = getattr(ext_obj, "extend_user_session_attributes", None)
if func:
try:
func(session_attrs, actor_user)
except Exception:
log.exception("Error calling UI extension extend_user_session_attributes()")
try:
# Get user session from OAuth access token in HTTP Authorization header
auth_hdr = request.headers.get("authorization", None)
if auth_hdr:
valid, req = self.oauth.verify_request([self.oauth_scope]) # Note: Do NOT extend session timeout here!
if valid:
actor_id = flask.g.oauth_user.get("actor_id", "")
actor_user = self.idm_client.read_actor_identity(actor_id)
session_attrs = dict(is_logged_in=True, is_registered=True,
attributes={"roles": actor_user.details.contact.roles}, roles={})
if actor_user.session:
session_attrs.update(actor_user.session)
call_extend_session_attrs(session_attrs, actor_user)
return build_json_response(session_attrs)
if self.remember_user:
# Get user session from user_id/access_token placed inside server session (Cookie)
# This is a feature to allow returning users to resume a session if still valid
access_token = flask.session.get("access_token", None)
actor_id = flask.session.get("actor_id", None)
if access_token and actor_id:
actor_user = self.idm_client.read_actor_identity(actor_id)
session_attrs = dict(access_token=access_token, is_logged_in=True, is_registered=True,
attributes={"roles": actor_user.details.contact.roles}, roles={})
if actor_user.session:
# Check validity in persisted user session
if 0 < int(actor_user.session.get("valid_until", 0)) * 1000 < current_time_millis():
clear_auth()
return build_json_response(get_auth())
session_attrs.update(actor_user.session)
else:
# No trace of existing session in user object
clear_auth()
return build_json_response(get_auth())
call_extend_session_attrs(session_attrs, actor_user)
return build_json_response(session_attrs)
# Get user session from Flask session and cookie (non-token mode)
user_info = get_auth()
if 0 < int(user_info.get("valid_until", 0)) * 1000 < current_time_millis():
clear_auth() # Clear expired session
user_info = get_auth()
call_extend_session_attrs(user_info, None)
return build_json_response(user_info)
except Exception:
return build_json_error()
def logout(self):
try:
access_token = get_req_bearer_token() or flask.session.get("access_token", None)
if access_token:
try:
# Invalidate access token
token_id = str("access_token_%s" % access_token)
token_obj = ui_instance.container.object_store.read(token_id)
token_obj.status = "CANCELLED"
token_obj.attributes["cancel_ts"] = get_ion_ts_millis()
token_obj.attributes["cancel_msg"] = "User logout"
ui_instance.container.object_store.update(token_obj)
log.info("Invalidated stored access token for user=%s", token_obj.actor_id)
except NotFound:
pass
except Exception:
log.exception("Error invalidating access token")
clear_auth()
return build_json_response("OK")
except Exception:
return build_json_error()
# Create a relationship with type 'knows'
relationship = firstNode.toma(secondNode, cantidad=3)
# Always shut down your database when your application exits
db.shutdown()
def application(env, start_response):
start_response("200 OK", [("Content-Type", "text/html; charset=utf-8")])
if env['PATH_INFO'] == '/':
return open('front.html', 'r').readlines()
if env['PATH_INFO'] == '/user':
post_data = post2dic(env['wsgi.input'].readline().decode())
addUser(post_data['usuario'])
return ["Hello, World!"]
if __name__ == "__main__":
from gevent.wsgi import WSGIServer
address = "localhost", 8080
server = WSGIServer(address, application)
try:
print "Server running on port %s:%d. Ctrl+C to quit" % address
server.serve_forever()
except KeyboardInterrupt:
server.stop()
print "Bye bye"
class Application(Singleton):
"""
Main class of your application.
Pass options to constructor and all subsystems(eventer, router) will be configured.
"""
def __init__(self, options):
self.init_options(options)
self.init_eventer()
self.init_router()
self.init_templater()
self.eventer.publish("BeforeDatabaseEngineConfiguration", self)
self.init_db()
self.eventer.publish("AfterDatabaseEngineConfiguration", self)
self.init_session()
self.eventer.publish("BeforeInitStatic", self)
self.init_static()
self.eventer.publish("AfterInitStatic", self)
self.eventer.publish("BeforeInitServer", self)
self.init_server()
self.eventer.publish("AfterInitServer", self)
self.eventer.publish("BeforeApplicationStarted", self)
def init_options(self, options):
logging.basicConfig(level=logging.CRITICAL)
default_options = {
"application": {
"address": "127.0.0.1",
"port": 8080,
"system": {
"log": None
}
},
"urls": {},
"views": {
"templates_path": [],
"templates_extensions": ["compressinja.html.HtmlCompressor", "jinja2.ext.i18n"],
"static_path": [],
"static_not_compile": [],
"static_build": True,
'session_type': "cookie",
"session_auto": True,
'session_cookie_expires': True,
'session_encrypt_key':'sldk24j0jf09w0jfg24',
'session_validate_key':';l[pfghopkqeq1234,fs'
},
"events": {}
}
self.options = Dict.merge(default_options, options)
def init_eventer(self):
self.eventer = Eventer(self.options["events"])
def init_router(self):
self.router = Router(self.options)
def init_templater(self):
self.templater = Templater(self)
def init_static(self):
static_builder = None
self.add_static(self.options["views"]["static_path"], not_compile=self.options["views"]["static_not_compile"], merge=False, build=self.options["views"]["static_build"])
def add_static(self, sps, not_compile=[], url_path="/", merge=True, build=True):
static_path = []
for sp in sps:
try:
sp = Importer.module_path(sp)
except:
pass
try:
static_path.append(sp)
static_builder = StaticBuilder(sp, not_compile)
if build:
static_builder.build()
if build:
self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {url_path : sp + "/build"}, cache=False)
else:
self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {url_path : sp}, cache=False)
except:
pass
if merge:
self.options["views"]["static_path"] = self.options["views"]["static_path"] + static_path
else:
self.options["views"]["static_path"] = static_path
def init_db(self):
if "models" in self.options:
metadata.bind = self.options["models"]["connection"]
metadata.bind.echo = False
def init_session(self):
session_options = {
'session.type': self.options["views"]['session_type'],
"session.auto": self.options["views"]["session_auto"],
'session.cookie_expires': self.options["views"]['session_cookie_expires'],
'session.encrypt_key': self.options["views"]['session_encrypt_key'],
'session.validate_key': self.options["views"]['session_validate_key']
}
self.wsgi_app = SessionMiddleware(self.wsgi_app, session_options, environ_key="session")
def init_server(self):
#kwargs = dict(filter(lambda item: item[0] not in ["address", "port"], self.options["application"].iteritems()))
kwargs = {}
if "system" in self.options["application"]:
kwargs = self.options["application"]["system"]
self.server = WSGIServer((self.options["application"]["address"], self.options["application"]["port"]), self.wsgi_app, **kwargs)
def wsgi_app(self, options, start_response):
request = Request(options)
response = self.router.route(request)
return response(options, start_response)
def start(self):
gevent.signal(signal.SIGTERM, self.stop)
gevent.signal(signal.SIGINT, self.stop)
self.eventer.publish("ApplicationStarted", self)
self.server.serve_forever()
def start_no_wait(self):
self.eventer.publish("ApplicationStarted", self)
self.server.start()
def stop(self):
self.eventer.publish("ApplicationStopped", self)
self.server.stop()
def stop(self, *args, **kwargs):
WSGIServer.stop(self)
Component.stop(self)
self.logger.info("Exit")
if __name__ == '__main__':
with virtualrest.app_context():
configs = mongodb.db.configs.find({},{'_id':0})[0]
fallback = literal_eval(configs['fallbacks'])
result_limit = configs['result_limit']
server_address = configs['server_address']
def_headers = {
'Access-Control-Allow-Origin' : '%s' % server_address,
'Content-Type' : 'application/json; charset=UTF-8',
'Access-Control-Max-Age': 86400,
'Access-Control-Allow-Credentials': True,
}
localport = config.getint('MAIN', 'local_port')
localaddress = config.get('MAIN', 'local_address')
if (config.getboolean('MAIN', 'debug')):
virtualrest.run(host=localaddress,port=localport, debug=True)
else:
if (config.getboolean('MAIN', 'use_ssl')):
cert_file = config.get('MAIN', 'ssl_cert_file')
key_file = config.get('MAIN', 'ssl_key_file')
http_server = WSGIServer((localaddress, localport), virtualrest, keyfile=key_file, certfile=cert_file)
else:
http_server = WSGIServer((localaddress, localport), virtualrest)
try:
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
class APIServer(object):
"""
Runs the sikorka API server
"""
# flask TypeConverter
# links argument-placeholder in route (e.g. '/<hexaddress: channel_address>') to the Converter
_type_converter_mapping = {'hexaddress': HexAddressConverter}
_api_prefix = '/api/1'
def __init__(self,
rest_api,
cors_domain_list=None,
eth_rpc_endpoint=None,
webui=False):
self.rest_api = rest_api
self.blueprint = create_blueprint()
# TODO: Make configurable version
self.rest_api.version = 1
if self.rest_api.version == 1:
self.flask_api_context = Api(
self.blueprint,
prefix=self._api_prefix,
)
else:
raise ValueError('Invalid api version: {}'.format(
self.rest_api.version))
rootpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.flask_app = Flask(__name__,
static_url_path='/static',
static_folder=os.path.join(
rootpath, 'ui', 'static'))
if cors_domain_list:
CORS(self.flask_app, origins=cors_domain_list)
self._add_default_resources()
self._register_type_converters()
self.flask_app.register_blueprint(self.blueprint)
self.flask_app.config['WEBUI_PATH'] = os.path.join(rootpath, 'ui')
if webui:
for route in ['/index.html', '/']:
self.flask_app.add_url_rule(
route,
route,
view_func=self._serve_webui,
methods=['GET'],
)
def _add_default_resources(self):
self.add_resource(AddressResource, '/address')
self.add_resource(DetectorSignResource,
'/detector_sign/<hexaddress:user_address>')
def _register_type_converters(self, additional_mapping=None):
# an additional mapping concats to class-mapping and will overwrite existing keys
if additional_mapping:
mapping = dict(self._type_converter_mapping, **additional_mapping)
else:
mapping = self._type_converter_mapping
for key, value in mapping.items():
self.flask_app.url_map.converters[key] = value
def add_resource(self, resource_cls, route):
self.flask_api_context.add_resource(
resource_cls,
route,
resource_class_kwargs={'rest_api_object': self.rest_api})
def _serve_webui(self, file='index.html'):
try:
assert file
response = send_from_directory(self.flask_app.config['WEBUI_PATH'],
file)
except (NotFound, AssertionError):
response = send_from_directory(self.flask_app.config['WEBUI_PATH'],
'index.html')
return response
def run(self, host='127.0.0.1', port=5011, **kwargs):
self.flask_app.run(host=host, port=port, **kwargs)
def start(self, host='127.0.0.1', port=5011):
self.wsgiserver = WSGIServer((host, port),
self.flask_app,
log=log,
error_log=log)
self.wsgiserver.start()
def stop(self, timeout=5):
if getattr(self, 'wsgiserver', None):
self.wsgiserver.stop(timeout)
self.wsgiserver = None
class APIServer(object):
"""
Runs the API-server that routes the endpoint to the resources.
The API is wrapped in multiple layers, and the Server should be invoked this way::
# instance of the raiden-api
raiden_api = RaidenAPI(...)
# wrap the raiden-api with rest-logic and encoding
rest_api = RestAPI(raiden_api)
# create the server and link the api-endpoints with flask / flask-restful middleware
api_server = APIServer(rest_api)
# run the server
api_server.run('127.0.0.1', 5001, debug=True)
"""
# flask TypeConverter
# links argument-placeholder in route (e.g. '/<hexaddress: channel_address>') to the Converter
_type_converter_mapping = {
'hexaddress': HexAddressConverter
}
_api_prefix = '/api/1'
def __init__(self, rest_api, cors_domain_list=None, web_ui=False, eth_rpc_endpoint=None):
self.rest_api = rest_api
self.blueprint = create_blueprint()
if self.rest_api.version == 1:
self.flask_api_context = Api(
self.blueprint,
prefix=self._api_prefix,
)
else:
raise ValueError('Invalid api version: {}'.format(self.rest_api.version))
self.flask_app = Flask(__name__)
if cors_domain_list:
CORS(self.flask_app, origins=cors_domain_list)
self._add_default_resources()
self._register_type_converters()
self.flask_app.register_blueprint(self.blueprint)
self.flask_app.config['WEBUI_PATH'] = '../ui/web/dist/'
if eth_rpc_endpoint:
if not eth_rpc_endpoint.startswith('http'):
eth_rpc_endpoint = 'http://' + eth_rpc_endpoint
self.flask_app.config['WEB3_ENDPOINT'] = eth_rpc_endpoint
if web_ui:
for route in ['/ui/<path:file>', '/ui', '/ui/', '/index.html', '/']:
self.flask_app.add_url_rule(
route,
route,
view_func=self._serve_webui,
methods=['GET'],
)
def _add_default_resources(self):
self.add_resource(AddressResource, '/address')
self.add_resource(ChannelsResource, '/channels')
self.add_resource(
ChannelsResourceByChannelAddress,
'/channels/<hexaddress:channel_address>'
)
self.add_resource(TokensResource, '/tokens')
self.add_resource(
PartnersResourceByTokenAddress,
'/tokens/<hexaddress:token_address>/partners'
)
self.add_resource(
RegisterTokenResource,
'/tokens/<hexaddress:token_address>'
)
self.add_resource(NetworkEventsResource, '/events/network')
self.add_resource(
TokenEventsResource,
'/events/tokens/<hexaddress:token_address>'
)
self.add_resource(
ChannelEventsResource,
'/events/channels/<hexaddress:channel_address>'
)
self.add_resource(
TokenSwapsResource,
'/token_swaps/<hexaddress:target_address>/<int:identifier>'
)
self.add_resource(
TransferToTargetResource,
'/transfers/<hexaddress:token_address>/<hexaddress:target_address>'
)
self.add_resource(
ConnectionsResource,
'/connection/<hexaddress:token_address>'
)
def _serve_webui(self, file='index.html'):
try:
assert file
web3 = self.flask_app.config.get('WEB3_ENDPOINT')
if web3 and 'config.' in file and file.endswith('.json'):
response = jsonify({'raiden': self._api_prefix, 'web3': web3})
else:
response = send_from_directory(self.flask_app.config['WEBUI_PATH'], file)
except (NotFound, AssertionError):
response = send_from_directory(self.flask_app.config['WEBUI_PATH'], 'index.html')
return response
def _register_type_converters(self, additional_mapping=None):
# an additional mapping concats to class-mapping and will overwrite existing keys
if additional_mapping:
mapping = dict(self._type_converter_mapping, **additional_mapping)
else:
mapping = self._type_converter_mapping
for key, value in mapping.items():
self.flask_app.url_map.converters[key] = value
def add_resource(self, resource_cls, route):
self.flask_api_context.add_resource(
resource_cls,
route,
resource_class_kwargs={'rest_api_object': self.rest_api}
)
def run(self, host='127.0.0.1', port=5001, **kwargs):
self.flask_app.run(host=host, port=port, **kwargs)
def start(self, host='127.0.0.1', port=5001):
self.wsgiserver = WSGIServer((host, port), self.flask_app)
self.wsgiserver.start()
def stop(self, timeout=5):
if getattr(self, 'wsgiserver', None):
self.wsgiserver.stop(timeout)
self.wsgiserver = None
@app.route("/api/{v}/node/<path:node_name>".format(v=API_VER), methods=["GET"])
def get_node_info(node_name):
"""
GET /api/<version>/node/<node_name>
Get information about a ROS node
"""
node_name = "/" + node_name
state = rosnode_master.getSystemState()
pubs = [t for t, l in state[0] if node_name in l]
subs = [t for t, l in state[1] if node_name in l]
srvs = [t for t, l in state[2] if node_name in l]
return jsonify({
"node_name": node_name,
"pubs": pubs,
"subs": subs,
"srvs": srvs
})
if __name__ == '__main__':
rospy.init_node("api")
server = WSGIServer(('', 5000), app)
try:
rospy.loginfo("API now listening on http://0.0.0.0:5000")
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def stop(self, *args, **kwargs):
self.application.real_logger.info("Stopping monitoring server")
WSGIServer.stop(self, *args, **kwargs)
class PlatformRuntime(object):
def __init__(self, registry, srnodes, container, attach=False):
self.registry = registry
self.container = container
self.srnodes = srnodes
self.attach = attach
self._resolve = _ProxyResolver(self.registry)
self._init()
def _init(self):
self._proxy = WSGIServer(('', 0), ProxyApp(self._resolve))
self._proxy.start()
def dispose(self):
self._proxy.stop()
def _make_port_specs(self, ports):
return [str(port) for port in ports]
def make_config(self):
"""Given a L{Container}, construct a Docker config."""
ports = self._make_port_specs(self.container.ports)
return self._container_config(self.container.image,
self.container.command,
hostname=self.container.instance,
environment=self._make_environment(),
tty=self.container.tty,
stdin_open=self.attach,
ports=ports)
def _make_environment(self):
proxy_netloc = 'http://%s:%d' % (_DOCKER_GATEWAY,
self._proxy.server_port)
environment = self.container.env or {}
environment = environment.copy()
for (n, v) in (('GILLIAM_FORMATION', self.container.formation),
('GILLIAM_SERVICE', self.container.service),
('GILLIAM_INSTANCE', self.container.instance),
('GILLIAM_SERVICE_REGISTRY_NODES', self.srnodes),
('GILLIAM_SERVICE_REGISTRY',
self.srnodes), ('HTTP_PROXY', proxy_netloc),
('http_proxy', proxy_netloc), ('HTTPS_PROXY',
proxy_netloc)):
if v is not None:
environment[n] = v
return _convert_environment_dict_to_array(environment)
def _container_config(self,
image,
command,
hostname=None,
user=None,
detach=False,
stdin_open=False,
tty=False,
mem_limit=0,
ports=None,
environment=None,
dns=None,
volumes=None,
volumes_from=None):
if isinstance(command, six.string_types):
command = shlex.split(str(command))
d = {
'Hostname': hostname,
'PortSpecs': ports,
'User': user,
'Tty': tty,
'OpenStdin': stdin_open,
'Memory': mem_limit,
'AttachStdin': self.attach,
'AttachStdout': self.attach,
'AttachStderr': self.attach,
'Env': environment,
'Cmd': command,
'Dns': dns,
'Image': image,
'Volumes': volumes,
'VolumesFrom': volumes_from,
}
#print "CONFIG", d
return d
class APIServer:
"""
Runs the API-server that routes the endpoint to the resources.
The API is wrapped in multiple layers, and the Server should be invoked this way::
# instance of the raiden-api
raiden_api = RaidenAPI(...)
# wrap the raiden-api with rest-logic and encoding
rest_api = RestAPI(raiden_api)
# create the server and link the api-endpoints with flask / flask-restful middleware
api_server = APIServer(rest_api)
# run the server
api_server.run('127.0.0.1', 5001, debug=True)
"""
_api_prefix = '/api/1'
def __init__(self, rest_api, cors_domain_list=None, web_ui=False, eth_rpc_endpoint=None):
if rest_api.version != 1:
raise ValueError(
'Invalid api version: {}'.format(rest_api.version)
)
flask_app = Flask(__name__)
if cors_domain_list:
CORS(flask_app, origins=cors_domain_list)
if eth_rpc_endpoint:
if not eth_rpc_endpoint.startswith('http'):
eth_rpc_endpoint = 'http://{}'.format(eth_rpc_endpoint)
flask_app.config['WEB3_ENDPOINT'] = eth_rpc_endpoint
blueprint = create_blueprint()
flask_api_context = Api(blueprint, prefix=self._api_prefix)
restapi_setup_type_converters(
flask_app,
{'hexaddress': HexAddressConverter},
)
restapi_setup_urls(
flask_api_context,
rest_api,
URLS_V1,
)
self.rest_api = rest_api
self.flask_app = flask_app
self.blueprint = blueprint
self.flask_api_context = flask_api_context
self.wsgiserver = None
self.flask_app.register_blueprint(self.blueprint)
self.flask_app.config['WEBUI_PATH'] = '../ui/web/dist/'
if is_frozen():
# Inside frozen pyinstaller image
self.flask_app.config['WEBUI_PATH'] = '{}/raiden/ui/web/dist/'.format(sys.prefix)
if web_ui:
for route in ('/ui/<path:file_name>', '/ui', '/ui/', '/index.html', '/'):
self.flask_app.add_url_rule(
route,
route,
view_func=self._serve_webui,
methods=('GET', ),
)
def _serve_webui(self, file_name='index.html'): # pylint: disable=redefined-builtin
try:
assert file_name
web3 = self.flask_app.config.get('WEB3_ENDPOINT')
if web3 and 'config.' in file_name and file_name.endswith('.json'):
host = request.headers.get('Host')
if any(h in web3 for h in ('localhost', '127.0.0.1')) and host:
_, _port = split_endpoint(web3)
_host, _ = split_endpoint(host)
web3 = 'http://{}:{}'.format(_host, _port)
response = jsonify({'raiden': self._api_prefix, 'web3': web3})
else:
response = send_from_directory(self.flask_app.config['WEBUI_PATH'], file_name)
except (NotFound, AssertionError):
response = send_from_directory(self.flask_app.config['WEBUI_PATH'], 'index.html')
return response
def run(self, host='127.0.0.1', port=5001, **kwargs):
self.flask_app.run(host=host, port=port, **kwargs)
def start(self, host='127.0.0.1', port=5001):
self.wsgiserver = WSGIServer((host, port), self.flask_app, log=log, error_log=log)
self.wsgiserver.start()
def stop(self, timeout=5):
if getattr(self, 'wsgiserver', None):
self.wsgiserver.stop(timeout)
self.wsgiserver = None
def stop(self, *args, **kwargs):
self.application.real_logger.info("Stopping monitoring server")
WSGIServer.stop(self, *args, **kwargs)
class ServiceGatewayService(BaseServiceGatewayService):
"""
The Service Gateway Service is the service that uses a gevent web server and Flask
to bridge HTTP requests to AMQP RPC ION process service calls.
"""
def on_init(self):
#defaults
self.http_server = None
#retain a pointer to this object for use in ProcessRPC calls
global service_gateway_instance
######
# to prevent cascading failure, here's an attempted hack
if service_gateway_instance is not None and service_gateway_instance.http_server is not None:
service_gateway_instance.http_server.stop()
# end hack
######
service_gateway_instance = self
self.server_hostname = self.CFG.get_safe('container.service_gateway.web_server.hostname', DEFAULT_WEB_SERVER_HOSTNAME)
self.server_port = self.CFG.get_safe('container.service_gateway.web_server.port', DEFAULT_WEB_SERVER_PORT)
self.web_server_enabled = self.CFG.get_safe('container.service_gateway.web_server.enabled', True)
self.web_logging = self.CFG.get_safe('container.service_gateway.web_server.log')
self.log_errors = self.CFG.get_safe('container.service_gateway.log_errors', False)
#Optional list of trusted originators can be specified in config.
self.trusted_originators = self.CFG.get_safe('container.service_gateway.trusted_originators')
if not self.trusted_originators:
self.trusted_originators = None
log.info("Service Gateway will not check requests against trusted originators since none are configured.")
#Get the user_cache_size
self.user_cache_size = self.CFG.get_safe('container.service_gateway.user_cache_size', DEFAULT_USER_CACHE_SIZE)
#Initialize an LRU Cache to keep user roles cached for performance reasons
#maxSize = maximum number of elements to keep in cache
#maxAgeMs = oldest entry to keep
self.user_data_cache = LRUCache(self.user_cache_size,0,0)
#Start the gevent web server unless disabled
if self.web_server_enabled:
log.info("Starting service gateway on %s:%s", self.server_hostname, self.server_port)
self.start_service(self.server_hostname, self.server_port)
#Configure subscriptions for user_cache events
self.user_role_event_subscriber = EventSubscriber(event_type=OT.UserRoleModifiedEvent, origin_type="Org",
callback=self.user_role_event_callback)
self.user_role_event_subscriber.start()
self.user_role_reset_subscriber = EventSubscriber(event_type=OT.UserRoleCacheResetEvent,
callback=self.user_role_reset_callback)
self.user_role_reset_subscriber.start()
def on_quit(self):
self.stop_service()
if self.user_role_event_subscriber is not None:
self.user_role_event_subscriber.stop()
if self.user_role_reset_subscriber is not None:
self.user_role_reset_subscriber.stop()
def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT):
"""Responsible for starting the gevent based web server."""
if self.http_server is not None:
self.stop_service()
self.http_server = WSGIServer((hostname, port), service_gateway_app, log=self.web_logging)
self.http_server.start()
return True
def stop_service(self):
"""Responsible for stopping the gevent based web server."""
if self.http_server is not None:
self.http_server.stop()
return True
def is_trusted_address(self, requesting_address):
if self.trusted_originators is None:
return True
for addr in self.trusted_originators:
if requesting_address == addr:
return True
return False
def user_role_event_callback(self, *args, **kwargs):
"""
This method is a callback function for receiving Events when User Roles are modified.
"""
user_role_event = args[0]
org_id = user_role_event.origin
actor_id = user_role_event.actor_id
role_name = user_role_event.role_name
log.debug("User Role modified: %s %s %s" % (org_id, actor_id, role_name))
#Evict the user and their roles from the cache so that it gets updated with the next call.
if service_gateway_instance.user_data_cache and service_gateway_instance.user_data_cache.has_key(actor_id):
log.debug('Evicting user from the user_data_cache: %s' % actor_id)
service_gateway_instance.user_data_cache.evict(actor_id)
def user_role_reset_callback(self, *args, **kwargs):
'''
This method is a callback function for when an event is received to clear the user data cache
'''
self.user_data_cache.clear()
class APIServer:
"""
Runs the API-server that routes the endpoint to the resources.
The API is wrapped in multiple layers, and the Server should be invoked this way::
# instance of the raiden-api
raiden_api = RaidenAPI(...)
# wrap the raiden-api with rest-logic and encoding
rest_api = RestAPI(raiden_api)
# create the server and link the api-endpoints with flask / flask-restful middleware
api_server = APIServer(rest_api)
# run the server
api_server.run('127.0.0.1', 5001, debug=True)
"""
_api_prefix = '/api/1'
def __init__(self,
rest_api,
cors_domain_list=None,
web_ui=False,
eth_rpc_endpoint=None):
if rest_api.version != 1:
raise ValueError('Invalid api version: {}'.format(
rest_api.version))
flask_app = Flask(__name__)
if cors_domain_list:
CORS(flask_app, origins=cors_domain_list)
if eth_rpc_endpoint:
if not eth_rpc_endpoint.startswith('http'):
eth_rpc_endpoint = 'http://{}'.format(eth_rpc_endpoint)
flask_app.config['WEB3_ENDPOINT'] = eth_rpc_endpoint
blueprint = create_blueprint()
flask_api_context = Api(blueprint, prefix=self._api_prefix)
restapi_setup_type_converters(
flask_app,
{'hexaddress': HexAddressConverter},
)
restapi_setup_urls(
flask_api_context,
rest_api,
URLS_V1,
)
self.rest_api = rest_api
self.flask_app = flask_app
self.blueprint = blueprint
self.flask_api_context = flask_api_context
self.wsgiserver = None
self.flask_app.register_blueprint(self.blueprint)
self.flask_app.config['WEBUI_PATH'] = '../ui/web/dist/'
if is_frozen():
# Inside frozen pyinstaller image
self.flask_app.config[
'WEBUI_PATH'] = '{}/raiden/ui/web/dist/'.format(sys.prefix)
self.flask_app.errorhandler(HTTPStatus.NOT_FOUND)(endpoint_not_found)
if web_ui:
for route in ('/ui/<path:file_name>', '/ui', '/ui/', '/index.html',
'/'):
self.flask_app.add_url_rule(
route,
route,
view_func=self._serve_webui,
methods=('GET', ),
)
def _serve_webui(self, file_name='index.html'): # pylint: disable=redefined-builtin
try:
assert file_name
web3 = self.flask_app.config.get('WEB3_ENDPOINT')
if web3 and 'config.' in file_name and file_name.endswith('.json'):
host = request.headers.get('Host')
if any(h in web3 for h in ('localhost', '127.0.0.1')) and host:
_, _port = split_endpoint(web3)
_host, _ = split_endpoint(host)
web3 = 'http://{}:{}'.format(_host, _port)
response = jsonify({'raiden': self._api_prefix, 'web3': web3})
else:
response = send_from_directory(
self.flask_app.config['WEBUI_PATH'], file_name)
except (NotFound, AssertionError):
response = send_from_directory(self.flask_app.config['WEBUI_PATH'],
'index.html')
return response
def run(self, host='127.0.0.1', port=5001, **kwargs):
self.flask_app.run(host=host, port=port, **kwargs)
def start(self, host='127.0.0.1', port=5001):
self.wsgiserver = WSGIServer((host, port),
self.flask_app,
log=log,
error_log=log)
self.wsgiserver.start()
def stop(self, timeout=5):
if getattr(self, 'wsgiserver', None):
self.wsgiserver.stop(timeout)
self.wsgiserver = None
