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