def serve(cfg): global config config = cfg anidb.config = config database.connect(os.path.expanduser(config['database']), config['user']) try: os.remove(os.path.expanduser(config['session'])) except: pass run = [True] def killer(r): r[0] = False class ActualHandler(Handler): def __init__(self, *args, **kwargs): self.shutdown = lambda: killer(run) return super().__init__(*args, **kwargs) server = socketserver.UnixStreamServer( os.path.expanduser(config['session']), ActualHandler) while run[0]: server.handle_request()
def main(): desc = 'gpuplug host server for dynamic container GPU binding' parser = argparse.ArgumentParser(description=desc) parser.add_argument('-c', '--conf', metavar='CONF', default='/etc/gpuplugd.conf', help='config file location') args = parser.parse_args() logging.basicConfig(level=logging.INFO) gpus = parse_gpu_devs(args.conf) cnt_server = socketserver.UnixStreamServer(SOCKET_PATH, ContainerSocket) cnt_server.gpus = gpus cnt_server_thread = threading.Thread(name='cnt_server', target=cnt_server.serve_forever) try: logging.info('Running') cnt_server_thread.start() ''' This join won't ever actually complete. The join is here just to keep the main thread blocked inside the try-block so the KeyboardInterrupt is caught and the server thread is shut down from the exception handler. ''' cnt_server_thread.join() except KeyboardInterrupt: cnt_server.shutdown() cnt_server_thread.join() pass finally: os.unlink(SOCKET_PATH) logging.info('Bye!')
def __init__(self, secret=None, secretfile=None, socket=SRSSOCKET, *args, **kw): secrets = [] if secret: secrets += secret if secretfile and os.path.exists(secretfile): assert os.path.isfile(secretfile) and os.access(secretfile,os.R_OK), \ "Secret file $secretfile not readable" with open(secretfile) as FH: for ln in FH: if not ln: continue if ln.startswith('#'): continue secrets += ln assert secrets, \ """No secret or secretfile given. Use --secret or --secretfile, and ensure the secret file is not empty.""" # Preserve the pertinent original arguments, mostly for fun. self.secret = secret self.secretfile = secretfile self.socket = socket self.srs = Guarded(secret=secrets, *args, **kw) try: os.unlink(socket) except: pass self.server = socketserver.UnixStreamServer(socket, EximHandler) self.server.srs = self.srs
def __run_server(cls): global server if constants.OS_NAME == "Linux" or constants.OS_NAME == "Darwin": if os.path.exists(constants.SOCKET_LOCATION): logging.info("mmDict already running") logging.info( f"If you are sure mmDict is not running, you can delete {constants.SOCKET_LOCATION} first, " f"then try to run again.") exit(0) MyTCPHandler.dict_daemon = DictDaemon(cls.__config_file) # Register signal handler for server cleaning signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) logging.info("running with Unix socket") server = socketserver.UnixStreamServer(constants.SOCKET_LOCATION, MyTCPHandler) server.serve_forever() else: MyTCPHandler.dict_daemon = DictDaemon(cls.__config_file) logging.info("running with TCP socket") try: server = socketserver.TCPServer( (constants.HOST, constants.PORT), MyTCPHandler) server.serve_forever() except OSError: logging.error( f"{constants.HOST}:{constants.PORT} is already in use.")
def setUpClass(cls): try: os.remove(sock_path) except OSError: pass cls.server = socketserver.UnixStreamServer(sock_path, FakeAlfred) cls.server_thread = threading.Thread(target=cls.server.serve_forever) cls.server_thread.start()
def run_reload_server(controller): server = socketserver.UnixStreamServer("/tmp/autoconf.sock", ReloadServerHandler) os.chown("/tmp/autoconf.sock", 0, 101) os.chmod("/tmp/autoconf.sock", 0o770) server.controller = controller thread = threading.Thread(target=server.serve_forever) thread.daemon = True thread.start() return (server, thread)
def __init__(self, socket_path=SOCKET_DEFAULT): self._socket = socket_path self._handlers = [] self._server = socketserver.UnixStreamServer(socket_path, _MonitorHandler) self._thread = threading.Thread(target=self._server.serve_forever, name='dhcp-monitor') self._netapi = None self._cif = None self._thread.setDaemon(True)
def __init__(self, socket_path=SOCKET_DEFAULT): self._socket = socket_path self._handlers = [] self._remove_socket() self._server = socketserver.UnixStreamServer(socket_path, _MonitorHandler) self._thread = concurrent.thread(self._server.serve_forever, name='dhcp-monitor') self._netapi = None self._cif = None
def __init__(self, config, bus): self.config = config self.bus = bus self.pastebin = bus.pastebin self.handlers = [] self.sockhdl = _request_handler(self.handlers, bus) address = config.protocols.socket.address if type(address) == tuple: self.sockserv = socketserver.TCPServer(address, self.sockhdl) elif type(address) is str: self.sockserv = socketserver.UnixStreamServer( address, self.sockhdl)
def start_server(): logging.info('Initializing power server...') if os.path.exists(SOCKET_PATH): logging.warn('Detected stale socket, removing to start server...') os.remove(SOCKET_PATH) server = socketserver.UnixStreamServer(SOCKET_PATH, PowerHandler) try: server.serve_forever() finally: # Make sure to remove socket if handler crashes os.remove(SOCKET_PATH)
def __init__(self, node_number, automatic_failover): self.node_number = node_number self.automatic_failover = automatic_failover self.leader = None self.followers = set() self.en = BinaryEncoderDecoder() sockFd = get_socket_fd(node_number) self.server = socketserver.UnixStreamServer(sockFd, EntryPointHandler) self.server.server = self print("starting loadbalancer")
def main_loop(): setproctitle('webshelld') dispatcher = SimpleXMLRPCDispatcher() SOCKFILE = '/var/run/webshell.sock' if os.path.exists(SOCKFILE): os.unlink(SOCKFILE) server = socketserver.UnixStreamServer(SOCKFILE, XMLRPCHandler) os.chmod(SOCKFILE, 0o700) dispatcher.register_instance( Multiplex("/usr/local/bin/bash", "xterm-color")) server.dispatcher = dispatcher server.serve_forever()
def serverUNIX(): ppid = os.getpid() path = FILE.format(**locals()) dir_path = os.path.dirname(path) if not os.path.isdir(dir_path): print("mkdir", dir_path) os.makedirs(dir_path) server = socketserver.UnixStreamServer(path, ServerUNIX) try: print("server UNIX", path) server.serve_forever() finally: server.shutdown() os.remove(path)
def start_server(): logging.info('Initializing CDH server...') if os.path.exists(SOCKET_PATH): logging.warn('Detected stale socket, removing to start server...') os.remove(SOCKET_PATH) logger = get_network_logger() server = socketserver.UnixStreamServer(SOCKET_PATH, CDHHandler) # Get a network logger server.logger = logging.handlers.SocketHandler(LOG_SOCKET_PATH) try: server.serve_forever() finally: # Make sure to remove socket if handler crashes os.remove(SOCKET_PATH)
def start_server(): socket_path = 'test.socket' if os.path.exists(socket_path): os.remove(socket_path) server = socketserver.UnixStreamServer(socket_path, Handler) thread = threading.Thread(target=server.serve_forever) thread.start() def shutdown(): server.shutdown() server.server_close() thread.join() return (shutdown, socket_path)
def start_server(): socket_dir = tempfile.mkdtemp(prefix='test-ops.pebble') socket_path = os.path.join(socket_dir, 'test.socket') server = socketserver.UnixStreamServer(socket_path, Handler) thread = threading.Thread(target=server.serve_forever) thread.start() def shutdown(): server.shutdown() server.server_close() thread.join() os.remove(socket_path) os.rmdir(socket_dir) return (shutdown, socket_path)
def __init__(self, node_number): self.node_number = node_number self.store = KVStore(node_number) self.en = BinaryEncoderDecoder() sockFd = get_socket_fd(node_number) self.server = socketserver.UnixStreamServer(sockFd, EntryPointHandler) self.server.server = self print("starting server on node %s" % node_number) print("registering with load balancer") try: command, s = call_node_with_command(self._register_command(), LB_NODE) s.close() except FileNotFoundError: print("could not reach the load balancer") self.shutdown() self.receive_registration_info(command)
def run(self): with socketserver.UnixStreamServer(SOCK_FILE, worker.Handler) as server: self.server = server self.ready.set() server.serve_forever()
if cmd == 'input': self.reset_count = 0 more = self.push(m['text']) if more: self.prompt(ps2) else: self.prompt(ps1) elif cmd == 'complete': self.send('completion', text=self.completer.complete(m['text'], m['state'])) elif cmd == 'reset': if self.buffer: self.resetbuffer() self.prompt(ps1) else: self.reset_count += 1 if self.reset_count >= 2: self.send('exit') break self.prompt(ps1) path = os.path.expanduser('~/.bn_rpc.sock') if os.path.exists(path): os.unlink(path) socketserver.UnixStreamServer.allow_reuse_address = True server = socketserver.UnixStreamServer(path, InteractiveServer) t = threading.Thread(target=server.serve_forever) t.daemon = True t.start()
def main(): under_systemd = 'NOTIFY_SOCKET' in os.environ args = parser.parse_args() if not under_systemd: # setup logging ha_syslog = logging.handlers.SysLogHandler('/dev/log') ha_syslog.setFormatter( logging.Formatter('%(name)s[%(process)d]: %(message)s')) logging.root.addHandler(ha_syslog) # leave log for backwards compatibility ha_file = logging.FileHandler(LOG_PATH) ha_file.setFormatter( logging.Formatter( '%(asctime)s %(name)s[%(process)d]: %(message)s')) logging.root.addHandler(ha_file) if args.foreground: ha_stderr = logging.StreamHandler(sys.stderr) ha_file.setFormatter( logging.Formatter( '%(asctime)s %(name)s[%(process)d]: %(message)s')) logging.root.addHandler(ha_stderr) sys.stdin.close() else: # Under systemd we use the systemd JournalHandler. logging.root.addHandler( systemd.journal.JournalHandler(SYSLOG_IDENTIFIER="qmemman")) logging.root.setLevel(parser.get_loglevel_from_verbosity(args)) log = logging.getLogger('qmemman.daemon') config = configparser.SafeConfigParser({ 'vm-min-mem': str(qubes.qmemman.algo.MIN_PREFMEM), 'dom0-mem-boost': str(qubes.qmemman.algo.DOM0_MEM_BOOST), 'cache-margin-factor': str(qubes.qmemman.algo.CACHE_FACTOR) }) config.read(args.config) if config.has_section('global'): qubes.qmemman.algo.MIN_PREFMEM = \ qubes.utils.parse_size(config.get('global', 'vm-min-mem')) qubes.qmemman.algo.DOM0_MEM_BOOST = \ qubes.utils.parse_size(config.get('global', 'dom0-mem-boost')) qubes.qmemman.algo.CACHE_FACTOR = \ config.getfloat('global', 'cache-margin-factor') log.info( 'MIN_PREFMEM={algo.MIN_PREFMEM}' ' DOM0_MEM_BOOST={algo.DOM0_MEM_BOOST}' ' CACHE_FACTOR={algo.CACHE_FACTOR}'.format(algo=qubes.qmemman.algo)) server = None systemd_sock = None systemd_listen_fds = systemd.daemon.listen_fds(True) if systemd_listen_fds: log.debug('listening on systemd provided socket') server = socketserver.UnixStreamServer(None, QMemmanReqHandler, False) server.socket = socket.fromfd(systemd_listen_fds[0], socket.AF_UNIX, socket.SOCK_STREAM) else: try: os.unlink(SOCK_PATH) except: pass log.debug('instantiating server') os.umask(0) server = socketserver.UnixStreamServer(SOCK_PATH, QMemmanReqHandler) os.umask(0o077) # Initialize the connection to Xen and to XenStore system_state.init() if under_systemd: systemd.daemon.notify('READY=1') threading.Thread(target=server.serve_forever).start() XS_Watcher().watch_loop()
#!/usr/bin/python3 from tgs.exporters import exporters from tgs.importers import importers import socketserver import os import atexit import io import sys importer = None exporter = None class Handler(socketserver.StreamRequestHandler): def handle(self): exporter.process(importer.process(io.BytesIO(self.rfile.read())), self.wfile) if __name__ == '__main__': importer = importers.get('lottie') exporter = exporters.get('gif') path = sys.argv[1] try: os.remove(path) except FileNotFoundError: pass atexit.register(os.remove, path) with socketserver.UnixStreamServer(path, Handler) as server: print('Started serving requests') server.serve_forever()
key_file = os.path.join(os.path.dirname(__file__), '.key') pid = str(os.getpid()) logging.debug("Writing PID " + pid + " to " + str(args.pidfile)) with open(args.pidfile, 'w') as fp: fp.write("%s\n" % pid) jc = JeedomCallback(args.apikey, args.callback) if not jc.test(): sys.exit() zigate.dispatcher.connect(callback_command, zigate.ZIGATE_FAILED_TO_CONNECT) if os.path.exists(args.socket): os.unlink(args.socket) server = socketserver.UnixStreamServer(args.socket, JeedomHandler) if args.device == 'fake': z = zigate.core.FakeZiGate(args.device, persistent_file, auto_start=False) elif '.' in args.device: # supposed I.P:PORT host_port = args.device.split(':', 1) host = host_port[0] port = None if len(host_port) == 2: port = int(host_port[1]) logging.info('Démarrage ZiGate WiFi {} {}'.format(host, port)) z = zigate.ZiGateWiFi(host, port, persistent_file, auto_start=False) else: logging.info('Démarrage ZiGate {}'.format(args.device)) if args.gpio: z = zigate.ZiGateGPIO(args.device, persistent_file, auto_start=False) else:
# # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. # # import socketserver class MyUNIXHandler(socketserver.StreamRequestHandler): def handle(self): # self.rfile is a file-like object created by the handler; # we can now use e.g. readline() instead of raw recv() calls self.data = self.rfile.readline().strip() print(self.data) # Likewise, self.wfile is a file-like object used to write back # to the client #~ self.wfile.write(self.data.upper()) if __name__ == '__main__': ADDR = "/tmp/algo" # Create the server, binding to localhost on port 9999 server = socketserver.UnixStreamServer(ADDR, MyUNIXHandler) # Activate the server; this will keep running until you # interrupt the program with Ctrl-C server.serve_forever()
def main(): args = parser.parse_args() # setup logging ha_syslog = logging.handlers.SysLogHandler('/dev/log') ha_syslog.setFormatter( logging.Formatter('%(name)s[%(process)d]: %(message)s')) logging.root.addHandler(ha_syslog) # leave log for backwards compatibility ha_file = logging.FileHandler(LOG_PATH) ha_file.setFormatter( logging.Formatter('%(asctime)s %(name)s[%(process)d]: %(message)s')) logging.root.addHandler(ha_file) if args.foreground: ha_stderr = logging.StreamHandler(sys.stderr) ha_file.setFormatter( logging.Formatter( '%(asctime)s %(name)s[%(process)d]: %(message)s')) logging.root.addHandler(ha_stderr) sys.stdin.close() logging.root.setLevel(parser.get_loglevel_from_verbosity(args)) log = logging.getLogger('qmemman.daemon') config = configparser.SafeConfigParser({ 'vm-min-mem': str(qubes.qmemman.algo.MIN_PREFMEM), 'dom0-mem-boost': str(qubes.qmemman.algo.DOM0_MEM_BOOST), 'cache-margin-factor': str(qubes.qmemman.algo.CACHE_FACTOR) }) config.read(args.config) if config.has_section('global'): qubes.qmemman.algo.MIN_PREFMEM = \ qubes.utils.parse_size(config.get('global', 'vm-min-mem')) qubes.qmemman.algo.DOM0_MEM_BOOST = \ qubes.utils.parse_size(config.get('global', 'dom0-mem-boost')) qubes.qmemman.algo.CACHE_FACTOR = \ config.getfloat('global', 'cache-margin-factor') log.info( 'MIN_PREFMEM={algo.MIN_PREFMEM}' ' DOM0_MEM_BOOST={algo.DOM0_MEM_BOOST}' ' CACHE_FACTOR={algo.CACHE_FACTOR}'.format(algo=qubes.qmemman.algo)) try: os.unlink(SOCK_PATH) except: pass log.debug('instantiating server') os.umask(0) server = socketserver.UnixStreamServer(SOCK_PATH, QMemmanReqHandler) os.umask(0o077) # notify systemd nofity_socket = os.getenv('NOTIFY_SOCKET') if nofity_socket: log.debug('notifying systemd') s = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM) if nofity_socket.startswith('@'): nofity_socket = '\0%s' % nofity_socket[1:] s.connect(nofity_socket) s.sendall(b"READY=1") s.close() threading.Thread(target=server.serve_forever).start() XS_Watcher().watch_loop()
p0f_status = 'ok' p0f_os = 'linux' alen = len(sys.argv) if alen > 1: SOCK = sys.argv[1] if alen >= 4: p0f_os = sys.argv[2] p0f_status = sys.argv[3] elif alen >= 3: p0f_os = sys.argv[2] cleanup(SOCK) server = socketserver.UnixStreamServer(SOCK, MyStreamHandler, bind_and_activate=False) server.allow_reuse_address = True server.p0f_status = p0f_status server.p0f_os = p0f_os server.server_bind() server.server_activate() dummy_killer.setup_killer(server) dummy_killer.write_pid(PID) try: server.handle_request() except socket.error: print("Socket closed")
def server_main(): with socketserver.UnixStreamServer(SOCKET_PATH, ServerHandler) as server: server.serve_forever()