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
memory = memory_info(psutil.Process(self.pid))
if config['limit_memory_soft'] and memory > config['limit_memory_soft']:
_logger.warning('LongPolling virtual memory limit reached: %s',
memory)
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
try:
from gevent.pywsgi import WSGIServer
except ImportError:
from gevent.wsgi import WSGIServer
set_limit_memory_hard()
if os.name == 'posix':
# Set process memory limit as an extra safeguard
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()
class ServiceApi:
def __init__(self, pathfinding_service: PathfindingService):
self.flask_app = Flask(__name__)
self.api = ApiWithErrorHandler(self.flask_app)
self.rest_server: WSGIServer = None
self.pathfinding_service = pathfinding_service
resources: List[Tuple[str, Resource, Dict]] = [
('/<token_network_address>/paths', PathsResource, {}),
('/<token_network_address>/payment/iou', IOUResource, {}),
('/info', InfoResource, {}),
]
for endpoint_url, resource, kwargs in resources:
endpoint_url = API_PATH + endpoint_url
kwargs['pathfinding_service'] = pathfinding_service
self.api.add_resource(resource,
endpoint_url,
resource_class_kwargs=kwargs)
def run(self, host: str = DEFAULT_API_HOST, port: int = DEFAULT_API_PORT):
self.rest_server = WSGIServer((host, port), self.flask_app)
self.rest_server.start()
log.info('Running endpoint', endpoint=f'{host}:{port}')
def stop(self):
self.rest_server.stop()
def _run():
from gevent.pywsgi import WSGIServer
server = WSGIServer(('127.0.0.1', 8999), app)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def run_server(instance_dir, address, port, access_log=False):
# workaround on osx, disable kqueue
if sys.platform == "darwin":
os.environ['EVENT_NOKQUEUE'] = "1"
sys.path.insert(0, instance_dir)
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
# This application object is used by any WSGI server configured to use this
# file. This includes Django's development server, if the WSGI_APPLICATION
# setting points here.
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
from gevent import monkey
monkey.patch_all(dns=False)
from gevent.pywsgi import WSGIServer
if access_log:
logfile = 'default'
else:
logfile = file(os.devnull, 'a+')
server = WSGIServer((address, port), application, log=logfile)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
class WebServiceInterface(Interface):
http_port = 80
def __init__(self, *args, **kwargs):
super(WebServiceInterface, self).__init__(*args, **kwargs)
self.wsgi_server = None
def on_start(self):
super(WebServiceInterface, self).on_start()
self.http_socket = create_socket('fd://%s' % self.container.get_shared_socket_fd(self.http_port))
self.wsgi_server = WSGIServer(self.http_socket, Request.application(self.dispatch_request))
self.wsgi_server.start()
def on_stop(self):
self.wsgi_server.stop()
super(WebServiceInterface, self).on_stop()
def dispatch_request(self, request):
trace.set_id()
urls = self.url_map.bind_to_environ(request.environ)
request.urls = urls
try:
endpoint, args = urls.match()
if callable(endpoint):
handler = endpoint(self, request)
response = handler.dispatch(args)
else:
try:
handler = getattr(self, endpoint)
except AttributeError:
raise # FIXME
response = handler(request, **args)
except HTTPException as e:
response = e.get_response(request.environ)
return response
class APIServer():
_api_prefix = '/api/1'
def __init__(self, rest_api: RestAPI, cors_domain_list: List[str] = None) -> None:
flask_app = Flask(__name__)
if cors_domain_list:
CORS(flask_app, origins=cors_domain_list)
blueprint = create_blueprint()
flask_api_context = Api(blueprint, prefix=self._api_prefix)
setup_urls(
flask_api_context=flask_api_context,
rest_api=rest_api,
urls=URLS_V1,
)
self.rest_api = rest_api
self.flask_app = flask_app
self.blueprint = blueprint
self.wsgiserver: Optional[WSGIServer] = None
self.flask_app.register_blueprint(self.blueprint)
self.flask_app.errorhandler(HTTPStatus.NOT_FOUND)(endpoint_not_found)
self.flask_app.register_error_handler(Exception, self.unhandled_exception)
@staticmethod
def unhandled_exception(exception: Exception) -> Response:
""" Flask.errorhandler when an exception wasn't correctly handled """
log.critical(
"Unhandled exception when processing endpoint request",
exc_info=True,
)
return api_response(wrap_in_fail_result(str(exception)), HTTPStatus.INTERNAL_SERVER_ERROR)
def run(self, host: str = '127.0.0.1', port: int = 5042, **kwargs: Any) -> None:
"""This is only used for the data faker and not used in production"""
self.flask_app.run(host=host, port=port, **kwargs)
def start(self, host: str = '127.0.0.1', port: int = 5042) -> None:
"""This is used to start the API server in production"""
wsgi_logger = logging.getLogger(__name__ + '.pywsgi')
self.wsgiserver = WSGIServer(
(host, port),
self.flask_app,
log=wsgi_logger,
error_log=wsgi_logger,
)
msg = f'Rotki API server is running at: {host}:{port}'
print(msg)
log.info(msg)
self.wsgiserver.start()
def stop(self, timeout: int = 5) -> None:
"""Stops the API server. If handlers are running after timeout they are killed"""
if self.wsgiserver is not None:
self.wsgiserver.stop(timeout)
self.wsgiserver = None
self.rest_api.stop()
def run():
from gevent.pywsgi import WSGIServer
http_server = WSGIServer(('', app.config['HTTP_PORT']), app)
if app.config['DEBUG']:
debugModeStr = '''Debug mode enabled!'''
else:
debugModeStr = ''
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...
===========================================================================
Running on '''+app.config['HTTP_HOST']+''':'''+str(app.config['HTTP_PORT'])+'''
'''+debugModeStr+'''
==========================================================================='''
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
print '''
def run_server(options):
api_listener = Api()
gevent.spawn(api_listener.run)
#
# Setup flask app
static_url_path = "/changed-so-it-doesnt-conflict-with-blueprint-static-path"
app = Flask(__name__, static_url_path=static_url_path)
app.config.from_pyfile(options["config"].name)
app.register_blueprint(FrontendBlueprint())
#
# JS/CSS & HTML minification in production
if not app.config.get('DEBUG'):
from .misc.jinja2htmlcompress import HTMLCompress
app.jinja_env.add_extension(HTMLCompress)
assets = Environment()
assets.init_app(app)
#
# Run server
http = WSGIServer((options['http_host'], options['http_port']), app)
LOGGER.info('Listening on %s:%s', options['http_host'],
options['http_port'])
try:
http.serve_forever()
return 0
except KeyboardInterrupt:
http.stop()
api_listener.stop()
LOGGER.info('Application Terminated')
return 0
def main():
parser = argparse.ArgumentParser(prog=PROJECT_NAME,
usage='%(prog)s [options]')
parser.add_argument('--logs_path',
help='logs path (default: {0})'.format(LOGS_PATH),
default=LOGS_PATH)
argv = parser.parse_args()
logging.basicConfig(
filename=argv.logs_path,
level=logging.DEBUG,
format='%(asctime)s.%(msecs)03d [%(levelname)s] %(message)s',
datefmt='%H:%M:%S')
http_server = WSGIServer((servers_manager.host, servers_manager.port),
app,
handler_class=WebSocketHandler)
srv_greenlet = gevent.spawn(http_server.serve_forever)
alarm_greenlet = gevent.spawn(servers_refresh)
try:
gevent.joinall([srv_greenlet, alarm_greenlet])
except KeyboardInterrupt:
servers_manager.stop()
http_server.stop()
def run_server(options):
api_listener = Api()
gevent.spawn(api_listener.run)
#
# Setup flask app
static_url_path = "/changed-so-it-doesnt-conflict-with-blueprint-static-path"
app = Flask(__name__, static_url_path=static_url_path)
app.config.from_pyfile(options["config"].name)
app.register_blueprint(FrontendBlueprint())
#
# JS/CSS & HTML minification in production
if not app.config.get('DEBUG'):
from .misc.jinja2htmlcompress import HTMLCompress
app.jinja_env.add_extension(HTMLCompress)
assets = Environment()
assets.init_app(app)
#
# Run server
http = WSGIServer((options['http_host'], options['http_port']), app)
LOGGER.info('Listening on %s:%s', options['http_host'], options['http_port'])
try:
http.serve_forever()
return 0
except KeyboardInterrupt:
http.stop()
api_listener.stop()
LOGGER.info('Application Terminated')
return 0
def main():
global ENVISALINKCLIENT
parser = argparse.ArgumentParser('Flask powered Alarm Server')
parser.add_argument('config', help='Configurationf file', default='')
args = parser.parse_args()
logger.info('Using configuration file %s' % args.config)
config = AlarmServerConfig(args.config)
# Create Envisalink client object
ENVISALINKCLIENT = Envisalink.Client(config, CONNECTEDCLIENTS)
gevent.spawn(ENVISALINKCLIENT.connect)
app.debug = True
server = WSGIServer(("", 5000), app, keyfile=config.KEYFILE, certfile=config.CERTFILE)
gevent.spawn(publish)
try:
server.serve_forever()
except KeyboardInterrupt:
print "Crtl+C pressed. Shutting down."
logger.info('Shutting down from Ctrl+C')
server.stop()
raise SystemExit
class ApiServer:
healthy = True
conf_map = {}
def __init__(self, confs, max_sequential_errors, port):
self.max_sequential_errors = max_sequential_errors
self.sequential_errors = 0
self.server = WSGIServer(('0.0.0.0', port), flask_app)
self.server_proc = Process(target=lambda: self._serve())
ApiServer.conf_map = dict([(c['project_id'], c) for c in confs])
def start(self):
self.server_proc.start()
def _serve(self):
try:
self.server.serve_forever()
except (KeyboardInterrupt, SystemExit) as e:
self.server.stop()
def stop(self):
self.server_proc.terminate()
self.server_proc.join()
def observe_health(self, success):
if success is True:
self.sequential_errors = 0
else:
self.sequential_errors += 1
if self.sequential_errors > self.max_sequential_errors:
self.healthy = False
else:
self.healthy = True
def _run():
from gevent.pywsgi import WSGIServer
server = WSGIServer(('127.0.0.1', 8999), app)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
class HttpNotificationHandler(BaseNotificationHandler):
server = None
def __init__(self, poa, callback_func, ssl_certs=None):
super(HttpNotificationHandler, self).__init__(poa, callback_func,
ssl_certs)
self.ca_certs = ssl_certs.get('ca_certs')
self.cert_file = ssl_certs.get('cert_file')
self.key_file = ssl_certs.get('key_file')
# TODO(rst): maybe tis needs to be tested when the server is started
if poa.scheme == 'https' and not (self.ca_certs and self.cert_file
and self.key_file):
raise Exception()
def start(self):
from flask import (
Flask,
request,
Response,
)
app = Flask(__name__)
@app.after_request
def attach_headers(response):
response.headers['x-m2m-ri'] = request.headers['x-m2m-ri']
return response
@app.route('/', methods=['POST'])
def index():
assert 'x-m2m-origin' in request.headers, 'No originator set'
assert 'x-m2m-ri' in request.headers, 'Missing request id'
assert 'content-type' in request.headers, 'Unspecified content type'
notification = self._unpack_notification(
get_onem2m_decoder(request.content_type).decode(request.data))
self._callback(request.headers['x-m2m-origin'], **notification)
return Response(headers={
'x-m2m-rsc': 2000,
}, )
if self._endpoint.scheme == 'https':
self.server = WSGIServer(
(self._endpoint.hostname, self._endpoint.port or 6050),
application=app,
keyfile=self.key_file,
certfile=self.cert_file,
ca_certs=self.ca_certs)
else:
self.server = WSGIServer(
(self._endpoint.hostname, self._endpoint.port or 6050),
application=app,
)
spawn(self.server.serve_forever)
def stop(self):
self.server.stop()
class TestExtIPUtil(unittest.TestCase):
def setUp(self):
def application(environ, start_response):
headers = [('Content-Type', 'text/html')]
start_response('200 OK', headers)
return [b'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 = str(
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)
def test_fetch_ext_ip(self):
self.assertIsNotNone(
conpot.utils.ext_ip.get_ext_ip(urls=["https://api.ipify.org"]))
class Server(Greenlet):
def __init__(self, name, addr, *args, **kwargs):
Greenlet.__init__(self)
self._application = Flask(name)
self._server = WSGIServer(addr, self._application, *args, **kwargs)
@self._application.errorhandler(404)
def error_404(error):
log.warning('web handler(%s) not found', request.path)
return str(error), 404
@self._application.errorhandler(Exception)
def error_500(error):
log.exception('web handler(%s) is error(%s)', request.path, error)
return str(error), 500
def _run(self):
self._server.serve_forever()
def close(self):
self._server.stop()
def getServer(self):
return self._server
def getApplication(self):
return self._application
def setHandler(self, handler, url=None, **kwargs):
if not url:
url = '/' + handler.__name__
self._application.route(url, **kwargs)(handler)
def main(config, *args):
'start a webhook server for trello'
app = Flask(__name__)
app.logger.addHandler(logging.StreamHandler(sys.stdout))
with app.app_context():
engine = Engine(config, modules)
http_server = WSGIServer(('', 5000), app)
if not http_server.started:
http_server.start()
pid = gevent.os.fork()
if pid == 0:
_, _, config = cli.parse()
for name, webhook in list(engine.triggers.items()):
if getattr(webhook, 'blueprint', None) and getattr(
webhook, 'register', None):
with app.app_context():
webhook_url = '/'.join(
(config['config'][name]['webhook'], name))
webhook.register(webhook_url)
try:
http_server._stop_event.wait()
finally:
http_server.stop()
def main():
server = WSGIServer(('', port), application)
try:
print("Fishes on %s" % port)
server.serve_forever()
except KeyboardInterrupt:
print(' now sleeping with the fishes')
server.stop()
class RpcAdapterWebSocket(RpcCommAdapter):
def __init__(self, id, ep):
RpcCommAdapter.__init__(self, id, ep)
self.server = None
ep.impl = self
def start(self):
from gevent.pywsgi import WSGIServer
import geventwebsocket
from geventwebsocket.handler import WebSocketHandler
# geventwebsocket.WebSocketServer
# self.server = WSGIServer((self.ep.host,self.ep.port), self._service, handler_class=geventwebsocket.WebSocketHandler)
if self.ep.ssl:
self.server = WSGIServer((self.ep.host, self.ep.port),
self._service,
handler_class=WebSocketHandler,
keyfile=self.ep.keyfile,
certfile=self.ep.certfile)
else:
self.server = WSGIServer((self.ep.host, self.ep.port),
self._service,
handler_class=WebSocketHandler)
print 'websocket server started!'
self.server.start() #.serve_forever()
def stop(self):
self.server.stop()
self.stopmtx.set()
def _http_handler(environ, start_response):
import geventwebsocket
if environ["PATH_INFO"].strip("/") == "version":
start_response("200 OK", [])
agent = "gevent-websocket/%s" % (geventwebsocket.get_version())
return [agent]
else:
start_response("400 Bad Request", [])
return ["WebSocket connection is expected here."]
def _service(self, environ, start_response):
print ' new client websocket come in :' #,str(address)
sock = environ.get("wsgi.websocket")
if sock is None:
return self._http_handler(environ, start_response)
conn = RpcConnectionWebSocket(self, self.ep, sock)
self.addConnection(conn)
server = RpcCommunicator.instance().currentServer()
if server.getPropertyValue('userid_check', 'false') == 'false':
conn.setUserId(self.generateSeq())
conn.recv()
self.removeConnection(conn)
def sendMessage(self, m):
RpcCommAdapter.sendMessage(self, m)
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
try:
from gevent.pywsgi import WSGIServer
except ImportError:
from gevent.wsgi import WSGIServer
if os.name == 'posix':
# Set process memory limit as an extra safeguard
_, hard = resource.getrlimit(resource.RLIMIT_AS)
resource.setrlimit(resource.RLIMIT_AS, (config['limit_memory_hard'], hard))
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()
class WebService(Service):
"""RPC service with Web server capabilities.
"""
def __init__(self, listen_port, handlers, parameters, shard=0,
custom_logger=None, listen_address=""):
Service.__init__(self, shard, custom_logger)
global logger
from cms.io.GeventLibrary import logger as _logger
logger = _logger
self.__responses = {}
# TODO: why are the following two lines needed?
self._RPCRequestHandler__responses = self.__responses
self._RPCAnswerHandler__responses = self.__responses
handlers += [(r"/rpc_request/([a-zA-Z0-9_-]+)/" \
"([0-9]+)/([a-zA-Z0-9_-]+)",
RPCRequestHandler),
(r"/rpc_answer", RPCAnswerHandler),
(r"/sync_rpc_request/([a-zA-Z0-9_-]+)/" \
"([0-9]+)/([a-zA-Z0-9_-]+)",
SyncRPCRequestHandler)]
self.application = tornado.wsgi.WSGIApplication(handlers, **parameters)
self.application.service = self
# is_proxy_used=True means the content of the header X-Real-IP
# is interpreted as the request IP. This means that if we're
# behind a proxy, it can see the real IP the request is coming
# from. But, to use it, we need to be sure we can trust it
# (i.e., if we are not behind a proxy that sets that header,
# we must not use it).
real_application = self.application
if parameters.get('is_proxy_used', False):
real_application = WSGIXheadersMiddleware(real_application)
self.web_server = WSGIServer((listen_address, listen_port),
real_application)
def run(self):
"""Start the WebService.
Both the WSGI server and the RPC server are started.
"""
self.web_server.start()
Service.run(self)
self.web_server.stop()
@rpc_callback
def _default_callback(self, data, plus, error=None):
"""This is the callback for the RPC method called from a web
page, that just collect the response.
"""
self.__responses[plus] = (data, error)
def stop(self, *args, **kwargs):
logger.info("Terminating server and all connected websockets")
for greenlet in self._websockets:
try:
websocket = greenlet._run.im_self
if websocket:
websocket.close(1001, 'Server is shutting down')
except:
pass
_WSGIServer.stop(self, *args, **kwargs)
def run_gevent(app, host='127.0.0.1', port=8000, *args, **kwargs):
from gevent.pywsgi 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 stop(self, *args, **kwargs):
logger.info("Terminating server and all connected websockets")
for greenlet in self._websockets:
try:
websocket = greenlet._run.im_self
if websocket:
websocket.close(1001, 'Server is shutting down')
except:
pass
_WSGIServer.stop(self, *args, **kwargs)
class RpcAdapterWebSocket(RpcCommAdapter):
def __init__(self,id,ep):
RpcCommAdapter.__init__(self,id,ep)
self.server = None
ep.impl = self
def start(self):
from gevent.pywsgi import WSGIServer
import geventwebsocket
from geventwebsocket.handler import WebSocketHandler
# geventwebsocket.WebSocketServer
# self.server = WSGIServer((self.ep.host,self.ep.port), self._service, handler_class=geventwebsocket.WebSocketHandler)
if self.ep.ssl:
self.server = WSGIServer((self.ep.host,self.ep.port), self._service, handler_class=WebSocketHandler,keyfile=self.ep.keyfile,certfile=self.ep.certfile)
else:
self.server = WSGIServer((self.ep.host,self.ep.port), self._service, handler_class=WebSocketHandler)
print 'websocket server started!'
self.server.start() #.serve_forever()
def stop(self):
self.server.stop()
self.stopmtx.set()
def _http_handler(environ, start_response):
import geventwebsocket
if environ["PATH_INFO"].strip("/") == "version":
start_response("200 OK", [])
agent = "gevent-websocket/%s" % (geventwebsocket.get_version())
return [agent]
else:
start_response("400 Bad Request", [])
return ["WebSocket connection is expected here."]
def _service(self,environ, start_response):
from communicator import RpcCommunicator
print ' new client websocket come in :'#,str(address)
sock = environ.get("wsgi.websocket")
if sock is None:
return self._http_handler(environ, start_response)
conn = RpcConnectionWebSocket(self,self.ep,sock)
self.addConnection(conn)
server = RpcCommunicator.instance().currentServer()
if server.getPropertyValue('userid_check','false') == 'false':
conn.setUserId( str(self.generateSeq()) )
conn.recv()
self.removeConnection(conn)
def sendMessage(self,m):
RpcCommAdapter.sendMessage(self,m)
class server_class():
__name = "[Flask Server]"
def __init__(self, threadID, name, client, delivery, delman):
self.name = name
self.client_obj = client
self.delivery_obj = delivery
self.delman_obj = delman
self.http_server = None
self.thread_server = None
def run(self):
# Weird Fix
monkey.patch_all()
app = Flask(__name__)
self.http_server = WSGIServer(("0.0.0.0", 80), app)
self.thread_server = threading.Thread(
target=self.http_server.serve_forever)
# Routes
@app.route('/', methods=['GET', 'POST'])
def hermes_index():
return render_template('index.html',
request=request,
delivery_obj=self.delivery_obj,
client_obj=self.client_obj)
@app.route('/newclient', methods=['GET', 'POST'])
def new_client_page():
return render_template('newclient.html',
request=request,
client_obj=self.client_obj)
@app.route('/newdelivery', methods=['GET', 'POST'])
def new_delivery_page():
return render_template('newdelivery.html',
request=request,
delivery_obj=self.delivery_obj)
@app.route('/newdeliveryman', methods=['GET', 'POST'])
def new_deliveryman_page():
return render_template('newdeliveryman.html',
request=request,
delman_obj=self.delman_obj)
self.thread_server.start()
def stop(self):
self.http_server.stop()
self.thread_server.join()
class WebService(Service):
"""RPC service with Web server capabilities.
"""
def __init__(self, listen_port, handlers, parameters, shard=0,
listen_address=""):
Service.__init__(self, shard)
self.__responses = {}
# TODO: why are the following two lines needed?
self._RPCRequestHandler__responses = self.__responses
self._RPCAnswerHandler__responses = self.__responses
handlers += [(r"/rpc_request/([a-zA-Z0-9_-]+)/"
"([0-9]+)/([a-zA-Z0-9_-]+)",
RPCRequestHandler),
(r"/rpc_answer", RPCAnswerHandler),
(r"/sync_rpc_request/([a-zA-Z0-9_-]+)/"
"([0-9]+)/([a-zA-Z0-9_-]+)",
SyncRPCRequestHandler)]
self.application = tornado.wsgi.WSGIApplication(handlers, **parameters)
self.application.service = self
# is_proxy_used=True means the content of the header X-Real-IP
# is interpreted as the request IP. This means that if we're
# behind a proxy, it can see the real IP the request is coming
# from. But, to use it, we need to be sure we can trust it
# (i.e., if we are not behind a proxy that sets that header,
# we must not use it).
real_application = self.application
if parameters.get('is_proxy_used', False):
real_application = WSGIXheadersMiddleware(real_application)
self.web_server = WSGIServer((listen_address, listen_port),
real_application)
def run(self):
"""Start the WebService.
Both the WSGI server and the RPC server are started.
"""
self.web_server.start()
Service.run(self)
self.web_server.stop()
@rpc_callback
def _default_callback(self, data, plus, error=None):
"""This is the callback for the RPC method called from a web
page, that just collect the response.
"""
self.__responses[plus] = (data, error)
class Server(threading.Thread):
def __init__(self, port):
threading.Thread.__init__(self)
self.port = port if port else 9090
def run(self):
if DEBUG: print("_testServer: running on port %d" % self.port)
self.server = WSGIServer(("0.0.0.0", self.port), app)
self.server.serve_forever()
def stop(self):
self.server.stop()
def run(self):
# Array since we need to pass by ref
last_task_complete = [time()]
last_maintenance_complete = time()
active_upload_counter = ThreadsafeCounter()
task_queue = TaskQueue()
logging.info("Starting server on %d...", self._port)
logging.debug("Task completed callback %s", last_task_complete)
def completed_callback(last_task_complete):
logging.debug("Task completed callback %s", last_task_complete)
last_task_complete[:] = [time()]
workers = WorkerPoolExecutor(
partial(completed_callback, last_task_complete))
workers.start(task_queue, self._workers)
remote_push_adapter_map, users, do_maintenance = self.parse_config()
webapp = UploadWebApp(__name__, users, self._managed_repos,
active_upload_counter, remote_push_adapter_map,
task_queue)
http_server = WSGIServer(('', self._port), webapp)
http_server.start()
logging.info("Server started on %s", self._port)
# loop until interrupted
while True:
try:
gsleep(5)
task_queue.join()
logging.debug("Task queue empty, %s uploads ongoing",
str(active_upload_counter.count))
# Continue looping if maintenance not desired
if do_maintenance:
last_maintenance_complete = self.perform_maintenance(
workers, task_queue, last_maintenance_complete,
last_task_complete)
except (KeyboardInterrupt, SystemExit):
break
logging.info("Cleaning up resources...")
http_server.stop()
workers.stop()
def main():
from gevent.pywsgi import WSGIServer
s = WSGIServer(('', 45678), app)
try:
s.serve_forever()
except KeyboardInterrupt:
pass
except Exception as e:
print('Unexpected exception:', e)
finally:
print('Stopping login server...')
s.stop()
def main():
from gevent.pywsgi import WSGIServer
s = WSGIServer(('', 45678), app)
try:
s.serve_forever()
except KeyboardInterrupt:
pass
except Exception as e:
print('Unexpected exception:', e)
finally:
print('Stopping login server...')
s.stop()
class HttpServer(Actor):
def pre_start(self, address, responders, default_content_type='text/html'):
self.responders = responders
self.default_content_type = default_content_type
self.server = WSGIServer(address, self.handle_wsgi_request)
self.server.start()
def post_stop(self):
self.server.stop()
def handle_wsgi_request(self, env, start_response):
ch = Channel()
req = Request(ch,
env,
start_response,
content_type=self.default_content_type)
self << ('handle', req)
return response_stream(ch)
def receive(self, msg):
if ('handle', ANY) == msg:
_, req = msg
try:
responder = self.get_responder(req.env['PATH_INFO'])
if responder:
responder, args, kwargs = responder
self.spawn(
RequestHandler.using(req, responder, args, kwargs))
else:
req.start_response('404 Not Found',
[('Content-Type', 'text/html')])
req.write('<h1>404 Not Found</h1>\n')
req.write(
'The page you tried to reach could not be found.\n')
req.close()
except:
_send_500(req)
raise
elif 'get-addr' == msg:
self.reply(self.server.address)
else:
raise Unhandled
def get_responder(self, path):
for pattern, responder in self.responders:
m = re.compile(pattern).match(path)
if m:
args = m.groups()
kwargs = m.groupdict()
return responder, args if not kwargs else (), kwargs
class MSApi:
def __init__(
self,
monitoring_service: MonitoringService,
operator: str,
info_message: str = DEFAULT_INFO_MESSAGE,
) -> None:
flask_app = Flask(__name__)
self.api = ApiWithErrorHandler(flask_app)
# Add the metrics prometheus app
self.flask_app = DispatcherMiddleware(
NotFound(),
{
"/metrics": make_wsgi_app(registry=metrics.REGISTRY),
API_PATH: flask_app.wsgi_app,
},
)
self.rest_server: Optional[WSGIServer] = None
self.monitoring_service = monitoring_service
self.operator = operator
self.info_message = info_message
resources: List[Tuple[str, Resource, str]] = [
("/v1/info", cast(Resource, InfoResource), "info"),
("/v2/info", cast(Resource, InfoResource2), "info2"),
]
for endpoint_url, resource, endpoint in resources:
self.api.add_resource(
resource,
endpoint_url,
resource_class_kwargs={
"monitoring_service": monitoring_service,
"api": self
},
endpoint=endpoint,
)
def run(self, host: str, port: int) -> None:
self.rest_server = WSGIServer((host, port), self.flask_app)
self.rest_server.start()
log.info("Running endpoint", endpoint=f"http://{host}:{port}")
def stop(self) -> None:
if self.rest_server:
self.rest_server.stop()
class VisualizationServerBase:
def __init__(self, server_port=9999, server_ip="0.0.0.0", **kwargs):
self._server_port = server_port
self._server_ip = server_ip
self._wsgi_server = None
self._flask_app = None
self._server_thread = None
def _start_server(self):
self._flask_app = self._get_flask_app()
self._wsgi_server = WSGIServer((self._server_ip, self._server_port),
self._flask_app)
self._wsgi_server.serve_forever()
def start_web_server(self):
"""
Start a web server in a separate thead.
Note:
The tracing server keeps track of session runs even without a running web server.
"""
if not self._server_thread:
self._server_thread = threading.Thread(target=self._start_server)
self._server_thread.start()
tf.logging.warn("Tracing Server: http://{}:{}/".format(
self._server_ip, self._server_port))
def stop_web_server(self):
"""
Stop the web server.
Note:
The tracing server keeps track of session runs even after the web server is stopped.
"""
if self._wsgi_server.started:
self._wsgi_server.stop()
if threading.current_thread() != self._server_thread:
self._server_thread.join()
self._server_thread = None
def join(self):
"""
Wait until the web server is stopped.
"""
if self._wsgi_server.started:
self._server_thread.join()
def _get_flask_app(self):
raise NotImplemented
class ServerThread(threading.Thread):
def __init__(self, app, port=5005):
self.port = port
threading.Thread.__init__(self)
self.srv = WSGIServer(("0.0.0.0", self.port), app)
self.ctx = app.app_context()
self.ctx.push()
def run(self):
logging.info('Starting threaded server.')
self.srv.serve_forever()
def shutdown(self):
logging.info('Stopping threaded server.')
self.srv.stop()
def test_do_upload_to_tender_with_retry_fail_then_success(self):
api_server_bottle = Bottle()
api_server = WSGIServer(('127.0.0.1', 20604),
api_server_bottle,
log=None)
setup_routing(api_server_bottle, response_spore)
api_server.start()
self.worker.client = TendersClientSync(
'', host_url='http://127.0.0.1:20604', api_version='2.3')
setup_routing(api_server_bottle,
generate_response_retry,
path='/api/2.3/tenders/{}/awards/{}/documents'.format(
self.tender_id, self.award_id),
method='POST')
self.worker.do_upload_to_tender_with_retry(self.data)
api_server.stop()
def test_do_upload_to_tender_failure(self):
api_server_bottle = Bottle()
api_server = WSGIServer(('127.0.0.1', 20604),
api_server_bottle,
log=None)
setup_routing(api_server_bottle, response_spore)
api_server.start()
self.worker.client = TendersClientSync(
'', host_url='http://127.0.0.1:20604', api_version='2.3')
setup_routing(api_server_bottle,
response_412,
path='/api/2.3/tenders/{}/awards/{}/documents'.format(
self.tender_id, self.award_id),
method='POST')
with self.assertRaises(ResourceError):
self.worker.do_upload_to_tender(self.data)
api_server.stop()
class Web(object):
"""
Dissonance's WSGI server. Routes requests to their appropriate module. See `dissonance.module.Module.app`
for more details.
"""
_url_map = Map([
Rule('/<module>/', endpoint='module', defaults={'rest': ''}),
Rule('/<module>/<path:rest>', endpoint='module')
])
def __init__(self, client, opts):
self._client = client
self._opts = opts
self._bind_addr = self._opts['listen_host'], int(
self._opts['listen_port'])
self._server = WSGIServer(self._bind_addr, self._wsgi_app)
def _wsgi_app(self, environ, start_response):
urls = self._url_map.bind_to_environ(environ)
try:
endpoint, args = urls.match()
handler = getattr(self, '_handle_%s' % endpoint)
return handler(args, environ, start_response)
except HTTPException as e:
return e(environ, start_response)
def _handle_module(self, args, environ, start_response):
module = self._client.modules.get_module(args['module'])
if module and module.is_web:
original_script_name = environ.get('SCRIPT_NAME', '')
environ[
'SCRIPT_NAME'] = original_script_name + '/' + args['module']
environ['PATH_INFO'] = args['rest']
return module.app(environ, start_response)
return NotFound()(environ, start_response)
def start(self):
logger.info("Starting web server on %s:%s", *self._bind_addr)
self._server.start()
def stop(self):
logger.info("Stopping web server on %s:%s", *self._bind_addr)
self._server.stop()
class Engine(BaseEngine, Signaler):
#
# 引擎本身只需实现 BaseEngine 接口，信号处理属于额外增强功能。
# 子进程创建、退出都属于系统信号范畴，统一由 Singaler 处理。
#
def __init__(self, server):
self._server = server
self._pool = ThreadPool(CPUS * 4)
self._listen_sock = None
self._wsgi_server = None
BaseEngine.__init__(self, server)
Signaler.__init__(self)
def run(self):
from engine.config import HOST, PORT
self._listen_sock = socket(family=AF_INET)
self._listen_sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self._listen_sock.bind((HOST, PORT))
self._listen_sock.listen(2048)
self._listen_sock.setblocking(0)
self.fork_workers(WORKERS or CPUS + 1)
self.parent_execute()
def fork_workers(self, num):
for i in range(num):
if fork() == 0:
self.worker_execute()
exit(0)
def worker_execute(self):
Signaler.worker_execute(self)
# 启动服务器。
kwargs = HTTPS and \
{k: app_path("ssl/" + v) for k, v in (("keyfile", HTTPS_KEY), ("certfile", HTTPS_CERT))} or \
{}
self._wsgi_server = WSGIServer(self._listen_sock, self._server.execute, log=None, **kwargs)
self._wsgi_server.serve_forever()
# 等待所有处理结束，超时 10 秒。
hasattr(self._wsgi_server, "__graceful__") and gwait(timeout=10)
def worker_stop(self, graceful):
stop = lambda *args: self._wsgi_server and self._wsgi_server.stop()
graceful and (setattr(self._wsgi_server, "__graceful__", True), stop()) or stop()
def async_execute(self, func, *args, **kwargs):
e = Event()
g = self._pool.apply_async(func, args, kwargs, callback=lambda ret: e.set())
e.wait()
return g.get()
class Frontend(object):
def start(self, start_wsgi_server=False, forever=False):
"""
Start the frontend's greenlets.
If *start_wsgi_server* is True, also create the frontend's main WSGI
application and serve it with gevent's WSGI server.
"""
# Start the frontend WSGI server if requested
if start_wsgi_server:
wsgi_app = self.create_wsgi_app({
'pyramid.debug_authorization': 'true',
'pyramid.debug_routematch': 'true',
'pyramid.reload_templates': 'true',
'pyramid.debug_notfound': 'true'
})
logfile = open("/tmp/jarvis.log", "w")
self.wsgi_server = WSGIServer(("127.0.0.1", 9017),
wsgi_app,
log=logfile)
if forever:
self.wsgi_server.serve_forever()
else:
self.wsgi_server.start()
else:
self.wsgi_server = None
def stop(self):
if self.wsgi_server is not None:
self.wsgi_server.stop()
def create_wsgi_app(self, settings):
# Create applincation
config = Configurator(settings=settings)
config.add_route('state_update', '/state/update/{id}/')
config.add_route('state_stream_json',
'/state/stream/json/{session_id}/')
config.add_route('state_stream_eventsource',
'/state/stream/eventsource/{session_id}/')
static_path = op.join(op.dirname(__file__), "media")
config.add_static_view(name='static', path=static_path)
config.scan()
return config.make_wsgi_app()
class WebService(Service):
"""RPC service with Web server capabilities.
"""
def __init__(self, listen_port, handlers, parameters, shard=0,
listen_address=""):
super(WebService, self).__init__(shard)
static_files = parameters.pop('static_files', [])
rpc_enabled = parameters.pop('rpc_enabled', False)
is_proxy_used = parameters.pop('is_proxy_used', False)
self.wsgi_app = tornado.wsgi.WSGIApplication(handlers, **parameters)
self.wsgi_app.service = self
for entry in static_files:
self.wsgi_app = SharedDataMiddleware(
self.wsgi_app, {"/static": entry})
if rpc_enabled:
self.wsgi_app = DispatcherMiddleware(
self.wsgi_app, {"/rpc": RPCMiddleware(self)})
# If is_proxy_used is set to True we'll use the content of the
# X-Forwarded-For HTTP header (if provided) to determine the
# client IP address, ignoring the one the request came from.
# This allows to use the IP lock behind a proxy. Activate it
# only if all requests come from a trusted source (if clients
# were allowed to directlty communicate with the server they
# could fake their IP and compromise the security of IP lock).
if is_proxy_used:
self.wsgi_app = ProxyFix(self.wsgi_app)
self.web_server = WSGIServer((listen_address, listen_port),
self.wsgi_app)
def run(self):
"""Start the WebService.
Both the WSGI server and the RPC server are started.
"""
self.web_server.start()
Service.run(self)
self.web_server.stop()
class HttpServer(Actor):
def pre_start(self, address, responders, default_content_type='text/html'):
self.responders = responders
self.default_content_type = default_content_type
self.server = WSGIServer(address, self.handle_wsgi_request)
self.server.start()
def post_stop(self):
self.server.stop()
def handle_wsgi_request(self, env, start_response):
ch = Channel()
req = Request(ch, env, start_response, content_type=self.default_content_type)
self << ('handle', req)
return response_stream(ch)
def receive(self, msg):
if ('handle', ANY) == msg:
_, req = msg
try:
responder = self.get_responder(req.env['PATH_INFO'])
if responder:
responder, args, kwargs = responder
self.spawn(RequestHandler.using(req, responder, args, kwargs))
else:
req.start_response('404 Not Found', [('Content-Type', 'text/html')])
req.write('<h1>404 Not Found</h1>\n')
req.write('The page you tried to reach could not be found.\n')
req.close()
except:
_send_500(req)
raise
elif 'get-addr' == msg:
self.reply(self.server.address)
else:
raise Unhandled
def get_responder(self, path):
for pattern, responder in self.responders:
m = re.compile(pattern).match(path)
if m:
args = m.groups()
kwargs = m.groupdict()
return responder, args if not kwargs else (), kwargs
class EmbargoServer(threading.Thread):
def __init__(self, host: str = 'localhost', port: int = 7777):
super().__init__(daemon=True)
self._host = host
self._port = port
self._server = None
def run(self) -> None:
self._server = WSGIServer((self._host, self._port), server_app)
self._server.serve_forever()
def stop(self) -> None:
if self._server is None:
return
self._server.stop()
self._server.close()
class Web(object):
"""
Dissonance's WSGI server. Routes requests to their appropriate module. See `dissonance.module.Module.app`
for more details.
"""
_url_map = Map([
Rule('/<module>/', endpoint='module', defaults={'rest': ''}),
Rule('/<module>/<path:rest>', endpoint='module')
])
def __init__(self, client, opts):
self._client = client
self._opts = opts
self._bind_addr = self._opts['listen_host'], int(self._opts['listen_port'])
self._server = WSGIServer(self._bind_addr, self._wsgi_app)
def _wsgi_app(self, environ, start_response):
urls = self._url_map.bind_to_environ(environ)
try:
endpoint, args = urls.match()
handler = getattr(self, '_handle_%s' % endpoint)
return handler(args, environ, start_response)
except HTTPException as e:
return e(environ, start_response)
def _handle_module(self, args, environ, start_response):
module = self._client.modules.get_module(args['module'])
if module and module.is_web:
original_script_name = environ.get('SCRIPT_NAME', '')
environ['SCRIPT_NAME'] = original_script_name + '/' + args['module']
environ['PATH_INFO'] = args['rest']
return module.app(environ, start_response)
return NotFound()(environ, start_response)
def start(self):
logger.info("Starting web server on %s:%s", *self._bind_addr)
self._server.start()
def stop(self):
logger.info("Stopping web server on %s:%s", *self._bind_addr)
self._server.stop()
class WebServerTimeout():
def __init__(self):
self.q = Queue()
self.wsgi = WSGIServer(('', 8088), self.application, log=None)
def application(self, env, start_response):
sleep(10)
start_response('200 OK', [('Content-Type', 'text/html')])
i = env["wsgi.input"].readlines()
env["wsgi.input"] = i
self.q.put(env)
yield '{"message": "hello world!"}'
def start(self):
spawn(self.wsgi.start)
def stop(self):
self.wsgi.stop()
class Frontend(object):
def start(self, start_wsgi_server=False, forever=False):
"""
Start the frontend's greenlets.
If *start_wsgi_server* is True, also create the frontend's main WSGI
application and serve it with gevent's WSGI server.
"""
# Start the frontend WSGI server if requested
if start_wsgi_server:
wsgi_app = self.create_wsgi_app(
{
"pyramid.debug_authorization": "true",
"pyramid.debug_routematch": "true",
"pyramid.reload_templates": "true",
"pyramid.debug_notfound": "true",
}
)
logfile = open("/tmp/jarvis.log", "w")
self.wsgi_server = WSGIServer(("127.0.0.1", 9017), wsgi_app, log=logfile)
if forever:
self.wsgi_server.serve_forever()
else:
self.wsgi_server.start()
else:
self.wsgi_server = None
def stop(self):
if self.wsgi_server is not None:
self.wsgi_server.stop()
def create_wsgi_app(self, settings):
# Create applincation
config = Configurator(settings=settings)
config.add_route("state_update", "/state/update/{id}/")
config.add_route("state_stream_json", "/state/stream/json/{session_id}/")
config.add_route("state_stream_eventsource", "/state/stream/eventsource/{session_id}/")
static_path = op.join(op.dirname(__file__), "media")
config.add_static_view(name="static", path=static_path)
config.scan()
return config.make_wsgi_app()
class ContractingUserTestCase(unittest.TestCase):
""""""
def setUp(self):
#self._testMethodName
self.app = Bottle()
setup_routing(self.app)
self.server = WSGIServer(('localhost', 20602), self.app, log=None)
self.server.start()
self.client = ContractingClient(API_KEY, host_url=HOST_URL,
api_version=API_VERSION)
with open(ROOT + 'contract_' + TEST_CONTRACT_KEYS.contract_id + '.json') as contract:
self.contract = munchify(load(contract))
self.contract.update({'access':{"token": API_KEY}})
def tearDown(self):
self.server.stop()
###########################################################################
# CREATE ITEM TEST
###########################################################################
def test_create_contract(self):
setup_routing(self.app, routs=["contract_create"])
contract = munchify({'data': 'contract'})
self.client.create_contract(contract)
###########################################################################
# DOCUMENTS FILE TEST
###########################################################################
def test_upload_contract_document(self):
setup_routing(self.app, routs=["contract_document_create"])
file_ = StringIO()
file_.name = 'test_document.txt'
file_.write("test upload contract document text data")
file_.seek(0)
doc = self.client.upload_document(file_, self.contract)
self.assertEqual(doc.data.title, file_.name)
self.assertEqual(doc.data.id, TEST_CONTRACT_KEYS.new_document_id)
file_.close()
class HTTPProxyServer(object):
def __init__(self, ip, port, app, log='default'):
self.ip = ip
self.port = port
self.app = app
self.server = WSGIServer((self.ip, self.port), log=log,
application=self.app.application, spawn=Pool(500), handler_class=ProxyHandler)
def start(self):
self.server.start()
def run(self):
self.server.serve_forever()
def stop(self):
self.server.stop()
@property
def closed(self):
return self.server.closed
class ViewerTenderTestCase(unittest.TestCase):
""""""
def setUp(self):
#self._testMethodName
self.app = Bottle()
setup_routing(self.app)
self.server = WSGIServer(('localhost', 20602), self.app, log=None)
self.server.start()
self.client = tender_client.TendersClient('', host_url=HOST_URL, api_version=API_VERSION)
with open(ROOT + 'tenders.json') as tenders:
self.tenders = munchify(load(tenders))
with open(ROOT + TEST_KEYS.tender_id + '.json') as tender:
self.tender = munchify(load(tender))
def tearDown(self):
self.server.stop()
def test_get_tenders(self):
setup_routing(self.app, routs=["tenders"])
tenders = self.client.get_tenders()
self.assertIsInstance(tenders, Iterable)
self.assertEqual(tenders, self.tenders.data)
def test_get_tender(self):
setup_routing(self.app, routs=["tender"])
tender = self.client.get_tender(TEST_KEYS.tender_id)
self.assertEqual(tender, self.tender)
def test_get_tender_location_error(self):
setup_routing(self.app, routs=["tender"])
tender = self.client.get_tender(TEST_KEYS.error_id)
self.assertEqual(tender, munchify(loads(location_error('tender'))))
def test_offset_error(self):
setup_routing(self.app, routs=['offset_error'])
tenders = self.client.get_tenders()
self.assertIsInstance(tenders, Iterable)
self.assertEqual(tenders, self.tenders.data)
def run(self, handler):
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler
self.options['log'] = None if self.quiet else 'default'
self.options['handler_class'] = WebSocketHandler
address = (self.host, self.port)
server = WSGIServer(address, handler, **self.options)
if 'BOTTLE_CHILD' in os.environ:
import signal
signal.signal(signal.SIGINT, lambda s, f: server.stop())
server.serve_forever()
def run(self):
# initialize server configuration
self._ct.start()
run_logger.info('initial config success')
# start to request remote server for getting forwarding data
self._rt.start()
# Start http server
httpd = WSGIServer((self._ct.host, self._ct.port), self.data)
try:
httpd.serve_forever()
run_logger.info("Server Started - %s:%s" % (self._ct.host, self._ct.port))
except KeyboardInterrupt:
pass
# Stop http server only in debug mode
httpd.stop()
self._rt.stop()
self._ct.stop()
run_logger.info("Server Stopped - %s:%s" % (self._ct.host, self._ct.host))
class ViewerPlanTestCase(unittest.TestCase):
""""""
def setUp(self):
self.app = Bottle()
setup_routing(self.app)
self.server = WSGIServer(('localhost', 20602), self.app, log=None)
self.server.start()
self.client = plan_client.PlansClient('', host_url=HOST_URL, api_version=API_VERSION)
with open(ROOT + 'plans.json') as plans:
self.plans = munchify(load(plans))
with open(ROOT + 'plan_' + TEST_PLAN_KEYS.plan_id + '.json') as plan:
self.plan = munchify(load(plan))
def tearDown(self):
self.server.stop()
def test_get_plans(self):
setup_routing(self.app, routs=["plans"])
plans = self.client.get_plans()
self.assertIsInstance(plans, Iterable)
self.assertEqual(plans, self.plans.data)
def test_get_plan(self):
setup_routing(self.app, routs=["plan"])
plan = self.client.get_plan(TEST_PLAN_KEYS.plan_id)
self.assertEqual(plan, self.plan)
def test_get_plan_location_error(self):
setup_routing(self.app, routs=["plan"])
tender = self.client.get_plan(TEST_PLAN_KEYS.error_id)
self.assertEqual(tender, munchify(loads(location_error('plan'))))
def test_offset_error(self):
setup_routing(self.app, routs=['plan_offset_error'])
plans = self.client.get_plans()
self.assertIsInstance(plans, Iterable)
self.assertEqual(plans, self.plans.data)
class TestExtIPUtil(unittest.TestCase):
def setUp(self):
def application(environ, start_response):
headers = [('Content-Type', 'text/html')]
start_response('200 OK', headers)
return [b'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 = str(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)
def test_fetch_ext_ip(self):
self.assertIsNotNone(conpot.utils.ext_ip.get_ext_ip(urls=["https://api.ipify.org"]))
class PostMocker(object):
def __init__(self, collection, port):
self.server_greenlet = None
self.collection = collection
self.server = None
self.port = port
self.builder = AppBuilder(collection)
self.app = None
def start(self):
self.app = self.builder.build_app()
self.server = WSGIServer(('', self.port), self.app, handler_class=LoggingWSGIHandler)
self.server_greenlet = gevent.spawn(self.server.serve_forever)
while self.server.server_port == 0:
gevent.sleep(0) # Wait until the server has started
logger.info('PostMocker listening on port: %s', self.server.server_port)
return self.server_greenlet
def stop(self):
logger.info('Stopping')
self.server.stop()
def stop(self, *args, **kwargs):
self.pool.clear()
_WSGIServer.stop(self, *args, **kwargs)
class WebService(Service):
"""RPC service with Web server capabilities.
"""
def __init__(self, listen_port, handlers, parameters, shard=0,
listen_address=""):
super(WebService, self).__init__(shard)
static_files = parameters.pop('static_files', [])
rpc_enabled = parameters.pop('rpc_enabled', False)
rpc_auth = parameters.pop('rpc_auth', None)
auth_middleware = parameters.pop('auth_middleware', None)
is_proxy_used = parameters.pop('is_proxy_used', None)
num_proxies_used = parameters.pop('num_proxies_used', None)
self.wsgi_app = tornado.wsgi.WSGIApplication(handlers, **parameters)
self.wsgi_app.service = self
for entry in static_files:
self.wsgi_app = SharedDataMiddleware(
self.wsgi_app, {"/static": entry})
if rpc_enabled:
self.wsgi_app = DispatcherMiddleware(
self.wsgi_app, {"/rpc": RPCMiddleware(self, rpc_auth)})
# The authentication middleware needs to be applied before the
# ProxyFix as otherwise the remote address it gets is the one
# of the proxy.
if auth_middleware is not None:
self.wsgi_app = auth_middleware(self.wsgi_app)
self.auth_handler = self.wsgi_app
# If we are behind one or more proxies, we'll use the content
# of the X-Forwarded-For HTTP header (if provided) to determine
# the client IP address, ignoring the one the request came from.
# This allows to use the IP lock behind a proxy. Activate it
# only if all requests come from a trusted source (if clients
# were allowed to directlty communicate with the server they
# could fake their IP and compromise the security of IP lock).
if num_proxies_used is None:
if is_proxy_used:
num_proxies_used = 1
else:
num_proxies_used = 0
if num_proxies_used > 0:
self.wsgi_app = ProxyFix(self.wsgi_app, num_proxies_used)
self.web_server = WSGIServer((listen_address, listen_port),
self.wsgi_app)
def run(self):
"""Start the WebService.
Both the WSGI server and the RPC server are started.
"""
self.web_server.start()
Service.run(self)
self.web_server.stop()
class WebService(Service):
"""RPC service with Web server capabilities.
"""
def __init__(self, listen_port, handlers, parameters, shard=0,
listen_address=""):
super(WebService, self).__init__(shard)
static_files = parameters.pop('static_files', [])
rpc_enabled = parameters.pop('rpc_enabled', False)
rpc_auth = parameters.pop('rpc_auth', None)
auth_middleware = parameters.pop('auth_middleware', None)
is_proxy_used = parameters.pop('is_proxy_used', None)
num_proxies_used = parameters.pop('num_proxies_used', None)
self.wsgi_app = tornado.wsgi.WSGIApplication(handlers, **parameters)
self.wsgi_app.service = self
for entry in static_files:
# TODO If we will introduce a flag to trigger autoreload in
# Jinja2 templates, use it to disable the cache arg here.
self.wsgi_app = SharedDataMiddleware(
self.wsgi_app, {"/static": entry},
cache=True, cache_timeout=SECONDS_IN_A_YEAR,
fallback_mimetype="application/octet-stream")
self.file_cacher = FileCacher(self)
self.wsgi_app = FileServerMiddleware(self.file_cacher, self.wsgi_app)
if rpc_enabled:
self.wsgi_app = DispatcherMiddleware(
self.wsgi_app, {"/rpc": RPCMiddleware(self, rpc_auth)})
# The authentication middleware needs to be applied before the
# ProxyFix as otherwise the remote address it gets is the one
# of the proxy.
if auth_middleware is not None:
self.wsgi_app = auth_middleware(self.wsgi_app)
self.auth_handler = self.wsgi_app
# If we are behind one or more proxies, we'll use the content
# of the X-Forwarded-For HTTP header (if provided) to determine
# the client IP address, ignoring the one the request came from.
# This allows to use the IP lock behind a proxy. Activate it
# only if all requests come from a trusted source (if clients
# were allowed to directlty communicate with the server they
# could fake their IP and compromise the security of IP lock).
if num_proxies_used is None:
if is_proxy_used:
num_proxies_used = 1
else:
num_proxies_used = 0
if num_proxies_used > 0:
self.wsgi_app = ProxyFix(self.wsgi_app, num_proxies_used)
self.web_server = WSGIServer((listen_address, listen_port), self)
def __call__(self, environ, start_response):
"""Execute this instance as a WSGI application.
See the PEP for the meaning of parameters. The separation of
__call__ and wsgi_app eases the insertion of middlewares.
"""
return self.wsgi_app(environ, start_response)
def run(self):
"""Start the WebService.
Both the WSGI server and the RPC server are started.
"""
self.web_server.start()
Service.run(self)
self.web_server.stop()
