def __init__(self, server_address, builder):
self.builder = builder
handler_class = BuildRequestHandler
if PY2:
HTTPServer.__init__(self, server_address, handler_class)
else:
super().__init__(server_address, handler_class)
def __init__(self, index_path, config=dict()):
self.index_path = index_path
self.server_port = config.get('server_port', 8000)
SimilaritySearchServer.config = config
server_address = ('', self.server_port)
HTTPServer.__init__(self, server_address, RequestHandler)
def __init__(self, server_address, request_handler_class, \
bind_and_activate=True, handler_params = []):
HTTPServer.__init__(self, server_address, request_handler_class, \
bind_and_activate)
self.address = server_address
self.handler_params = handler_params
self.stop = False
### SSL specific
ssl_certificate = self.handler_params[0].ssl_certificate
#if 1 == 1:
try:
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file (ssl_certificate)
ctx.use_certificate_file(ssl_certificate)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
self.socket_type))
except:
error = "SSL error : %s. Did you generate certificate ?" % self.handler_params[0].get_exception()
print(error)
self.handler_params[0].log.error(error)
# force exiting
self.handler_params[0].force_leave()
return
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
HTTPServer.__init__(self, server_address, HandlerClass)
print 'In init!'
self.macToLL={}
self.AddMacFile()
self.locator = locator.Locator()
self.locator.Init()
def __init__(self, host, port, app, handler=None, passthrough_errors=False, ssl_context=None):
if handler is None:
handler = WSGIRequestHandler
self.address_family = select_address_family(host, port)
port = port or 0
bind_to = (host, port)
if self.address_family is socket.AF_UNIX:
if host.startswith("unix://"):
bind_to = host.partition("unix://")[-1]
else:
bind_to = host
HTTPServer.__init__(self, bind_to, handler)
self.app = app
self.passthrough_errors = passthrough_errors
self.shutdown_signal = False
if ssl_context is not None:
try:
from OpenSSL import tsafe
except ImportError:
raise TypeError("SSL is not available if the OpenSSL " "library is not installed.")
if isinstance(ssl_context, tuple):
ssl_context = load_ssl_context(*ssl_context)
if ssl_context == "adhoc":
ssl_context = generate_adhoc_ssl_context()
self.socket = tsafe.Connection(ssl_context, self.socket)
self.ssl_context = ssl_context
else:
self.ssl_context = None
def start(self):
# If the use_default_httpserver setting is specified,
# the presentation will start own http server on the specified port.
isDefault = SettingsBase.get_setting(self, 'use_default_httpserver')
if not globals().has_key('Callback'):
isDefault = False
if isDefault:
self._cb_handle = Callback(self.cb)
self.__tracer.info("using web page %s and"
" using digiweb", self.get_page())
else:
self._cb_handle = self.get_channels
try:
port = SettingsBase.get_setting(self, 'port')
self.__tracer.info("using port %d and BaseHTTPServer", port)
HTTPServer.__init__(self, ('', port), WebRequestHandler)
except Exception:
self.__tracer.debug(traceback.format_exc())
self.socket.close()
# Only start a thread if the Python web-server is
# used:
threading.Thread.start(self)
def __init__(self):
HTTPServer.__init__(self, ('',8087), Monitor.Handler)
self.__cv = threading.Condition()
self.__thread = threading.Thread(target=self.serve_forever)
self.__messages = []
self.__thread.setDaemon(True)
self.__thread.start()
def __init__(self, proxy_address, server_address, get_stop, log, \
auth_method, username, password, \
request_handler_class, bind_and_activate=True, handler_params = []):
HTTPServer.__init__(self, proxy_address, request_handler_class, \
bind_and_activate)
self.username = username
self.password = password
self.address = proxy_address
self.server = server_address
self.handler_params = handler_params
self.log = log
self.get_stop = get_stop
self.auth_method = auth_method
self.stop = False
### SSL specific
ssl_certificate = self.handler_params[0].ssl_certificate
#if 1 == 1:
try:
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file (ssl_certificate)
ctx.use_certificate_file(ssl_certificate)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
self.socket_type))
except:
error = "SSL error : %s. Did you generate certificate ?" % self.handler_params[0].get_exception()
print(error)
self.handler_params[0].log.error(error)
# force exiting
self.handler_params[0].force_leave()
return
def __init__(self, server_address, RequestHandlerClass,
store=None, cors=False, index_file=None):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.store = store or self._default_store()
self.cors = cors
self.index_file = index_file
def __init__(self, serverThread, log, opt, handle):
self.serverThread = serverThread
HTTPServer.__init__(self, opt, handle)
self.log = log
self.protocol_version = 'HTTP/1.1'
def __init__(self, queue, collector_url, port=80, host='', template_name='', debug=False):
KissKissieBase.__init__(self, queue, debug)
HTTPServer.__init__(self, (host, port), DtdServerHandler)
self._port = port
self._collector_url = collector_url
self._host = host
self._template_name = template_name
def __init__(self, suite_desc_list, suite_renderer, jscover_path=None):
"""
Initialize the server to serve test runner pages
and dependencies described by `suite_desc_list`
(list of `SuiteDescription` instances).
`jscover_path` is the path to the JSCover JAR file. If not
specified, no coverage information will be collected.
Use `suite_renderer` (a `SuiteRenderer` instance) to
render the test suite pages.
"""
# Store dependencies
self.desc_dict = self._suite_dict_from_list(suite_desc_list)
self.renderer = suite_renderer
self._jscover_path = jscover_path
# Create a dict for source instrumenter services
# (One for each suite description)
self.src_instr_dict = {}
# Using port 0 assigns us an unused port
address = ('0.0.0.0', 0)
HTTPServer.__init__(self, address, SuitePageRequestHandler)
def __init__(self, **kargs):
self.include_path = os.path.dirname(os.path.realpath(__file__))
self.js_includes = []
for js in glob.glob(os.path.join(self.include_path, '*.js')):
self.js_includes.append(os.path.basename(js))
if 'request_handler' in kargs:
request_handler = kargs['request_handler']
else: request_handler = RequestHandler
self.http_root = ''
self.sync = SyncRootNode('sync', self, SyncNode)
self.async= AsyncRootNode('async', self, AsyncNode)
self.message_handler = lambda message: 0
#Counter: used to give messages IDs
self.counter = 0
self.counter_lock = multiprocessing.Lock()
#Message buffer: records messages waiting for a return
self.message_buffer = {}
self.message_buffer_lock = multiprocessing.Lock()
#Message queue: messages to be written to the socket
self.message_queue = Queue.Queue()
HTTPServer.__init__(self, ('', 8080), request_handler)
threading.Thread.__init__(self)
def __init__(self, server_address, RequestHandlerClass, proxied_to, staticfolder, printer):
self.proxied_to = proxied_to
self.staticfolder = staticfolder
self.printer = printer
self.session = requests.session()
self.last = proxied_to
HTTPServer.__init__(self, server_address, RequestHandlerClass)
def __init__(self, server_address, RequestHandlerClass, certfile):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
# we assume the certfile contains both private key and certificate
self.certfile = certfile
self.active = False
self.allow_reuse_address = True
def __init__(self, settings):
self._terminator = threading.Event()
self.auth = Auth(settings)
self.elasticsearch = settings.elasticsearch
self.skip_index_initialization = settings.options.skip_index_initialization
listen_address = settings.listen_address
listen_port = settings.listen_port
url_scheme = 'http'
HTTPServer.__init__(self, (listen_address, listen_port), ElasticRequestHandler, bind_and_activate=False)
if settings.secure_connection:
url_scheme = 'https'
self.socket = ssl.wrap_socket(self.socket, settings.private_key, settings.certificate,
server_side=True, ssl_version=ssl.PROTOCOL_TLSv1)
self.wsgi_environ = os.environ.copy()
self.wsgi_environ['SERVER_SOFTWARE'] = APP_NAME + ' ' + VERSION
self.wsgi_environ['SERVER_NAME'] = listen_address
self.wsgi_environ['SERVER_PORT'] = listen_port
self.wsgi_environ['wsgi.errors'] = WsgiErrorLog(self.log)
self.wsgi_environ['wsgi.url_scheme'] = url_scheme
self.wsgi_environ['wsgi.multiprocess'] = False
self.wsgi_environ['wsgi.multithread'] = True
self.wsgi_environ['wsgi.run_once'] = False
self.wsgi_environ['wsgi.version'] = (1, 0)
def __init__(self, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
if configuration.daemon_conf['nossl']:
proto = 'http'
proto_port = 80
else:
proto = 'https'
proto_port = 443
if self.server_port != proto_port:
self.base_url = ('%s://%s:%s/' %
(proto, self.server_name, self.server_port))
else:
self.base_url = '%s://%s/' % (proto, self.server_name,)
# We serve from sub dir to ease targeted proxying
self.server_base = 'openid'
self.base_url += "%s/" % self.server_base
self.openid = None
self.approved = {}
self.lastCheckIDRequest = {}
# Add our own SReg fields to list of valid fields from sreg 1.1 spec
for (key, val) in cert_field_map.items():
if not key in sreg.data_fields:
sreg.data_fields[key] = key.replace('_', ' ').title()
# print "DEBUG: sreg fields: %s" % sreg.data_fields
for name in cert_field_names:
cert_field_aliases[name] = []
for target in [i for i in cert_field_names if name != i]:
if cert_field_map[name] == cert_field_map[target]:
cert_field_aliases[name].append(target)
def __init__(self,
server_address,
RequestHandlerClass,
db_conn_string,
pckg_data,
suppress_handler,
db_version_info):
LOG.debug('Initializing HTTP server')
self.www_root = pckg_data['www_root']
self.doc_root = pckg_data['doc_root']
self.checker_md_docs = pckg_data['checker_md_docs']
self.checker_md_docs_map = pckg_data['checker_md_docs_map']
self.suppress_handler = suppress_handler
self.db_version_info = db_version_info
self.__engine = sqlalchemy.create_engine(db_conn_string,
client_encoding='utf8',
poolclass=sqlalchemy.pool.NullPool)
Session = scoped_session(sessionmaker())
Session.configure(bind=self.__engine)
self.sc_session = Session
self.__request_handlers = ThreadPool(processes=10)
HTTPServer.__init__(self, server_address,
RequestHandlerClass,
bind_and_activate=True)
def __init__(self, host, port, app, handler=None,
passthrough_errors=False, ssl_context=None, fd=None):
if handler is None:
handler = WSGIRequestHandler
self.address_family = select_ip_version(host, port)
if fd is not None:
real_sock = socket.fromfd(fd, self.address_family,
socket.SOCK_STREAM)
port = 0
HTTPServer.__init__(self, (host, int(port)), handler)
self.app = app
self.passthrough_errors = passthrough_errors
self.shutdown_signal = False
self.host = host
self.port = port
# Patch in the original socket.
if fd is not None:
self.socket.close()
self.socket = real_sock
self.server_address = self.socket.getsockname()
if ssl_context is not None:
if isinstance(ssl_context, tuple):
ssl_context = load_ssl_context(*ssl_context)
if ssl_context == 'adhoc':
ssl_context = generate_adhoc_ssl_context()
self.socket = ssl_context.wrap_socket(self.socket,
server_side=True)
self.ssl_context = ssl_context
else:
self.ssl_context = None
def __init__(self,
server_address,
RequestHandlerClass,
db_conn_string,
pckg_data,
suppress_handler,
db_version_info,
manager):
LOG.debug('Initializing HTTP server')
self.www_root = pckg_data['www_root']
self.doc_root = pckg_data['doc_root']
self.checker_md_docs = pckg_data['checker_md_docs']
self.checker_md_docs_map = pckg_data['checker_md_docs_map']
self.suppress_handler = suppress_handler
self.db_version_info = db_version_info
self.__engine = database_handler.SQLServer.create_engine(
db_conn_string)
Session = scoped_session(sessionmaker())
Session.configure(bind=self.__engine)
self.sc_session = Session
self.manager = manager
self.__request_handlers = ThreadPool(processes=10)
HTTPServer.__init__(self, server_address,
RequestHandlerClass,
bind_and_activate=True)
def __init__(self, server_address, services=[], RequestHandlerClass=SOAPRequestHandler):
'''server_address --
RequestHandlerClass --
'''
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self._nodes = self.NodeTree()
map(lambda s: self.setNode(s), services)
def __init__(self, server_address, RequestHandlerClass, servernumber,
bind_and_activate=True):
HTTPServer.__init__(self, server_address, RequestHandlerClass,
bind_and_activate=bind_and_activate)
self.log = util.getLogger()
self.servernumber = servernumber
self.cloudiness_cache = {}
self.cloudiness_cache_misses = 0
self.cloudiness_cache_hits = 0
self.image_cache = {}
self.image_cache_size = 0
self._cpu_usage = 0.0
self._cpu_prev_idle = 0.0
self._cpu_prev_total = 0.0
self._cpu_usage_last_100_samples = []
# Shared object is expected to reside in lib/libcloudiness.so
LIB_FILENAME = "libcloudiness.so"
LIBPATH = os.path.join(constants.ROOT_DIR, "lib", LIB_FILENAME)
# Load the shared object. This object has been compiled with some
# particular flags. Look at the Makefile accompanying it.
self.libcloudiness = ctypes.cdll.LoadLibrary(LIBPATH)
# This is one of the functions declared in the library
self.calc_cloudiness = self.libcloudiness.calc_cloudiness
self.calc_cloudiness.restype = ctypes.c_double
def __init__(self, RequestHandlerClass):
HTTPServer.__init__(self, None, RequestHandlerClass, False)
self.requestHandler = RequestHandlerClass
# TODO provide proper limit for this queue
self.queue = TaskQueue(sys.maxint)
def __init__( self, addr, handler ):
HTTPServer.__init__( self, addr, handler )
self.events = [""] * self.event_limit
self.event_pos = 0
self.traffic_time = datetime.now()
self.clients = {}
def __init__(self, host, port, app, handler=None,
passthrough_errors=False):
if handler is None:
handler = BaseRequestHandler
HTTPServer.__init__(self, (host, int(port)), handler)
self.app = app
self.passthrough_errors = passthrough_errors
def __init__(self, notify, host_and_port):
HTTPServer.__init__(self, host_and_port, NotificationHandler)
threading.Thread.__init__(self)
self.setDaemon(True)
self.notify = notify
self.msg_ids = [ ]
print('Listening for Oracle Notifications on %s:%s' % host_and_port)
def __init__(self, server_address, request_handler_class, \
bind_and_activate=True, handler_params = []):
HTTPServer.__init__(self, server_address, request_handler_class, \
bind_and_activate)
self.address = server_address
self.handler_params = handler_params
self.stop = False
def __init__(self, conffile=None, verbose=False, fork=False, start=False ):
self.verbose = verbose
self.fork = fork
self.pidfile = None
self.__config = None
self.__password = None
if not self.__configuration(conffile):
print >>sys.stderr, "error: unable to read configuration"
sys.exit(1)
general = self.config['general']
addr = ( general['bind'], general['listen'] )
HTTPServer.__init__(self, addr, NotifyRequestHandler )
self.__queue = Queue.Queue(self.queue_size)
self.__queue_thread = None
self.__client = None
self.__connected = False
self.__tries = 0
self.__alive = False
if start:
self.start()
def start(self):
"""
Starts the web presentation module.
If the use_default_httpserver setting is specified it starts own http server on the specified port.
"""
isDefault = SettingsBase.get_setting(self, 'use_default_httpserver')
if not globals().has_key('Callback'):
isDefault = False
if isDefault:
self._cb_handle = Callback(self.cb)
print "Web2 (%s): using web page %s" % (self.__name,
self.get_page())
print "... using digiweb"
else:
self._cb_handle = self.get_channels
try:
port = SettingsBase.get_setting(self, 'port')
print "Web Presentation (%s): using port %d" % (self.__name, port)
print "... using BaseHTTPServer"
HTTPServer.__init__(self, ('', port), WebRequestHandler)
except Exception:
traceback.print_exc()
self.socket.close()
# Only start a thread if the Python web-server is
# used:
threading.Thread.start(self)
def __init__(self, GeniusCtrl, cmdQueue, serverName):
self.GeniusCtrl = GeniusCtrl
self.cmdQueue = cmdQueue
self.serverName = serverName
port = findFreePort(11211,11220)
HTTPServer.__init__(self, ('', port), GeniusRequest)
self.GeniusCtrl.log('HTTP service %s started on port %d.\n' % (self.serverName, port))
self.running = True
self.quitEvent = None
self.quitTimer = None
self.socket_errors_to_ignore = []
# Not all of these names will be defined for every platform.
for _ in ("EPIPE", "ETIMEDOUT", "ECONNREFUSED", "ECONNRESET",
"EHOSTDOWN", "EHOSTUNREACH",
"WSAECONNABORTED", "WSAECONNREFUSED", "WSAECONNRESET",
"WSAENETRESET", "WSAETIMEDOUT"):
if _ in dir(errno):
self.socket_errors_to_ignore.append(getattr(errno, _))
# de-dupe the list
self.socket_errors_to_ignore = dict.fromkeys(self.socket_errors_to_ignore).keys()
map = [
('/status/log', self.doLog),
('/status(/(?P<cmd>quit|exit|reset|chdir|tmpdir))', self.doStatusCmd),
('/status(/(?P<cmd>name|pwd|wait))?(\?(?P<arg>.*))?', self.doStatusQuery),
('/deck(/(?P<type>file|text))', self.doRunDeck),
('/solution', self.doSolution),
('/struct(/(?P<format>xml|text))', self.doStructQuery),
('/file/(?P<path>.*)', self.doFile)
]
self.dispatcher = Dispatcher(map, self.errorHandler)
def __init__(self, server_address, handlerClass):
HTTPServer.__init__(self, server_address, handlerClass)
self.running = False
self.stop_requested = False
def __init__(self, host, port):
server_address = (host, port)
HTTPServer.__init__(self, server_address, RequestHandler)
def __init__(self, *args, **kwargs):
self.logger = logging.getLogger('server.handler')
HTTPServer.__init__(self, *args, **kwargs)
def __init__(self, ref, *args):
HTTPServer.__init__(self, *args)
if ref.__class__ is FileBruter:
self.ref = ref
else:
raise "SOMETHING IS SERIOUSLY BROKEN!"
def __init__(self, server_address, RequestHandlerClass, resources):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.resources = resources
def __init__(self, server_address, RequestHandlerClass, s_queues):
self.s_queues = s_queues
HTTPServer.__init__(self, server_address, RequestHandlerClass)
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
def __init__(self, (HOST,PORT), handler, task_root, monitor_list):
HTTPServer.__init__(self, (HOST, PORT), handler)
self.task_root = task_root
self.is_monitor_visited = { m: False for m in monitor_list }
def __init__(self, address, web_port, ws_port, handler, http_docs=None):
HTTPServer.__init__(self, (address, web_port), handler)
self.ip_address = address
self.terminate = False
self.ws_port = ws_port
self.docpath = http_docs
def __init__(self, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
self.__serving = False
self.__is_shut_down = threading.Event()
def __init__(self, server_address, path='htdocs'):
self.base_path = os.path.join(os.path.dirname(__file__), path)
HTTPServer.__init__(self, server_address, HTTPHandler)
def __init__(self, servaddr, cam): HTTPServer.__init__(self, servaddr, ImageServerRequestHandler) self.cam = cam print 'Starting server, use <Ctrl-C> to stop' self.server_thread = threading.Thread(target=self.serve_forever) self.server_thread.start()
def __init__(self, *args, **kw):
HTTPServer.__init__(self, *args, **kw)
self.ready = True
def __init__(self, address, handler):
HTTPServer.__init__(self, address, handler)
def __init__(self, base_path, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
self.RequestHandlerClass.base_path = base_path
def __init__(self, port=PORT):
HTTPServer.__init__(self,
('http://118.31.19.120', int(port), '/signin'),
SimpleHTTPRequestHandler)
def __init__(self, server_address, handler_class, context):
_HTTPServer.__init__(self, server_address, handler_class)
self.context = context
def __init__(self, server_address=('', 8080), RequestHandlerClass=ProxyHandler, bind_and_activate=True, ca_file='ca.pem'):
HTTPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate)
self.ca = CertificateAuthority(ca_file)
self._res_plugins = []
self._req_plugins = []
def __init__(self, *args, **kw): HTTPServer.__init__(self, *args, **kw) self.allow_reuse_address = True
def __init__(self, server_address):
HTTPServer.__init__(self, server_address, BratHTTPRequestHandler)
def __init__(self, port=PORT):
HTTPServer.__init__(self, ('localhost', int(port)),
SimpleHTTPRequestHandler)
def __init__(self, cert_reqs, ca_cert):
self.port = get_free_port()
self.cert_reqs = cert_reqs
self.ca_cert = None
HTTPServer.__init__(self, ('0.0.0.0', self.port), _HTTPHandler)
def __init__(self, server_address, RequestHandlerClass, metrics, otput):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.metrics = metrics
self.otput = otput
self.counter = 0
def __init__(self, dbClient, *args, **kwargs):
# Because HTTPServer is an old-style class, super() can't be used.
HTTPServer.__init__(self, *args, **kwargs)
print("Attached DB client")
self.dbc = dbClient
def __init__(self, fm):
self.fm = fm
self.queue = SimpleQueue()
self.goDie = False
HTTPServer.__init__(self, ('127.0.0.1', 5964), RangerControlHandler)
def __init__(self, server_address, RequestHandlerClass, queue):
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.queue = queue
def __init__(self, port):
global FILE_PATH
HTTPServer.__init__(self, ('', port), ScoreboardHttpHandler)
FILE_PATH = os.path.relpath(os.path.dirname(__file__), sys.path[0])
self.running = True
def __init__(self, host, port):
HTTPServer.__init__(self, (host, port), MyHTTPRequestHandler)
def __init__(self, host, port): HTTPServer.__init__(self, (host, port), ConvertcaseRequestHandler) self.service_map = collections.defaultdict()
def __init__(self, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
self.__requests_thread = []
self.authID = config.AUTH_ID
def __init__(self, server_address, rpcmethod={}, rpcclasses={}):
HTTPServer.__init__(self, server_address, XmlRpcHTTPHandler)
XmlRpcServer.__init__(self, rpcmethod, rpcclasses)
