def run(self): self.running = True self.__server = UnixStreamServer(self.__socket, NetemDaemonHandler) os.chmod(self.__socket, 0o666) logging.info("Start pynetem daemon") self.__server.serve_forever()
def server_bind(self): # Everything expects a (host, port) pair, except the unix bind function. save = self.server_address self.server_address = save[0] UnixStreamServer.server_bind(self) self.server_address = save self.server_name, self.server_port = self.server_address self.setup_environ()
def __init__(self, store_server, socket_path, exports=None): with Pfx("%s.__init__(store_server=%s, socket_path=%r)", type(self), store_server, socket_path): UnixStreamServer.__init__(self, socket_path, _ClientConnectionHandler) self.store_server = store_server self.socket_path = socket_path self.exports = exports
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): UnixStreamServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate) self._connection_socket = None # type: socket.socket self._messages = []
def __init__(self, connection, requestHandler=FLSUnixRequestHandler, name='flscp-unix'): Thread.__init__(self, name=name) if os.path.exists(connection): # is a server running with this socket? os.unlink(connection) elif not os.path.exists(os.path.dirname(connection)): os.makedirs(os.path.dirname(connection)) UnixStreamServer.__init__(self, connection, requestHandler)
class EchoServer(threading.Thread): def __init__(self, address): super(EchoServer, self).__init__() self.daemon = True self.server = UnixStreamServer(address, EchoHandler) def run(self): self.server.handle_request() def stop(self): self.server.shutdown()
def main(argv): parser = argparse.ArgumentParser() parser.add_argument('--unix_socket', action='store') parser.add_argument('mode', type=str, nargs='?') parser.add_argument('target', type=str, nargs='?') args = parser.parse_args(argv) if args.mode: if args.mode == 'always' and args.target: Handler.filename = args.target elif args.mode == 'redirect' and args.target: Handler.redirect = args.target elif args.mode == '404': Handler.not_found = True elif args.mode == 'timeout': Handler.simulate_timeout = True elif args.mode == 'auth': Handler.auth = True if args.target: Handler.filename = args.target httpd = None if args.unix_socket: httpd = UnixStreamServer(args.unix_socket, Handler) sys.stderr.write('Serving forever on %s.\n' % args.unix_socket) else: port = None while port is None: try: port = random.randrange(32760, 59760) httpd = TCPServer(('', port), Handler) except socket.error: port = None sys.stdout.write('%d\nstarted\n' % (port, )) sys.stdout.flush() sys.stdout.close() sys.stderr.write('Serving forever on %d.\n' % port) try: httpd.serve_forever() finally: sys.stderr.write('Goodbye.\n')
class NetemDaemonThread(threading.Thread): def __init__(self, socket): super(NetemDaemonThread, self).__init__() self.__server = None self.__socket = socket self.running = False def run(self): self.running = True self.__server = UnixStreamServer(self.__socket, NetemDaemonHandler) os.chmod(self.__socket, 0o666) logging.info("Start pynetem daemon") self.__server.serve_forever() def stop(self): if self.__server is not None: logging.info("Stop pynetem daemon") self.__server.shutdown() self.__server = None self.running = False
def run_test_server(sock_path): srv = UnixStreamServer(sock_path, RequestHandler) thr = Thread(target=srv.serve_forever) thr.daemon = True thr.start()
res['concentration'] = self.concentration(data["position"]) res['robot'] = data['robot'] res['position'] = data['position'] res['type'] = "cloudread" print("Robot {number}: position {position} with concentration {concentration}".format(number=data["robot"], position=data["position"], concentration=res["concentration"])) # Send response using single communication channel. # Generally it's bad pattern, but don't want to make async nor block # inside robot. with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as conn: conn.connect(os.path.join("/tmp/sst/", str(data["robot"]))) conn.send(json.dumps(res).encode("utf-8")) conn.close() if __name__ == "__main__": parser = ArgumentParser(description="Cloud sensor") parser.add_argument("config", help="Path to environment configuration") args = parser.parse_args() config = ConfigParser() config.read(args.config) cloud = config["cloud"] radius = int(cloud["radius"]) center = [x for x in map(float, map(float, cloud["center"].split(',')))] path = os.path.join("/tmp/sst/", Cloud.name) server = UnixStreamServer(path, Cloud.handler(center, radius)) print("Starting server") server.serve_forever()
def server_bind(self): UnixStreamServer.server_bind(self) self.server_name = "unix_socket_server" self.server_port = 0
r = json.dumps(r_dict) self.wfile.write(r.encode('utf-8')) super().finish() if __name__ == "__main__": print('%s start...' % __file__) path = r'/home/nykh2010/sqlite3.sock' # try: # with open(CONFIG_PATH, 'r') as f: # config = f.read(1024) # c_dict = json.loads(config) # DBPORT = c_dict['dbconfig']['DBPORT'] # DBIP = c_dict['dbconfig']['DBIP'] # except: # DBIP = 'localhost' # DBPORT = 9000 if os.path.exists(path): os.unlink(path) dbserver = UnixStreamServer(path, DBServer) try: engine = create_engine(r'sqlite:///gateway.db?check_same_thread=False', echo=True) Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) except Exception as e: print(e) dbserver.serve_forever()
from socketserver import UnixStreamServer, StreamRequestHandler import os os.unlink('unix.sock') class EchoTCPServer(StreamRequestHandler): def handle(self): data = self.request.recv(1024).strip() data = data.decode('utf-8') data = int(data[0]) + int(data[-1]) data = str(data) data = data.encode('utf-8') self.request.sendall(data) if __name__ == '__main__': with UnixStreamServer('unix.sock', EchoTCPServer) as server: server.serve_forever()
def __init__(self, address): super(EchoServer, self).__init__() self.daemon = True self.server = UnixStreamServer(address, EchoHandler)
#!/usr/bin/env python from fastcgi import * from pathlib import Path from socketserver import UnixStreamServer,TCPServer from warnings import warn class TestHandler(FcgiHandler): def handle(self): self.print(f'Content-type: text/html\n\nHello {self.content()}') p = Path('fcgi.sock') if p.exists(): p.unlink() with UnixStreamServer(str(p), TestHandler) as srv: srv.serve_forever()