def run(self, root_page):
root_dir = os.environ['PACKAGE_ROOT_DIR']
site = Site(root_page)
reactor.listenUNIX(os.path.join(root_dir, 'run', 'twisted.0.sock'),
site)
reactor.run()
def create_server(q, address_type, factory=None, block_reading=False,
streamfile='stream'):
if factory is None:
factory = EventProtocolFactory(q, block_reading)
if address_type == cs.SOCKET_ADDRESS_TYPE_UNIX:
# don't use os.getcwd() here because it can be quite long and
# can easily hit the AF_UNIX max path length.
path = tempfile.mkstemp(suffix=streamfile)[1]
try:
os.remove(path)
except OSError as e:
if e.errno != errno.ENOENT:
raise
reactor.listenUNIX(path, factory)
_to_cleanup.append(path)
return dbus.ByteArray(path.encode())
elif address_type == cs.SOCKET_ADDRESS_TYPE_IPV4:
for port in range(5000,6000):
try:
reactor.listenTCP(port, factory, interface='localhost')
except CannotListenError:
continue
else:
return ('127.0.0.1', dbus.UInt16(port))
else:
assert False
def startSocketServer(root_node, shutdownOnLastDisconnect, interactive, socket=None, extra_loggers=None):
"""
Bind the first available unix socket.
Return the socket file.
"""
# Create protocol factory.
factory = Factory()
factory.connectionPool = set() # List of currently, active connections
factory.protocol = CliClientProtocol
factory.shutdownOnLastDisconnect = shutdownOnLastDisconnect
factory.root_node = root_node
factory.interactive = interactive
factory.extra_loggers = extra_loggers or []
factory.runtime_options = Options()
# Listen on socket.
if socket:
reactor.listenUNIX(socket, factory)
else:
# Find a socket to listen on. (if no socket was given.)
i = 0
while True:
try:
socket = '/tmp/deployer.sock.%s.%i' % (getpass.getuser(), i)
reactor.listenUNIX(socket, factory)
break
except CannotListenError:
i += 1
# When 100 times failed, cancel server
if i == 100:
logging.warning('100 times failed to listen on posix socket. Please clean up old sockets.')
raise
return socket
def __init__(self, argv):
appConcSoc = "tmpSoc"
id = "conc"
self.cbFactory = Factory()
self.cbFactory.protocol = cbAdaptorProtocol
reactor.listenUNIX(appConcSoc, self.cbFactory)
reactor.run()
def daemon_main(self):
if config.logreqs:
self.logfile_access = logfile.DailyLogFile.fromFullPath(os.path.join(config.datadir, 'logs', 'access.log'))
else:
self.logfile_access = log.NullFile()
if config.debugmode:
if config.debugtostdout and config.nodaemon:
self.logfile_debug = sys.stdout
else:
self.logfile_debug = logfile.DailyLogFile.fromFullPath(os.path.join(config.datadir, 'logs', 'debug.log'))
else:
self.logfile_debug = log.NullFile()
log.startLogging(self.logfile_debug)
reactor.listenTCPonExistingFD = listenTCPonExistingFD
reactor.listenUNIX(os.path.join(config.rundir, 'rpc.socket'), factory=pb.PBServerFactory(self.rpc_server))
for i in range(config.processes):
subprocess = spawnT2W(self, self.childFDs, self.fds_https, self.fds_http)
self.subprocesses.append(subprocess.pid)
def MailException(etype, value, tb):
sendexceptionmail(config, etype, value, tb)
sys.excepthook = MailException
reactor.run()
def startSocketServer(root_node, shutdownOnLastDisconnect, interactive, socket=None, extra_loggers=None):
"""
Bind the first available unix socket.
Return the socket file.
"""
# Create protocol factory.
factory = Factory()
factory.connectionPool = set() # List of currently, active connections
factory.protocol = CliClientProtocol
factory.shutdownOnLastDisconnect = shutdownOnLastDisconnect
factory.root_node = root_node
factory.interactive = interactive
factory.extra_loggers = extra_loggers or []
factory.runtime_options = Options()
# Listen on socket.
if socket:
reactor.listenUNIX(socket, factory)
else:
# Find a socket to listen on. (if no socket was given.)
i = 0
while True:
try:
socket = "/tmp/deployer.sock.%s.%i" % (getpass.getuser(), i)
reactor.listenUNIX(socket, factory)
break
except CannotListenError:
i += 1
# When 100 times failed, cancel server
if i == 100:
logging.warning("100 times failed to listen on posix socket. Please clean up old sockets.")
raise
return socket
def daemon_main(self):
if config.logreqs:
self.logfile_access = logfile.DailyLogFile.fromFullPath(os.path.join(config.datadir, 'logs', 'access.log'))
else:
self.logfile_access = log.NullFile()
if config.debugmode:
if config.debugtostdout and config.nodaemon:
self.logfile_debug = sys.stdout
else:
self.logfile_debug = logfile.DailyLogFile.fromFullPath(os.path.join(config.datadir, 'logs', 'debug.log'))
else:
self.logfile_debug = log.NullFile()
log.startLogging(self.logfile_debug)
reactor.listenTCPonExistingFD = listenTCPonExistingFD
reactor.listenUNIX(os.path.join(config.rundir, 'rpc.socket'), factory=pb.PBServerFactory(self.rpc_server))
for i in range(config.processes):
subprocess = spawnT2W(self, self.childFDs, self.fds_https, self.fds_http)
self.subprocesses.append(subprocess.pid)
def MailException(etype, value, tb):
sendexceptionmail(config, etype, value, tb)
sys.excepthook = MailException
reactor.run()
def main():
factory = Echo()
reactor.listenUNIX(
'/home/user/test.sock',
factory,
)
reactor.run()
def krb5keytabproxy(sock_path, krb5keytab_server, keytab_dir):
"""Run krb5keytab proxy server."""
if not sock_path:
sock_path = _DEFAULT_SOCK_PATH
if not keytab_dir:
keytab_dir = _DEFAULT_KEYTAB_DIR
# Check the keytab dir is owned by root.
stat = os.stat(keytab_dir)
if stat.st_uid != 0 or stat.st_gid != 0:
_LOGGER.warning('Keytab directory must be owned by root: %s',
keytab_dir)
sys.exit(-1)
fs.rm_safe(sock_path)
os.environ['KRB5CCNAME'] = 'FILE:/tmp/krb5cc_host_krb5keytab_proxy'
def _refresh_krbcc():
"""Refresh host credentials."""
subproc.check_call(['kinit', '-k'])
task.LoopingCall(_refresh_krbcc).start(_HOST_CREDS_REFRESH_INTERVAL)
reactor.listenUNIX(
sock_path,
Krb5KeytabProxyFactory(list(krb5keytab_server), keytab_dir))
reactor.run()
def cbConfigure(self, config):
"""Config is based on what apps are available."""
#logging.debug("%s %s Configuration: %s ", ModuleName, self.id, config)
self.name = config["name"]
self.friendly_name = config["friendly_name"]
self.device = config["btAdpt"]
self.addr = config["btAddr"]
self.sim = int(config["sim"])
for app in config["apps"]:
iName = app["id"]
if iName not in self.appInstances:
# configureig may be called again with updated config
name = app["name"]
adtSoc = app["adtSoc"]
self.appInstances.append(iName)
self.cbFactory[iName] = CbServerFactory(self.onAppMessage)
reactor.listenUNIX(adtSoc, self.cbFactory[iName])
if "zwave_socket" in config:
initMsg = {"id": self.id, "request": "init"}
self.zwaveFactory = CbClientFactory(self.onZwaveMessage, initMsg)
reactor.connectUNIX(config["zwave_socket"],
self.zwaveFactory,
timeout=30)
self.onConfigureMessage(config)
self.configured = True
def run(self):
self.factory = HTTPFactory(
self.channel_layer,
self.action_logger,
timeout=self.http_timeout,
websocket_timeout=self.websocket_timeout,
ping_interval=self.ping_interval,
ping_timeout=self.ping_timeout,
ws_protocols=self.ws_protocols,
root_path=self.root_path,
)
# Redirect the Twisted log to nowhere
globalLogBeginner.beginLoggingTo([lambda _: None],
redirectStandardIO=False,
discardBuffer=True)
# Listen on a socket
if self.unix_socket:
reactor.listenUNIX(self.unix_socket, self.factory)
elif self.file_descriptor:
# socket returns the same socket if supplied with a fileno
sock = socket.socket(fileno=self.file_descriptor)
reactor.adoptStreamPort(self.file_descriptor, sock.family,
self.factory)
else:
reactor.listenTCP(self.port, self.factory, interface=self.host)
if "twisted" in self.channel_layer.extensions:
logging.info("Using native Twisted mode on channel layer")
reactor.callLater(0, self.backend_reader_twisted)
else:
logging.info("Using busy-loop synchronous mode on channel layer")
reactor.callLater(0, self.backend_reader_sync)
reactor.callLater(2, self.timeout_checker)
reactor.run(installSignalHandlers=self.signal_handlers)
def run(self):
self.factory = HTTPFactory(
self.channel_layer,
self.action_logger,
timeout=self.http_timeout,
websocket_timeout=self.websocket_timeout,
ping_interval=self.ping_interval,
ws_protocols=self.ws_protocols,
root_path=self.root_path,
)
# Redirect the Twisted log to nowhere
globalLogBeginner.beginLoggingTo([lambda _: None], redirectStandardIO=False, discardBuffer=True)
# Listen on a socket
if self.unix_socket:
reactor.listenUNIX(self.unix_socket, self.factory)
elif self.file_descriptor:
# socket returns the same socket if supplied with a fileno
sock = socket.socket(fileno=self.file_descriptor)
reactor.adoptStreamPort(self.file_descriptor, sock.family, self.factory)
else:
reactor.listenTCP(self.port, self.factory, interface=self.host)
if "twisted" in self.channel_layer.extensions:
logging.info("Using native Twisted mode on channel layer")
reactor.callLater(0, self.backend_reader_twisted)
else:
logging.info("Using busy-loop synchronous mode on channel layer")
reactor.callLater(0, self.backend_reader_sync)
reactor.callLater(2, self.timeout_checker)
reactor.run(installSignalHandlers=self.signal_handlers)
def kajonggServer():
"""start the server"""
# pylint: disable=too-many-branches
options = parseArgs()
if not initDb():
sys.exit(1)
realm = MJRealm()
realm.server = MJServer()
kajonggPortal = portal.Portal(realm, [DBPasswordChecker()])
import predefined
predefined.load()
try:
if Options.socket:
# we do not want tracebacks to go from server to client,
# please check on the server side instead
factory = pb.PBServerFactory(kajonggPortal, unsafeTracebacks=False)
if os.name == 'nt':
if Debug.connections:
logDebug('local server listening on 127.0.0.1 port %d' %
options.port)
reactor.listenTCP(options.port, factory, interface='127.0.0.1')
else:
if Debug.connections:
logDebug('local server listening on UNIX socket %s' %
Options.socket)
reactor.listenUNIX(Options.socket, factory)
else:
if Debug.connections:
logDebug('server listening on port %d' % options.port)
reactor.listenTCP(options.port, pb.PBServerFactory(kajonggPortal))
except error.CannotListenError as errObj:
logWarning(errObj)
sys.exit(1)
else:
reactor.run()
def run(self):
"""
Start the server and listen on host:port
"""
f = None
unix_prefix = 'unix://'
if self.http_enabled:
rpc = JsonRpcHttpResource()
rpc.rpcprocessor = self.rpcprocessor
rpc.tls_client_auth_enabled = self.tls_client_auth_enabled
if self.http_basic_auth_enabled:
checker = PasswordChecker(self.passwdCheckFunction)
realm = HttpPasswordRealm(rpc)
p = portal.Portal(realm, [checker])
realm_name = 'Reflect RPC'
if sys.version_info.major == 2:
realm_name = realm_name.encode('utf-8')
credentialFactory = BasicCredentialFactory(realm_name)
rpc = HTTPAuthSessionWrapper(p, [credentialFactory])
root = RootResource(rpc)
f = server.Site(root)
else:
f = JsonRpcProtocolFactory(self.rpcprocessor,
self.tls_client_auth_enabled)
if self.tls_enabled:
if not self.tls_client_auth_enabled:
reactor.listenSSL(self.port,
f,
self.cert.options(),
interface=self.host)
else:
reactor.listenSSL(self.port,
f,
self.cert.options(self.client_auth_ca),
interface=self.host)
else:
if self.host.startswith(unix_prefix):
path = self.host[len(unix_prefix):]
reactor.listenUNIX(path,
f,
backlog=self.unix_socket_backlog,
mode=self.unix_socket_mode,
wantPID=self.unix_socket_want_pid)
else:
reactor.listenTCP(self.port, f, interface=self.host)
if self.host.startswith(unix_prefix):
print("Listening on %s" % (self.host))
else:
print("Listening on %s:%d" % (self.host, self.port))
reactor.run()
def main():
"""main() function to execute the server
Params:
* urls: a list of urls to push into the download queue
"""
if os.path.exists(urldrop_path()):
print("The server is already running")
return
logging.basicConfig(filename=os.path.join(runtime_base_path(), 'dman.log'),
level=logging.DEBUG)
logging.info("Starting dman")
dman = DMan()
signal.signal(signal.SIGTERM, shutdownDaemon)
signal.signal(signal.SIGINT, shutdownDaemon)
reactor.listenUNIX(urldrop_path(), UrlDropFactory(dman))
reactor.run()
logging.info("Shutting down")
try:
os.unlink(ipc_path())
os.unlink(urldrop_path())
except OSError:
pass
def setup(self):
socket = self.parent.socket
if os.path.exists(socket):
os.remove(socket)
self.factory = UserServerFactory(self.parent)
reactor.listenUNIX(socket,
self.factory,
mode=self.parent.config.get_umask('sock'))
def test():
if stat.S_ISSOCK(os.fstat(fastcgi.FCGI_LISTENSOCK_FILENO)[stat.ST_MODE]):
raise Exception('using pre-set fastcgi environment is not yet supported')
fac = twistedfcgi.FastCGIFactory(handler)
#reactor.listenTCP(8030, fac)
reactor.listenUNIX('fcgi.socket', fac)
reactor.run()
def autostart(reason, **kwargs):
if reason == 0:
try:
os.remove("/tmp/hotplug.socket")
except (IOError, OSError):
pass
factory = Factory()
factory.protocol = Hotplug
reactor.listenUNIX("/tmp/hotplug.socket", factory)
def run():
service = Place
print("Start place_info Service")
reactor.listenUNIX(PLACEINFO_UNIX_DOMAIN, PlaceInfoFactory(service))
try:
reactor.run()
except Exception, err:
logger.info(err)
def cbConnect(self, directoryService):
"""
Callback from the directory service.
From this point we're connected and authenticated.
"""
basepath = FilePath(os.path.expanduser('~/.distfs'))
if not basepath.exists():
basepath.createDirectory()
store = FileSystemStore(basepath.child('store').path)
chunkFactory = Site(server.StoreResource(store))
locname = self['alias'] or directoryService.service
# Listen for remote connections. This is for the other nodes
# to access our store.
port = self['port'] and int(self['port']) or 0
listeningPort = reactor.listenTCP(port, chunkFactory)
keyStore = SQLiteDataStore(basepath.child('%s.db' % locname).path)
dhtNode = KademliaNode(listeningPort.getHost().port,
keyStore,
reactor=reactor)
# Listen locally so that applications can easily access the
# store.
reactor.listenUNIX(
basepath.child('%s.http' % locname).path, chunkFactory)
resolverPublisher = ResolverPublisher(dhtNode)
controlFactory = control.ControlFactory(store, directoryService,
dhtNode, resolverPublisher)
reactor.listenUNIX(
basepath.child('%s.ctrl' % locname).path, controlFactory)
# Start a looping call that will publish chunks to the
# overlay; do that every 6th hour. Delay the procedure a bit
# so that the node has a chance to join the network.
looping = task.LoopingCall(publishChunks, store, resolverPublisher)
reactor.callLater(10, looping.start, 6 * 60 * 60, True)
# Try joining the network.
introducers = list()
if self['introducer']:
try:
address, port = self['introducer'].split(':')
except ValueError:
address, port = self['introducer'], 8033
introducers.append((address, int(port)))
dhtNode.joinNetwork(introducers)
# At this point everything that can go (majorly) wrong has
# been initialized and we can daemonize.
if not self['no-daemon']:
daemonize()
def run():
service = TagRankService()
print("Start relation Service")
reactor.listenUNIX(RELATIONS_UNIX_DOMAIN, RelationFactory(service))
try:
reactor.run()
except Exception, err:
logger.info(err)
def cbConnect(self, directoryService):
"""
Callback from the directory service.
From this point we're connected and authenticated.
"""
basepath = FilePath(os.path.expanduser('~/.distfs'))
if not basepath.exists():
basepath.createDirectory()
store = FileSystemStore(basepath.child('store').path)
chunkFactory = Site(server.StoreResource(store))
locname = self['alias'] or directoryService.service
# Listen for remote connections. This is for the other nodes
# to access our store.
port = self['port'] and int(self['port']) or 0
listeningPort = reactor.listenTCP(port, chunkFactory)
keyStore = SQLiteDataStore(basepath.child('%s.db' % locname).path)
dhtNode = KademliaNode(listeningPort.getHost().port, keyStore,
reactor=reactor)
# Listen locally so that applications can easily access the
# store.
reactor.listenUNIX(basepath.child('%s.http' % locname).path,
chunkFactory)
resolverPublisher = ResolverPublisher(dhtNode)
controlFactory = control.ControlFactory(store, directoryService,
dhtNode, resolverPublisher)
reactor.listenUNIX(basepath.child('%s.ctrl' % locname).path,
controlFactory)
# Start a looping call that will publish chunks to the
# overlay; do that every 6th hour. Delay the procedure a bit
# so that the node has a chance to join the network.
looping = task.LoopingCall(publishChunks, store, resolverPublisher)
reactor.callLater(10, looping.start, 6*60*60, True)
# Try joining the network.
introducers = list()
if self['introducer']:
try:
address, port = self['introducer'].split(':')
except ValueError:
address, port = self['introducer'], 8033
introducers.append((address, int(port)))
dhtNode.joinNetwork(introducers)
# At this point everything that can go (majorly) wrong has
# been initialized and we can daemonize.
if not self['no-daemon']:
daemonize()
def __init__(self, command_cb, address = None, sock_owner = None):
self.command_cb = command_cb
self.protocol = Cli_session
if address == None:
address = '/var/run/ccm.sock'
if exists(address):
unlink(address)
reactor.listenUNIX(address, self)
if sock_owner != None:
chown(address, sock_owner[0], sock_owner[1])
def autostart(reason, **kwargs):
if reason == 0:
from twisted.internet import reactor
try:
os.remove("/tmp/hotplug.socket")
except OSError:
pass
factory = Factory()
factory.protocol = Hotplug
reactor.listenUNIX("/tmp/hotplug.socket", factory)
def autostart(reason, **kwargs):
if reason == 0:
from twisted.internet import reactor
try:
os.remove("/tmp/hotplug.socket")
except OSError:
pass
factory = Factory()
factory.protocol = Hotplug
reactor.listenUNIX("/tmp/hotplug.socket", factory)
def __init__(self, command_cb, address=None, sock_owner=None):
self.command_cb = command_cb
self.protocol = Cli_session
if address == None:
address = '/var/run/ccm.sock'
if exists(address):
unlink(address)
reactor.listenUNIX(address, self)
if sock_owner != None:
chown(address, sock_owner[0], sock_owner[1])
def run():
wordseg = WordSegService()
relations = TagService()
print("Start WordSeg Service")
reactor.listenUNIX(WORDSEG_UNIX_DOMAIN, WordSegFactory(wordseg, relations))
try:
reactor.run()
except Exception, err:
logger.info(err)
def autostart(reason, **kwargs):
if reason == 0:
try:
if not os.path.exists("/tmp/hotplug.socket"):
return
except (IOError, OSError):
pass
factory = Factory()
factory.protocol = Hotplug
reactor.listenUNIX("/tmp/hotplug.socket", factory)
def _run_manhole(self):
# This condition is made with the assumption that no existing daemon
# is running. If there is one, the following code could potentially
# cause problems for the other daemon by removing its socket.
if os.path.exists(self.manhole_sock):
log.info('Removing orphaned manhole socket')
os.remove(self.manhole_sock)
self.manhole = make_manhole(dict(trond=self, mcp=self.mcp))
reactor.listenUNIX(self.manhole_sock, self.manhole)
log.info(f"manhole started on {self.manhole_sock}")
def _run_manhole(self):
# This condition is made with the assumption that no existing daemon
# is running. If there is one, the following code could potentially
# cause problems for the other daemon by removing its socket.
if os.path.exists(self.manhole_sock):
log.info('Removing orphaned manhole socket')
os.remove(self.manhole_sock)
self.manhole = make_manhole(dict(trond=self, mcp=self.mcp))
reactor.listenUNIX(self.manhole_sock, self.manhole)
log.info(f"manhole started on {self.manhole_sock}")
def listen(self): server = ModuleServer(self.options.module) # ensure that the UNIX socket is only accessable by root old_umask = umask(0077) try: reactor.listenUNIX(self.options.socket, server) finally: umask(old_umask) notifier.loop()
def run(self):
"""
Start the server and listen on host:port
"""
f = None
unix_prefix = 'unix://'
if self.http_enabled:
rpc = JsonRpcHttpResource()
rpc.rpcprocessor = self.rpcprocessor
rpc.tls_client_auth_enabled = self.tls_client_auth_enabled
if self.http_basic_auth_enabled:
checker = PasswordChecker(self.passwdCheckFunction)
realm = HttpPasswordRealm(rpc)
p = portal.Portal(realm, [checker])
realm_name = 'Reflect RPC'
if sys.version_info.major == 2:
realm_name = realm_name.encode('utf-8')
credentialFactory = BasicCredentialFactory(realm_name)
rpc = HTTPAuthSessionWrapper(p, [credentialFactory])
root = RootResource(rpc)
f = server.Site(root)
else:
f = JsonRpcProtocolFactory(self.rpcprocessor,
self.tls_client_auth_enabled)
if self.tls_enabled:
if not self.tls_client_auth_enabled:
reactor.listenSSL(self.port, f, self.cert.options(),
interface=self.host)
else:
reactor.listenSSL(self.port, f,
self.cert.options(self.client_auth_ca),
interface=self.host)
else:
if self.host.startswith(unix_prefix):
path = self.host[len(unix_prefix):]
reactor.listenUNIX(path, f, backlog=self.unix_socket_backlog,
mode=self.unix_socket_mode, wantPID=self.unix_socket_want_pid)
else:
reactor.listenTCP(self.port, f, interface=self.host)
if self.host.startswith(unix_prefix):
print("Listening on %s" % (self.host))
else:
print("Listening on %s:%d" % (self.host, self.port))
reactor.run()
def main():
args = sys.argv[1: ]
config = Config(args)
comet_server = CometServer(config)
site = server.Site(comet_server, timeout = config.http_timeout)
if config.http_port != None:
reactor.listenTCP(config.http_port, site)
if config.unix_socket_path != None:
reactor.listenUNIX(config.unix_socket_path, site)
reactor.run()
def start_server():
startLogging(sys.stdout)
serverFactory = protocol.ServerFactory()
serverFactory.protocol = WaitForQueries
try:
remove(pipe_filepath)
except:
pass
reactor.listenUNIX(pipe_filepath, serverFactory)
reactor.run()
def autostart(reason, **kwargs):
if reason == 0:
print "starting hotplug handler"
factory = Factory()
factory.protocol = Hotplug
try:
import os
os.remove("/tmp/hotplug.socket")
except OSError:
pass
reactor.listenUNIX("/tmp/hotplug.socket", factory)
def main():
# Parse options
parser = OptionParser()
parser.add_option(
"--config-file", help="Path to configuration file", default=os.path.expanduser("~/.config/melissi/config")
)
parser.add_option("--no-desktop", help="Disable desktop", action="store_true", default=False)
parser.add_option(
"-v",
"--verbosity",
help="Verbose debug messages. Use multiple for more verbose messages",
action="count",
dest="verbosity",
default=0,
)
(options, _) = parser.parse_args()
# parse verbosity level and set logging
if options.verbosity == 0:
setup_logging(20)
elif options.verbosity == 1:
setup_logging(10)
elif options.verbosity == 2:
setup_logging(5)
elif options.verbosity >= 3:
setup_logging(4)
elif options.quiet == True:
setup_logging(30)
hub = Hub()
hub.queue = queue.Queue(hub)
hub.config_manager = config.ConfigManager(hub, os.path.expanduser(options.config_file))
hub.database_manager = database.DatabaseManager(hub, hub.config_manager.get_database())
hub.notify_manager = notifier.NotifyManager(hub)
hub.desktop_tray = desktop.DesktopTray(
hub, disable=hub.config_manager.config.get("main", "no-desktop") == "True" or options.no_desktop
)
hub.worker = worker.Worker(hub)
hub.rest_client = restclient.RestClient(hub)
hub.watch_dog = watchdog.WatchDog(hub)
# enable commander
command_receiver = commander.FooboxCommandReceiver(hub)
socket_path = hub.config_manager.get_socket()
if socket_path:
try:
reactor.listenUNIX(socket_path, command_receiver)
except twisted.internet.error.CannotListenError, error_message:
print "Cannot use this socket. Please specify another socket"
sys.exit(1)
def initialize():
"""
Starts the server main loop.
"""
from twisted.internet import reactor
from twisted.python.logfile import LogFile
import sys
import os,os.path
# load our run-time configuration
import tops.core.utility.config as config
verbose = config.initialize()
# use file-based logging for ourself (print statements are automatically redirected)
logpath = config.getfilename('logger','logfile')
if not logpath or logpath == 'stdout':
log.startLogging(sys.stdout)
else:
(logpath,logfile) = os.path.split(logpath)
log.startLogging(LogFile(logfile,logpath))
print 'Executing',__file__,'as PID',os.getpid()
try:
# create a record buffer to connect our feed watchers to our clients
feed = FeedBuffer()
# initialize socket servers to listen for local and network log message producers
factory = Factory()
factory.protocol = LogServer
factory.feed = feed
reactor.listenTCP(config.getint('logger','tcp_port'),factory)
reactor.listenUNIX(config.getfilename('logger','unix_addr'),factory)
# initialize an HTTP server to handle feed watcher requests via http
prepareWebServer(
portNumber = config.getint('logger','http_port'),
handlers = {"feed":FeedUpdate()},
properties = {"feed":feed},
filterLogs = True
)
# fire up the reactor
print 'Waiting for clients...'
reactor.run()
except Exception:
print 'Reactor startup failed'
# How do I release my unix socket cleanly here?
#reactor.stop()
raise
def create_server(q, address_type, factory=None, block_reading=False,
streamfile='stream'):
if factory is None:
factory = EventProtocolFactory(q, block_reading)
if address_type == cs.SOCKET_ADDRESS_TYPE_UNIX:
path = os.getcwd() + '/' + streamfile
try:
os.remove(path)
except OSError, e:
if e.errno != errno.ENOENT:
raise
reactor.listenUNIX(path, factory)
return dbus.ByteArray(path)
def do_setup(self):
props = self.config['properties']
self.socketPath = props.get('path')
self.factory = UnixDomainDumbFactory(self)
# We need to set the pipeline to READY so the multifdsink gets started
self.pipeline.set_state(gst.STATE_READY)
# remove the existing socket
if os.path.exists(self.socketPath):
os.unlink(self.socketPath)
self.log("Starting to listen on UNIX : %s" % self.socketPath)
reactor.listenUNIX(self.socketPath, self.factory)
def kajonggServer():
"""start the server"""
from optparse import OptionParser
parser = OptionParser()
defaultPort = InternalParameters.defaultPort()
parser.add_option('', '--port', dest='port',
help=m18n('the server will listen on PORT (%d)' % defaultPort),
type=int, default=defaultPort)
parser.add_option('', '--socket', dest='socket',
help=m18n('the server will listen on SOCKET'), default=None)
parser.add_option('', '--db', dest='dbpath', help=m18n('name of the database'), default=None)
parser.add_option('', '--local', dest='local', action='store_true',
help=m18n('start a local game server'), default=False)
parser.add_option('', '--continue', dest='continueServer', action='store_true',
help=m18n('do not terminate local game server after last client disconnects'), default=False)
parser.add_option('', '--debug', dest='debug',
help=Debug.help())
(options, args) = parser.parse_args()
if args and ''.join(args):
logWarning(m18n('unrecognized arguments:%1', ' '.join(args)))
sys.exit(2)
InternalParameters.continueServer |= options.continueServer
if options.dbpath:
InternalParameters.dbPath = os.path.expanduser(options.dbpath)
if options.local:
InternalParameters.socket = socketName()
if options.socket:
InternalParameters.socket = options.socket
Debug.setOptions(options.debug)
Query.dbhandle = initDb()
realm = MJRealm()
realm.server = MJServer()
kajonggPortal = portal.Portal(realm, [DBPasswordChecker()])
# pylint: disable=E1101
# pylint thinks reactor is missing listen* and run
loadPredefinedRulesets()
try:
if InternalParameters.socket:
if os.name == 'nt':
logInfo('local server listening on 127.0.0.1 port %d' % options.port)
reactor.listenTCP(options.port, pb.PBServerFactory(kajonggPortal),
interface='127.0.0.1')
else:
logInfo('local server listening on UNIX socket %s' % InternalParameters.socket)
reactor.listenUNIX(InternalParameters.socket, pb.PBServerFactory(kajonggPortal))
else:
logInfo('server listening on port %d' % options.port)
reactor.listenTCP(options.port, pb.PBServerFactory(kajonggPortal))
except error.CannotListenError, errObj:
logWarning(errObj)
def reactor_run(reactor, factory, port, context_factory=None, unix_socket_path=None):
if unix_socket_path:
sock_file = Path(unix_socket_path)
if sock_file.exists():
sock_file.unlink()
reactor.listenUNIX(unix_socket_path, factory)
else:
if context_factory:
log.info("wss secure")
reactor.listenSSL(port, factory, context_factory)
else:
log.info("ws unsecure")
reactor.listenTCP(port, factory)
reactor.run(installSignalHandlers=0)
def do_setup(self):
props = self.config['properties']
self.socketPath = props.get('path')
self.factory = UnixDomainDumbFactory(self)
# We need to set the pipeline to READY so the multifdsink gets started
self.pipeline.set_state(gst.STATE_READY)
# remove the existing socket
if os.path.exists(self.socketPath):
os.unlink(self.socketPath)
self.log("Starting to listen on UNIX : %s" % self.socketPath)
reactor.listenUNIX(self.socketPath, self.factory)
def main():
# Listen on the UNIX socket
f = Factory()
f.protocol = MailProcessor
safe_del('%s/%s' % (ALLFILTERS, FILTERNAME))
reactor.listenUNIX('%s/%s' % (ALLFILTERS, FILTERNAME), f, 10)
# Once started, close fd 3 to let Courier know we're ready
reactor.callLater(0, os.close, 3)
# When stdin is closed, it's time to exit.
s = stdio.StandardIO(DieWhenLost())
# Go!
reactor.run()
def run(self):
self.factory = HTTPFactory(
self.channel_layer,
self.action_logger,
timeout=self.http_timeout,
websocket_timeout=self.websocket_timeout,
ping_interval=self.ping_interval,
)
if self.unix_socket:
reactor.listenUNIX(self.unix_socket, self.factory)
else:
reactor.listenTCP(self.port, self.factory, interface=self.host)
reactor.callLater(0, self.backend_reader)
reactor.callLater(2, self.timeout_checker)
reactor.run(installSignalHandlers=self.signal_handlers)
def run(self):
self.factory = HTTPFactory(
self.channel_layer,
self.action_logger,
timeout=self.http_timeout,
websocket_timeout=self.websocket_timeout,
ping_interval=self.ping_interval,
)
if self.unix_socket:
reactor.listenUNIX(self.unix_socket, self.factory)
else:
reactor.listenTCP(self.port, self.factory, interface=self.host)
reactor.callLater(0, self.backend_reader)
reactor.callLater(2, self.timeout_checker)
reactor.run(installSignalHandlers=self.signal_handlers)
def main():
# Listen on the UNIX socket
f = Factory()
f.protocol = MailProcessor
safe_del("{}/{}".format(ALLFILTERS, FILTERNAME))
reactor.listenUNIX("{}/{}".format(ALLFILTERS, FILTERNAME), f, 10)
# Once started, close fd 3 to let Courier know we're ready
reactor.callLater(0, os.close, 3)
# When stdin is closed, it's time to exit.
stdio.StandardIO(DieWhenLost())
# Go!
reactor.run()
def main():
args = _getArgs()
logging.basicConfig(level=args.log_level,
format='%(asctime)s %(levelname)-s: %(message)s')
logging.addLevelName(5, 'VERBOSE')
if args.remote:
ippool = IPPool(args.remote)
ippool.register(args.local)
else:
ippool = None
on_unix_socket = args.listen.startswith('/')
if on_unix_socket and not args.no_ssl:
logging.error('Listen on UNIX doamin socket require --no-ssl.')
sys.exit(2)
if args.no_ssl:
logging.info('Running without SSL.')
factory = SSTPProtocolFactory(args, remotePool=ippool, certHash=None)
if on_unix_socket:
reactor.listenUNIX(args.listen, factory)
else:
reactor.listenTCP(args.listen_port, factory, interface=args.listen)
else:
cert = _load_cert(args.pem_cert)
sha1 = cert.digest('sha1').replace(':', '').decode('hex')
sha256 = cert.digest('sha256').replace(':', '').decode('hex')
cert_options = cert.options()
if args.ciphers:
cert_options.getContext().set_cipher_list(args.ciphers)
factory = SSTPProtocolFactory(args,
remotePool=ippool,
certHash=[sha1, sha256])
reactor.listenSSL(args.listen_port,
factory,
cert_options,
interface=args.listen)
if args.proxy_protocol:
logging.info('PROXY PROTOCOL is activated.')
if on_unix_socket:
logging.info('Listening on %s...', args.listen)
else:
logging.info('Listening on %s:%s...', args.listen, args.listen_port)
reactor.run()
def setUp(self):
self.hs = yield setup_test_homeserver(
"blue",
http_client=None,
federation_client=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
)
self.hs.get_ratelimiter().send_message.return_value = (True, 0)
self.master_store = self.hs.get_datastore()
self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs)
self.event_id = 0
server_factory = ReplicationStreamProtocolFactory(self.hs)
# XXX: mktemp is unsafe and should never be used. but we're just a test.
path = tempfile.mktemp(prefix="base_slaved_store_test_case_socket")
listener = reactor.listenUNIX(path, server_factory)
self.addCleanup(listener.stopListening)
self.streamer = server_factory.streamer
self.replication_handler = TestReplicationClientHandler(self.slaved_store)
client_factory = ReplicationClientFactory(
self.hs, "client_name", self.replication_handler
)
client_connector = reactor.connectUNIX(path, client_factory)
self.addCleanup(client_factory.stopTrying)
self.addCleanup(client_connector.disconnect)
def initiate_broker(self):
if sys.platform == "win32":
d = defer.succeed(None)
d.addCallback(defer.drop_param, self.become_master)
d.addErrback(self._handle_critical_error)
return d
self._set_idle(False)
if not self._is_standalone:
try:
self.factory = MasterFactory(self)
self.listener = reactor.listenUNIX( #@UndefinedVariable
self.socket_path,
self.factory,
mode=self.socket_mode)
d = defer.succeed(None)
d.addCallback(defer.drop_param, self.become_master)
d.addErrback(self._handle_critical_error)
d.addBoth(defer.bridge_param, self._set_idle, True)
return d
except CannotListenError as e:
self.info('Cannot listen on socket: %r. '\
'Assuming slave role.', e)
return self._connect_as_slave()
elif self._is_standalone:
self.info('Standalone role')
return self._connect_as_slave()
def test_dumber(self):
"""
L{IReactorUNIX.connectUNIX} can be used to connect a client to a server
started with L{IReactorUNIX.listenUNIX}.
"""
filename = self.mktemp()
serverFactory = MyServerFactory()
serverConnMade = defer.Deferred()
serverFactory.protocolConnectionMade = serverConnMade
unixPort = reactor.listenUNIX(filename, serverFactory)
self.addCleanup(unixPort.stopListening)
clientFactory = MyClientFactory()
clientConnMade = defer.Deferred()
clientFactory.protocolConnectionMade = clientConnMade
reactor.connectUNIX(filename, clientFactory)
d = defer.gatherResults([serverConnMade, clientConnMade])
def allConnected(args):
serverProtocol, clientProtocol = args
# Incidental assertion which may or may not be redundant with some
# other test. This probably deserves its own test method.
self.assertEqual(clientFactory.peerAddresses,
[address.UNIXAddress(filename)])
clientProtocol.transport.loseConnection()
serverProtocol.transport.loseConnection()
d.addCallback(allConnected)
return d
def startService(self):
Service.startService(self)
log.info("Starting RPC service...")
self.cleanSocket(None)
self._localPort=reactor.listenUNIX(core.cfg['UNIX_PORT'], pb.PBServerFactory(LocalRPC(self._master)))
self._remotePort=reactor.listenTCP(core.cfg['TCP_PORT'], pb.PBServerFactory(RemoteRPC(self._master)))
def setUp(self):
self.hs = yield setup_test_homeserver(
"blue",
http_client=None,
replication_layer=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
)
self.hs.get_ratelimiter().send_message.return_value = (True, 0)
self.master_store = self.hs.get_datastore()
self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs)
self.event_id = 0
server_factory = ReplicationStreamProtocolFactory(self.hs)
listener = reactor.listenUNIX("\0xxx", server_factory)
self.addCleanup(listener.stopListening)
self.streamer = server_factory.streamer
self.replication_handler = ReplicationClientHandler(self.slaved_store)
client_factory = ReplicationClientFactory(
self.hs, "client_name", self.replication_handler
)
client_connector = reactor.connectUNIX("\0xxx", client_factory)
self.addCleanup(client_factory.stopTrying)
self.addCleanup(client_connector.disconnect)
def testDumber(self):
filename = tempfile.mktemp()
l = reactor.listenUNIX(filename, Factory())
reactor.connectUNIX(filename, TestClientFactory())
for i in xrange(100):
reactor.iterate()
l.stopListening()
def __init__(self):
self.accounting = [
__import__('mediaproxy.interfaces.accounting.%s' % mod.lower(),
globals(), locals(), ['']).Accounting()
for mod in set(DispatcherConfig.accounting)
]
self.cred = X509Credentials(cert_name='dispatcher')
self.tls_context = TLSContext(self.cred)
self.relay_factory = RelayFactory(self)
dispatcher_addr, dispatcher_port = DispatcherConfig.listen
self.relay_listener = reactor.listenTLS(dispatcher_port,
self.relay_factory,
self.tls_context,
interface=dispatcher_addr)
self.opensips_factory = OpenSIPSControlFactory(self)
socket_path = process.runtime.file(DispatcherConfig.socket_path)
unlink(socket_path)
self.opensips_listener = reactor.listenUNIX(socket_path,
self.opensips_factory)
self.opensips_management = opensips.ManagementInterface()
self.management_factory = ManagementControlFactory(self)
management_addr, management_port = DispatcherConfig.listen_management
if DispatcherConfig.management_use_tls:
self.management_listener = reactor.listenTLS(
management_port,
self.management_factory,
self.tls_context,
interface=management_addr)
else:
self.management_listener = reactor.listenTCP(
management_port,
self.management_factory,
interface=management_addr)
def test_dumber(self):
"""
L{IReactorUNIX.connectUNIX} can be used to connect a client to a server
started with L{IReactorUNIX.listenUNIX}.
"""
filename = self.mktemp()
serverFactory = MyServerFactory()
serverConnMade = defer.Deferred()
serverFactory.protocolConnectionMade = serverConnMade
unixPort = reactor.listenUNIX(filename, serverFactory)
self.addCleanup(unixPort.stopListening)
clientFactory = MyClientFactory()
clientConnMade = defer.Deferred()
clientFactory.protocolConnectionMade = clientConnMade
reactor.connectUNIX(filename, clientFactory)
d = defer.gatherResults([serverConnMade, clientConnMade])
def allConnected(args):
serverProtocol, clientProtocol = args
# Incidental assertion which may or may not be redundant with some
# other test. This probably deserves its own test method.
self.assertEqual(clientFactory.peerAddresses,
[address.UNIXAddress(filename)])
clientProtocol.transport.loseConnection()
serverProtocol.transport.loseConnection()
d.addCallback(allConnected)
return d
def _listen_server(self, addr):
from twisted.internet import reactor
self.server_factory = UnitSettingsFactoryLocal()
self.server_socket = reactor.listenUNIX(addr, self.server_factory)
self.addCleanup(self.server_socket.stopListening)
return self.server_socket
def setUp(self):
self.hs = yield setup_test_homeserver(
"blue",
http_client=None,
federation_client=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
)
self.hs.get_ratelimiter().send_message.return_value = (True, 0)
self.master_store = self.hs.get_datastore()
self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs)
self.event_id = 0
server_factory = ReplicationStreamProtocolFactory(self.hs)
# XXX: mktemp is unsafe and should never be used. but we're just a test.
path = tempfile.mktemp(prefix="base_slaved_store_test_case_socket")
listener = reactor.listenUNIX(path, server_factory)
self.addCleanup(listener.stopListening)
self.streamer = server_factory.streamer
self.replication_handler = ReplicationClientHandler(self.slaved_store)
client_factory = ReplicationClientFactory(
self.hs, "client_name", self.replication_handler
)
client_connector = reactor.connectUNIX(path, client_factory)
self.addCleanup(client_factory.stopTrying)
self.addCleanup(client_connector.disconnect)
def _configure(self, config_yml, dockerArgs={}, dockerOnSocket=False,
realDockerSocket=False, powerstripPort=0, nullAdapter=False):
if not realDockerSocket:
self.dockerAPI = testtools.FakeDockerServer(**dockerArgs)
if dockerOnSocket:
self.socketPath = self.mktemp()
self.dockerServer = reactor.listenUNIX(self.socketPath, self.dockerAPI)
else:
self.dockerServer = reactor.listenTCP(0, self.dockerAPI)
self.dockerPort = self.dockerServer.getHost().port
else:
# NB: only supports real docker on socket (not tcp) at the
# moment
assert dockerOnSocket, ("must pass dockerOnSocket=True "
"if specifying realDockerSocket")
self.socketPath = realDockerSocket
self.config = PluginConfiguration()
tmp = self.mktemp()
self.config._default_file = tmp
fp = FilePath(tmp)
fp.setContent(config_yml)
self.parser = EndpointParser(self.config)
if dockerOnSocket:
self.proxyAPI = powerstrip.ServerProtocolFactory(
dockerSocket=self.socketPath, config=self.config)
else:
self.proxyAPI = powerstrip.ServerProtocolFactory(
dockerAddr="127.0.0.1", dockerPort=self.dockerPort,
config=self.config)
self.proxyServer = reactor.listenTCP(powerstripPort, self.proxyAPI)
self.proxyPort = self.proxyServer.getHost().port
def _listen_server(self, addr):
from twisted.internet import reactor
self.server_factory = UnitSettingsFactoryLocal()
self.server_socket = reactor.listenUNIX(addr, self.server_factory)
self.addCleanup(self.server_socket.stopListening)
return self.server_socket
def _configure(self, config_yml, dockerArgs={}, dockerOnSocket=False):
self.dockerAPI = TrafficLoggingFactory(testtools.FakeDockerServer(**dockerArgs), "docker-")
if dockerOnSocket:
self.socketPath = self.mktemp()
self.dockerServer = reactor.listenUNIX(self.socketPath, self.dockerAPI)
else:
self.dockerServer = reactor.listenTCP(0, self.dockerAPI)
self.dockerPort = self.dockerServer.getHost().port
self.config = PluginConfiguration()
tmp = self.mktemp()
self.config._default_file = tmp
fp = FilePath(tmp)
fp.setContent(config_yml)
self.parser = EndpointParser(self.config)
if dockerOnSocket:
self.proxyAPI = TrafficLoggingFactory(powerstrip.ServerProtocolFactory(
dockerSocket=self.socketPath, config=self.config), "proxy-")
else:
self.proxyAPI = TrafficLoggingFactory(
powerstrip.ServerProtocolFactory(
dockerAddr="127.0.0.1", dockerPort=self.dockerPort,
config=self.config), "proxy-")
self.proxyServer = reactor.listenTCP(0, self.proxyAPI)
self.proxyPort = self.proxyServer.getHost().port
