def __init__(self, irc):
self.__parent = super(MsgPipe, self)
self.__parent.__init__(irc)
self.ConnectionHandler.irc = irc
self.ConnectionHandler.log = self.log
config = conf.supybot.plugins.MsgPipe
self.unixsock = None
if config.unix():
self.unixsock = config.socketFile()
# delete stale socket
try:
os.unlink(self.unixsock)
except OSError:
pass
self.server = SocketServer.UnixStreamServer(
self.unixsock, self.ConnectionHandler)
else:
host = config.host()
port = config.port()
self.server = SocketServer.TCPServer((host, port),
self.ConnectionHandler)
t = threading.Thread(target=self.server.serve_forever,
name="MsgPipeThread")
t.setDaemon(True)
t.start()
world.threadsSpawned += 1
def __init__(self,
node_id,
socket_name=G.DB_DEFAULT_SOCK,
db_filename=G.DB_FILENAME):
"""
Initialize our socket
@param socket_name: Filename of UNIX socket to open for database
interaction.
"""
# Store our socket file name
self.socket_name = socket_name
if os.path.exists(self.socket_name):
try:
os.unlink(self.socket_name)
except:
logger.error(
"Could not delete %s, socket creation will fail." %
self.socket_name)
DatabaseServer.DB = CatanDatabase(node_id=node_id,
filename=db_filename)
# Setup our server
self.server = SocketServer.UnixStreamServer(socket_name, DbHandler)
# IMPORTANT: Allow everyone to write to the socket
os.chmod(socket_name, 0777)
multiprocessing.Process.__init__(self)
def __init__(self,
socket_name=G.TX_DEFAULT_SOCK):
"""
Initialize our socket
@param socket_name: Filename of UNIX socket to open for TX
transmissions
"""
# Store our socket file name
self.socket_name = socket_name
if os.path.exists(self.socket_name):
try:
os.unlink(self.socket_name)
except:
logger.error("Could not delete %s, socket creation will fail."%
self.socket_name)
# Setup our server
self.server = SocketServer.UnixStreamServer(socket_name,TxHandler)
# IMPORTANT: Allow everyone to write to the socket
os.chmod(socket_name, 0777)
multiprocessing.Process.__init__(self)
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"
FH = open(secretfile)
for ln in FH:
if not ln: continue
if ln.startswith('#'): continue
secrets += ln
FH.close()
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 __call__(self):
"""The callable action for the SystemSocketDaemon, which executes the _run method within the
context of a systemd service.
@@@return boolean
Specifies whether or not to continue execution of the daemon after this returns. True
equates to a continue, False will break execution and disable the daemon.
"""
if self.verbose:
self.logger.write('Cleaning up leftover socket file')
try:
os.unlink(self._socket)
except Exception as err:
pass
if self.verbose:
self.logger.write('Creating socket server')
self._server = SocketServer.UnixStreamServer(self._socket,
self._socketHandler)
if self.verbose:
self.logger.write('Executing socket server polling')
try:
self._server.serve_forever()
except Exception as err:
self.logger.write('FAILED: serve_forever', err)
if self.verbose:
self.logger.write('Closed socket server polling')
return False
def main_loop():
if os.path.exists(SOCKFILE):
os.unlink(SOCKFILE)
server = SocketServer.UnixStreamServer(SOCKFILE, CommandHandler)
server.context = BackupContext()
server.context.shutdown = server.shutdown
os.chmod(SOCKFILE, 0o700)
server.serve_forever()
def main():
usage = "usage: %prog [options]"
parser = OptionParser(usage)
parser.add_option("-c",
"--config",
action="store",
dest="config",
default=config_path)
(options, args) = parser.parse_args()
logfd = os.open(LOG_PATH, os.O_WRONLY | os.O_APPEND | os.O_CREAT, 0644)
if logfd < 0:
print sys.stderr, "ERROR: Failed to open log file (%s)" % LOG_PATH
exit(1)
# reinitialize python stdout/err
sys.stdout.flush()
sys.stderr.flush()
os.dup2(logfd, 1)
os.dup2(logfd, 2)
os.close(logfd)
devnull = os.open('/dev/null', os.O_RDONLY)
os.dup2(devnull, 0)
config = SafeConfigParser({
'vm-min-mem':
str(qmemman_algo.MIN_PREFMEM),
'dom0-mem-boost':
str(qmemman_algo.DOM0_MEM_BOOST),
'cache-margin-factor':
str(qmemman_algo.CACHE_FACTOR)
})
config.read(options.config)
if config.has_section('global'):
qmemman_algo.MIN_PREFMEM = parse_size(
config.get('global', 'vm-min-mem'))
qmemman_algo.DOM0_MEM_BOOST = parse_size(
config.get('global', 'dom0-mem-boost'))
qmemman_algo.CACHE_FACTOR = config.getfloat(
'global', 'cache-margin-factor')
print "values: %s, %s, %s" % (str(
qmemman_algo.MIN_PREFMEM), str(
qmemman_algo.DOM0_MEM_BOOST), str(qmemman_algo.CACHE_FACTOR))
try:
os.unlink(SOCK_PATH)
except:
pass
os.umask(0)
server = SocketServer.UnixStreamServer(SOCK_PATH, QMemmanReqHandler)
os.umask(077)
if os.fork() == 0:
thread.start_new_thread(start_server, tuple([server]))
XS_Watcher().watch_loop()
def runServer(vfsSessionClass):
log.info("Starting socket server using session class '%s.%s'" %
(vfsSessionClass.__module__, vfsSessionClass.__name__))
if os.path.exists(SOCKET_FILE):
os.unlink(SOCKET_FILE)
VFSModuleSession.setSessionClass(vfsSessionClass)
server = SocketServer.UnixStreamServer(SOCKET_FILE, VFSHandler)
try:
server.serve_forever()
except Exception, e:
log.info("Socket server stopped due to exception '%s'" % e.__class__)
def handle(self, **options):
socket_file = options.get('socket_file')
if not socket_file:
raise CommandError('Path to the socket file is required!')
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write('Binding to unix socket: %s' % (socket_file, ))
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
server.serve_forever()
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 handle(self, **options):
socket_file = options.get("socket_file")
network_socket = options.get("network_socket")
threading = options.get("threading")
forking = options.get("forking")
if threading and forking:
raise CommandError("Pick one: threading or forking.")
if socket_file and network_socket:
raise CommandError("Only one socket allowed at a time")
if threading:
server_type = "threading"
elif forking:
server_type = "forking"
else:
server_type = "single-threaded"
self.stdout.write("Server type: %s\n" % (server_type, ))
if socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write("Binding to unix socket: %s\n" % (socket_file, ))
if threading:
server = SocketServer.ThreadingUnixStreamServer(
socket_file, EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = ForkingUnixStreamServer(socket_file,
EventNormalizeHandler)
else:
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(":")
port = int(port)
self.stdout.write("Binding to network socket: %s:%s\n" %
(host, port))
if threading:
server = SocketServer.ThreadingTCPServer((host, port),
EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = SocketServer.ForkingTCPServer((host, port),
EventNormalizeHandler)
else:
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError("No connection option specified")
server.serve_forever()
def handle(self, **options):
socket_file = options.get('socket_file')
network_socket = options.get('network_socket')
threading = options.get('threading')
forking = options.get('forking')
if threading and forking:
raise CommandError('Pick one: threading or forking.')
if socket_file and network_socket:
raise CommandError('Only one socket allowed at a time')
if threading:
server_type = 'threading'
elif forking:
server_type = 'forking'
else:
server_type = 'single-threaded'
self.stdout.write('Server type: %s\n' % (server_type, ))
if socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write('Binding to unix socket: %s\n' % (socket_file, ))
if threading:
server = SocketServer.ThreadingUnixStreamServer(
socket_file, EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = ForkingUnixStreamServer(socket_file,
EventNormalizeHandler)
else:
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(':')
port = int(port)
self.stdout.write('Binding to network socket: %s:%s\n' %
(host, port))
if threading:
server = SocketServer.ThreadingTCPServer((host, port),
EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = SocketServer.ForkingTCPServer((host, port),
EventNormalizeHandler)
else:
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError('No connection option specified')
server.serve_forever()
def run():
#for i in range(20):
# t = proc_tran(queue)
# t.setDaemon(True)
# t.start()
#
server_address = os.path.join(tempfile.gettempdir(), 'addr_server_socket')
if os.access(server_address, 0):
os.remove(server_address)
try:
server = SocketServer.UnixStreamServer(server_address, MyHandler)
server.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
def setup_socket(server_address, q):
try:
os.unlink(server_address)
except OSError:
if os.path.exists(server_address):
raise
server = SocketServer.UnixStreamServer(server_address,
SocketRequestHandler)
os.chmod(server_address, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
server.q = q
t = threading.Thread(target=server.serve_forever)
t.setDaemon(True) # don't hang on exit
t.start()
return server
def start_inner(args): try: os.unlink(UNIX_SOCK) except OSError: if os.path.exists(UNIX_SOCK): print "[inner] ERR file %s cannot be removed."%(UNIX_SOCK) print "[inner] Interface failed." return threading.Timer(TIMER_SECS, reset_pid).start() if TIMER_CK_ID == SELF_ID: print "[inner] check point will be done in every %d seconds."%(CK_TIMER_SECS) threading.Timer(CK_TIMER_SECS, timer_checkpoint).start() print "[inner] Interface(%s) will start."%(UNIX_SOCK) srv = SocketServer.UnixStreamServer(UNIX_SOCK,InnerHandler) srv.serve_forever()
def main():
signal.signal(signal.SIGTERM, sig_handler)
signal.signal(signal.SIGINT, sig_handler)
start_update_loop()
# Ensure the socket directory exists
mkdir_p(os.path.dirname(PLUGIN_UNIX_SOCK))
# Remove existing socket in case it was left behind
delete_socket_file()
# Listen for connections on the unix socket
server = SocketServer.UnixStreamServer(PLUGIN_UNIX_SOCK, Handler)
try:
server.serve_forever()
except:
delete_socket_file()
raise
def main():
socketpath = sys.argv[1]
testnum = int(sys.argv[2])
if testnum == 1:
pathend = 'text_device_xml'
if testnum == 2:
pathend = 'email_address_xml'
if testnum == 3:
pathend = 'no_friendlyname_xml'
if testnum == 4:
pathend = 'ssdp_device_xml'
h = ThreadingHTTPServer(('', 0), HttpHandler)
sn = h.socket.getsockname()
port = sn[1]
url = 'http://127.0.0.1:%d/%s' % (port, pathend)
st = 'server type'
uuid = 'uuid goes here'
if testnum == 4:
minissdpd_response[0] = [0]
else:
minissdpd_response[0] = [1]
minissdpd_response[0].extend([len(url)] + list(url))
minissdpd_response[0].extend([len(st)] + list(st))
minissdpd_response[0].extend([len(uuid)] + list(uuid))
notify_text[0] = notify_template % url
h_thread = threading.Thread(target=h.serve_forever)
h_thread.daemon = True
h_thread.start()
d = ThreadingUdpServer(('', 1900), UdpHandler)
d.socket.setsockopt(
socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP,
socket.inet_pton(socket.AF_INET, '239.255.255.250') +
socket.inet_pton(socket.AF_INET, '0.0.0.0'))
d_thread = threading.Thread(target=d.serve_forever)
d_thread.daemon = True
d_thread.start()
u = SocketServer.UnixStreamServer(socketpath, UnixHandler)
while keep_running[0]:
u.handle_request()
def run(self):
"""Start listening in options['path'] and spawn handler per connection.
Your remotebackend handler class is rebuilt between connections."""
if 'path' in self.options:
path = self.options['path']
else:
path = '/tmp/remotebackend.sock'
if os.path.exists(path):
os.remove(path)
s = SocketServer.UnixStreamServer(path, UnixRequestHandler, False)
s.rpc_handler = self.handler
s.rpc_options = self.options
s.server_bind()
s.server_activate()
try:
s.serve_forever()
except (KeyboardInterrupt, SystemExit):
pass
os.remove(path)
def handle(self, **options):
socket_file = options.get('socket_file')
network_socket = options.get('network_socket')
if socket_file and network_socket:
raise CommandError('Only one socket allowed at a time')
elif socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write('Binding to unix socket: %s' % (socket_file, ))
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(':')
port = int(port)
self.stdout.write('Binding to network socket: %s:%s' %
(host, port))
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError('No connection option specified')
server.serve_forever()
class RequestHandler(SocketServer.StreamRequestHandler):
def handle(self):
# redirect stdout to string
sys.stdout = buf = StringIO()
data = self.rfile.readline().strip().split(' ')
command = data[0]
tags = data[1:]
if command == "tag":
tag(tags)
elif command == "save":
save(tags)
elif command == "search":
search(tags)
self.wfile.write(buf.getvalue())
buf.close()
if __name__ == '__main__':
init_db()
server = SocketServer.UnixStreamServer("./socket", RequestHandler)
try:
server.serve_forever()
finally:
sys.stdout = sys.__stdout__
os.remove('./socket')
#!/usr/bin/python
#coding:utf-8
import SocketServer
import os
import time
class MyHandler(SocketServer.BaseRequestHandler):
def handle(self):
print self.request.recv(1024)
time.sleep(10)
self.request.send("welcome!!!")
addr_path = './unix.sock'
if os.path.exists(addr_path):
os.remove(addr_path)
server = SocketServer.UnixStreamServer(addr_path, MyHandler)
server.serve_forever()
if data == '':
break
# socket = self.request[1]
# print "{} wrote:".format(self.client_address[0])
# socket.sendto(data.upper(), self.client_address)
#class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.UnixStreamServer):
# pass
if __name__ == "__main__":
HOST, PORT = "localhost", 9999
PATH = '/home/brbt/ipc/udp/comm2oma'
# PATH = 'omc_trace'
try:
os.unlink(PATH)
except OSError:
if os.path.exists(PATH):
raise
# server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)
server = SocketServer.UnixStreamServer(PATH, MyUDPHandler)
# server = ThreadedTCPServer(PATH, MyUDPHandler)
# server_thread = threading.Thread(target=server.serve_forever)
# server_thread.daemon = True
# server_thread.start()
server.serve_forever()
# print "Server loop running in thread:", server_thread.name
# server.shutdown()
# server.server_close()
except omega.PharosEDIException as e:
self.wfile.write("EINTERNAL: %s\n" % (str(e)))
return
self.wfile.write("OK: %s\n" % (rval))
else:
self.wfile.write("ESYN: Unknown command %s" % (cmd))
if __name__ == "__main__":
try:
if os.path.exists(SOCKNAME):
os.remove(SOCKNAME)
except OSError as e:
print >> sys.stderr, "Couldn't remove socket (%s): %s" % (SOCKNAME,
str(e))
sys.exit(1)
server = SocketServer.UnixStreamServer(SOCKNAME, PharosConnector)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
try:
if os.path.exists(SOCKNAME):
os.remove(SOCKNAME)
except OSError as e:
print >> sys.stderr, "Couldn't remove socket (%s): %s" % (SOCKNAME,
str(e))
sys.exit(1)
sys.exit(0)
def main():
# 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)
log = logging.getLogger('qmemman.daemon')
usage = "usage: %prog [options]"
parser = OptionParser(usage)
parser.add_option("-c",
"--config",
action="store",
dest="config",
default=config_path)
parser.add_option("-d",
"--debug",
action="store_true",
dest="debug",
default=False,
help="Enable debugging")
(options, args) = parser.parse_args()
if options.debug:
logging.root.setLevel(logging.DEBUG)
# close io
sys.stdin.close()
sys.stdout.close()
sys.stderr.close()
config = SafeConfigParser({
'vm-min-mem':
str(qmemman_algo.MIN_PREFMEM),
'dom0-mem-boost':
str(qmemman_algo.DOM0_MEM_BOOST),
'cache-margin-factor':
str(qmemman_algo.CACHE_FACTOR)
})
config.read(options.config)
if config.has_section('global'):
qmemman_algo.MIN_PREFMEM = parse_size(
config.get('global', 'vm-min-mem'))
qmemman_algo.DOM0_MEM_BOOST = parse_size(
config.get('global', 'dom0-mem-boost'))
qmemman_algo.CACHE_FACTOR = config.getfloat(
'global', 'cache-margin-factor')
log.info('MIN_PREFMEM={qmemman_algo.MIN_PREFMEM}'
' DOM0_MEM_BOOST={qmemman_algo.DOM0_MEM_BOOST}'
' CACHE_FACTOR={qmemman_algo.CACHE_FACTOR}'.format(
qmemman_algo=qmemman_algo))
try:
os.unlink(SOCK_PATH)
except:
pass
log.debug('instantiating server')
os.umask(0)
server = SocketServer.UnixStreamServer(SOCK_PATH, QMemmanReqHandler)
os.umask(077)
# 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("READY=1")
s.close()
thread.start_new_thread(start_server, tuple([server]))
XS_Watcher().watch_loop()
import SocketServer
from struct import unpack
from os import unlink
from gen import msg_pb2
address = './socket'
class Session(SocketServer.BaseRequestHandler):
def handle(self):
header = self.request.recv(4)
message_length, = unpack('>I', header) #unpack always returns a tuple.
print(message_length)
message = self.request.recv(message_length)
pb_message = msg_pb2.Boring()
pb_message.ParseFromString(message)
print("Message: " + pb_message.cont)
try:
unlink(address)
except OSError as e:
pass
server = SocketServer.UnixStreamServer(address, Session)
server.serve_forever()
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"
