def __init__(self, server_address, handler_class, config): UnixStreamServer.__init__(self, server_address, handler_class) if 'consumers' not in config: raise ValueError('Configuration does not provide any consumer') self.config = config if 'server_string' in self.config: self.server_string = self.config['server_string']
def __init__(self, address, requestHandler=SimpleXMLRPCRequestHandler, allow_none=False, encoding=None): self.logRequests = False SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) UnixStreamServer.__init__(self, address, requestHandler)
def __init__(self, server_address, requestHandler=UnixStreamSimpleXMLRPCRequestHandler, allow_none=False, encoding=None, bind_and_activate=True): # cleanup leftover address if not server_address.startswith('\x00'): try: os.unlink(server_address) except OSError: if os.path.exists(server_address): raise # logging fails with UnixStreamServer self.logRequests = True SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) UnixStreamServer.__init__(self, server_address, requestHandler, bind_and_activate) if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'): flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD) flags |= fcntl.FD_CLOEXEC fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, sockfile=None, app=None): self.address_family = socket.AF_UNIX UnixStreamServer.__init__(self, sockfile, UnixWSGIRequestHandler) self.app = app self.passthrough_errors = None self.shutdown_signal = False self.ssl_context = None
def run(self): socket_path = '/var/run/ajenti-ipc.sock' if os.path.exists(socket_path): os.unlink(socket_path) server = UnixStreamServer(socket_path, Handler) os.chmod(socket_path, 0700) server.serve_forever()
def __init__(self, addr, requestHandler=RequestHandler): self.logRequests = 0 if os.path.exists(addr): os.unlink(addr) dir = os.path.dirname(addr) if not(os.path.exists(dir)): os.makedirs(dir) SimpleXMLRPCDispatcher.__init__(self) UnixStreamServer.__init__(self, addr, requestHandler)
def __init__(self, addr, requestHandler=RequestHandler): self.logRequests = 0 if os.path.exists(addr): os.unlink(addr) dir = os.path.dirname(addr) if not (os.path.exists(dir)): os.makedirs(dir) SimpleXMLRPCDispatcher.__init__(self) UnixStreamServer.__init__(self, addr, requestHandler)
def server(dispatcher, tmpdir): """ Return UnixStreamServer combined with Handler and a Dispatcher instance. """ socket_path = tmpdir.join('test_tolk_socket').strpath s = UnixStreamServer(socket_path, Handler) s.dispatcher = dispatcher return s
def shutdown(self): """ Shuts down the server. """ with self.shuttingdown.get_lock(): self.shuttingdown.value = 1 UnixStreamServer.server_close(self) if self.process: self.process.terminate() os.remove(self.address) self.deleted_socket_file = True
def harakiri(self): """ Shuts down the server from the server process itself. """ with self.shuttingdown.get_lock(): self.shuttingdown.value = 1 UnixStreamServer.server_close(self) os.remove(self.address) self.deleted_socket_file = True exit(0)
def __init__(self, address='/tmp/BaseIPCServer.sock', start=True): """ Initializes the server. :param address: (str) The unix socket file path :param start: (bool) Flag indicating if the server should startup rightaway. """ self.address = address self.deleted_socket_file = False self.process = None self.shuttingdown = Value('i', 0) UnixStreamServer.__init__(self, self.address, self.handler) self._started = False if start: self.startup()
def run_slapd_trigger(script=None): if script is None: script = __file__ scriptdir, scriptname = path.split(script) rulesname = '%s.rules' % path.splitext(scriptname)[0] env = Env.parse_args([path.join(scriptdir, rulesname), path.join("/etc/ldap", rulesname)]) if env.action: env.set_state(env.action) elif env.devel: env.before_start(DebugHandler) DebugHandler().start() else: env.before_start(SocketHandler) logging.info("Listening on %s", env.socket_path) server = UnixStreamServer(env.socket_path, SocketHandler) env.after_start() server.serve_forever()
def run_slapd_trigger(script=None): if script is None: script = __file__ scriptdir, scriptname = path.split(script) rulesname = '%s.rules' % path.splitext(scriptname)[0] env = Env.parse_args( [path.join(scriptdir, rulesname), path.join("/etc/ldap", rulesname)]) if env.action: env.set_state(env.action) elif env.devel: env.before_start(DebugHandler) DebugHandler().start() else: env.before_start(SocketHandler) logging.info("Listening on %s", env.socket_path) server = UnixStreamServer(env.socket_path, SocketHandler) env.after_start() server.serve_forever()
def main(): args = docopt(__doc__) modbus_master = TcpMaster(args['--modbus-host'], int(args['--modbus-port'])) dispatcher = Dispatcher(modbus_master) server = UnixStreamServer(args['--socket'], Handler) server.dispatcher = dispatcher try: log.info('Start Tolk listening at {0}.'.format(args['--socket'])) server.serve_forever() except KeyboardInterrupt: log.info('Received SIGINT. Exiting') pass finally: os.unlink(args['--socket']) log.info('Tolk has stopped')
def __init__(self, server_address, requestHandler=UnixStreamSimpleXMLRPCRequestHandler, allow_none=False, encoding=None, bind_and_activate=True): # cleanup leftover address if not server_address.startswith('\x00'): try: os.unlink(server_address) except OSError: if os.path.exists(server_address): raise # logging fails with UnixStreamServer self.logRequests = True SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) UnixStreamServer.__init__( self, server_address, requestHandler, bind_and_activate) if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'): flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD) flags |= fcntl.FD_CLOEXEC fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def server_bind(self): oldmask = os.umask(000) UnixStreamServer.server_bind(self) os.umask(oldmask) self.socket_file = self.socket.getsockname()
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler): self.logRequests = False # critical, as logging fails with UnixStreamServer SimpleXMLRPCDispatcher.__init__(self) UnixStreamServer.__init__(self, addr, requestHandler)
def __init__(self, load_manager, logger=None, **kwargs): self.load_manager = load_manager self.logger = logger or logging.getLogger(__name__) UnixStreamServer.__init__(self, RequestHandlerClass=RPCRequestHandler, **kwargs)
def shutdown(self): UnixStreamServer.shutdown(self) self.__remove_socket(self.server_address)
def server_bind(self): self.__remove_socket(self.server_address) UnixStreamServer.server_bind(self)
msg = str(g.export_keys(opts.fingerprint)) self.reply_multiline(msg) elif l[:4] == 'SIGN' and len(l) > 5: sig = g.sign(datetime.datetime.today().isoformat() + "\n" + l[5:], keyid=opts.fingerprint) self.reply_multiline(str(sig)) else: self.reply("go away.", "404") def reply(self, line, code="200"): self.wfile.write(code + " " + line + "\n") def reply_multiline(self, data): self.wfile.write("200 READ=" + str(len(data)) + "\n") self.wfile.write(data) self.wfile.flush() ## print status information print HELP_STRING print "Protocol Version", PROTO_VERSION_STRING ## start server try: os.remove(opts.socket) except OSError: pass s = UnixStreamServer(opts.socket, SISRequestHandler) os.chmod(opts.socket, 0777) s.serve_forever()