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)