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()
