def __init__(self,
host,
nick,
channels,
pm_to_nicks=[],
port=6667,
allowForce=False,
categories=None,
password=None,
notify_events={},
noticeOnChannel=False,
showBlameList=True,
useRevisions=False,
useSSL=False,
lostDelay=None,
failedDelay=None,
useColors=True,
allowShutdown=False):
base.StatusReceiverMultiService.__init__(self)
assert allowForce in (True, False) # TODO: implement others
assert allowShutdown in (True, False)
# need to stash these so we can detect changes later
self.host = host
self.port = port
self.nick = nick
self.channels = channels
self.pm_to_nicks = pm_to_nicks
self.password = password
self.allowForce = allowForce
self.useRevisions = useRevisions
self.categories = categories
self.notify_events = notify_events
self.allowShutdown = allowShutdown
self.f = IrcStatusFactory(self.nick,
self.password,
self.channels,
self.pm_to_nicks,
self.categories,
self.notify_events,
noticeOnChannel=noticeOnChannel,
useRevisions=useRevisions,
showBlameList=showBlameList,
lostDelay=lostDelay,
failedDelay=failedDelay,
useColors=useColors,
allowShutdown=allowShutdown)
if useSSL:
# SSL client needs a ClientContextFactory for some SSL mumbo-jumbo
if not have_ssl:
raise RuntimeError("useSSL requires PyOpenSSL")
cf = ssl.ClientContextFactory()
c = internet.SSLClient(self.host, self.port, self.f, cf)
else:
c = internet.TCPClient(self.host, self.port, self.f)
c.setServiceParent(self)
def start(config):
"""Start twisted event loop and the fun should begin..."""
host = config.get('broker', 'host')
port = int(config.get('broker', 'port'))
username = config.get('broker', 'username')
password = config.get('broker', 'password')
fileServerPort = int(config.get('fileserver', 'port'))
fileServerDirectory = config.get('fileserver', 'directory')
# Start File Server
try:
privkey = os.path.abspath(
os.path.dirname(__file__) + '/services/privkey.pem')
cacert = os.path.abspath(
os.path.dirname(__file__) + '/services/cacert.pem')
logger.info('Using SSL, privkey = %s, cacert = %s' % (privkey, cacert))
reactor.listenSSL(fileServerPort,
FileServerFactory(fileServerDirectory),
ssl.DefaultOpenSSLContextFactory(privkey, cacert))
logger.info('Listening on port %d, serving files from directory: %s' %
(fileServerPort, fileServerDirectory))
except:
logger.fatal("Unable to start file server at port: %d, please check." %
fileServerPort)
stompProtocolFactory = StompProtocolFactory()
reactor.connectTCP(host, port, stompProtocolFactory)
reactor.run()
return internet.TCPClient(host, port, stompProtocolFactory)
def testPrivileged(self):
factory = protocol.ServerFactory()
factory.protocol = TestEcho
TestEcho.d = defer.Deferred()
t = internet.TCPServer(0, factory)
t.privileged = 1
t.privilegedStartService()
num = t._port.getHost().port
class Foo(basic.LineReceiver):
def connectionMade(self):
self.transport.write('lalala\r\n')
def lineReceived(self, line):
self.factory.line = line
self.transport.loseConnection()
factory = protocol.ClientFactory()
factory.protocol = Foo
factory.line = None
c = internet.TCPClient('127.0.0.1', num, factory)
c.startService()
util.spinWhile(lambda: factory.line is None)
self.assertEqual(factory.line, 'lalala')
# Cleanup the reactor
util.wait(defer.maybeDeferred(c.stopService))
util.wait(defer.maybeDeferred(t.stopService))
util.wait(TestEcho.d)
def __init__(self,
buildmaster_host,
port,
name,
passwd,
basedir,
keepalive,
usePTY,
keepaliveTimeout=30,
umask=None,
debugOpts={}):
log.msg("Creating BuildSlave -- buildbot.version: %s" %
buildbot.version)
service.MultiService.__init__(self)
self.debugOpts = debugOpts.copy()
bot = self.botClass(basedir, usePTY)
bot.setServiceParent(self)
self.bot = bot
if keepalive == 0:
keepalive = None
self.umask = umask
bf = self.bf = BotFactory(keepalive, keepaliveTimeout)
bf.startLogin(credentials.UsernamePassword(name, passwd), client=bot)
self.connection = c = internet.TCPClient(buildmaster_host, port, bf)
c.setServiceParent(self)
def __init__(self, buildmaster_host, port, name, passwd, basedir,
keepalive, usePTY, keepaliveTimeout=30, umask=None,
maxdelay=300, unicode_encoding=None, allow_shutdown=None):
log.msg("Creating BuildSlave -- version: %s" % buildslave.version)
self.recordHostname(basedir)
service.MultiService.__init__(self)
bot = Bot(basedir, usePTY, unicode_encoding=unicode_encoding)
bot.setServiceParent(self)
self.bot = bot
if keepalive == 0:
keepalive = None
self.umask = umask
if allow_shutdown == 'signal':
if not hasattr(signal, 'SIGHUP'):
raise ValueError("Can't install signal handler")
elif allow_shutdown == 'file':
self.shutdown_file = os.path.join(basedir, 'shutdown.stamp')
self.shutdown_mtime = 0
self.allow_shutdown = allow_shutdown
bf = self.bf = BotFactory(buildmaster_host, port, keepalive, keepaliveTimeout, maxdelay)
bf.startLogin(credentials.UsernamePassword(name, passwd), client=bot)
self.connection = c = internet.TCPClient(buildmaster_host, port, bf)
c.setServiceParent(self)
def makeService(config):
# finger on port 79
s = service.MultiService()
f = FingerService(config['file'])
h = internet.TCPServer(1079, IFingerFactory(f))
h.setServiceParent(s)
# website on port 8000
r = resource.IResource(f)
r.templateDirectory = config['templates']
site = server.Site(r)
j = internet.TCPServer(8000, site)
j.setServiceParent(s)
# ssl on port 443
# if config.get('ssl'):
# k = internet.SSLServer(443, site, ServerContextFactory())
# k.setServiceParent(s)
# irc fingerbot
if 'ircnick' in config:
i = IIRCClientFactory(f)
i.nickname = config['ircnick']
ircserver = config['ircserver']
b = internet.TCPClient(ircserver, 6667, i)
b.setServiceParent(s)
# Pespective Broker on port 8889
if 'pbport' in config:
m = internet.TCPServer(int(config['pbport']),
pb.PBServerFactory(IPerspectiveFinger(f)))
m.setServiceParent(s)
return s
def makeService(self, options):
"""
Construct a TCPClient from a EsmeTransceiverFactory.
"""
#print "host", options["host"]
#print "port", options["port"]
#print "system_id", options["system_id"]
#print "password", options["password"]
#print "system_type", options["system_type"]
esmeTransFact = EsmeTransceiverFactory()
esmeTransFact.loadDefaults(clickatell_defaults)
esmeTransFact.loadDefaults({"host":options["host"], "port":int(options["port"])})
if options["system_id"]:
esmeTransFact.loadDefaults({"system_id":options["system_id"]})
if options["password"]:
esmeTransFact.loadDefaults({"password":options["password"]})
if options["system_type"]:
esmeTransFact.loadDefaults({"system_type":options["system_type"]})
print 'Factory Defaults:', esmeTransFact.defaults, '\n'
return internet.TCPClient(
esmeTransFact.defaults['host'],
esmeTransFact.defaults['port'],
esmeTransFact)
def connect(self, network):
"""
connect to the network
@ivar network: the name of the network to connect to as used in the config
gets the servername and port from config, and then connects to the network.
"""
f = BotFactory(self.root, self, network)
sname = self.config.get("server", "localhost", "main", network)
port = int(self.config.get('port', 6667, 'main', network))
bindaddress = self.config.get('bind', None, 'main', network)
if bindaddress:
bindaddress=(bindaddress, 0)
if (self.config.getBool('ssl', False, 'main', network)):
s = ssl.ClientContextFactory()
serv = internet.SSLClient(host=sname, port=port, factory=f,
bindAddress=bindaddress, contextFactory=s)
repr = "<IRC Connection with SSL to %s:%s>"
serv.__repr__ = lambda: repr % (sname, port)
serv.factory=f
else:
serv = internet.TCPClient(host=sname, port=port, bindAddress=bindaddress, factory=f)
serv.__repr__ = lambda: "<IRC Connection to %s:%s>" % (sname, port)
serv.factory=f
f.service = serv
serv.setName(network)
serv.parent = self
#if the connect is invoced via control-service,
#set the network to enabled. if not, its enabled anyway
self.config.set('enabled', True, 'main', network)
self.addService(serv)
def _makeExternalRelay(self, nick, network, port, channels):
if not network in self.connectors:
self.connectors[network] = []
factory = RelayFactory(self, nick, network, channels)
connector = internet.TCPClient(network, port, factory)
connector.setServiceParent(application)
self.connectors[network].append((connector, factory))
def __init__(self,
host,
nick,
channel,
port=6667,
categories=None,
password=None,
stableTimer=60):
base.StatusReceiverMultiService.__init__(self)
# need to stash these so we can detect changes later
self.host = host
self.port = port
self.nick = nick
self.channel = channel
self.password = password
self.categories = categories
self.stableTimer = stableTimer
# need to stash the factory so we can give it the status object
self.f = IrcStatusFactory(self.nick, self.password, self.channel,
self.categories, self.stableTimer)
c = internet.TCPClient(host, port, self.f)
c.setServiceParent(self)
def make_plugin(config, http=None):
irc_config = IrcConfig(config)
dispatcher = Dispatcher()
channel_manager = ChannelManager(irc_config.channels, dispatcher)
# add the http resources
if http:
http.root.putChild('message', MessageListener(http, dispatcher))
topic_root = resource.Resource()
http.root.putChild('topic', topic_root)
topic_root.putChild('set', SetTopicListener(http, dispatcher))
# configure the default irc commands
p = IrcPlugin()
p.register_command(who)
p.register_command(debug)
# set up the IRC client
irc_factory = IRCBotFactory(p, irc_config, dispatcher, channel_manager)
p.config = irc_config
p.bot = dispatcher
p.channels = channel_manager
if irc_config:
context_factory = ssl.ClientContextFactory()
p.add_service(
internet.SSLClient(irc_config.host, irc_config.port, irc_factory,
context_factory))
else:
p.add_service(
internet.TCPClient(irc_config.host, irc_config.port, irc_factory))
return p
def __init__(self,
host,
nick,
channels,
port=6667,
allowForce=True,
categories=None,
password=None):
base.StatusReceiverMultiService.__init__(self)
assert allowForce in (True, False) # TODO: implement others
# need to stash these so we can detect changes later
self.host = host
self.port = port
self.nick = nick
self.channels = channels
self.password = password
self.allowForce = allowForce
self.categories = categories
# need to stash the factory so we can give it the status object
self.f = IrcStatusFactory(self.nick, self.password, self.channels,
self.categories)
c = internet.TCPClient(host, port, self.f)
c.setServiceParent(self)
def _makeHomeRelay(self, nick, network, channel):
if not network in self.connectors:
self.connectors[network] = []
factory = HomeRelayManager(self, nick, network, channel)
connector = internet.TCPClient(self.network, self.port, factory)
connector.setServiceParent(application)
self.connectors[network].append((connector, factory))
def __init__(self, host, port):
self.host = host
self.port = int(port)
self.simpleName = ("%s_%d" % (self.host, self.port)).replace('.', '_')
self.factory = PypeConnectionFactory(self)
self.client = internet.TCPClient(self.host, self.port, self.factory)
self.consumedMessages = 0
self.logicalMessages = 0
def start(self):
"""
Connect session to sessionhandler.
"""
if self.port:
service = internet.TCPClient(self.network, int(self.port), self)
self.sessionhandler.portal.services.addService(service)
def __init__(self, master):
self.master = master
self.config = master.modules["config"].interface("irc")
irc = IRC(master)
internet.TCPClient(master.options["irchost"],
master.options["ircport"],
irc).setServiceParent(master)
def get_VNC_info_subprocess(port):
if type(port) == int:
vncClient = internet.TCPClient('localhost', port, RFBFactory())
else:
vncClient = internet.UNIXClient(port, RFBFactory())
vncClient.startService()
reactor.run()
return VNC_data
def __actuallyConnect(self):
from twisted.application import internet
f = pb.PBClientFactory()
internet.TCPClient(self.host_tx, self.port_tx, f)
creds = UsernamePassword(self.user_tx, self.pswd_tx)
f.login(creds, self.pbReferenceable).addCallbacks(
self.pbCallback, self.couldNotConnect).setTimeout(30)
def service(host):
"""
Create and return Twisted service (w. assoc. factory w. assoc. protocol)
"""
web_socket_url = "ws://%s:8080/orchestra/connection/instrumentControlJoin" % host
factory = ReconnectingWebSocketClientFactory(web_socket_url)
factory.protocol = MessengerClientProtocol
return internet.TCPClient(factory.host, factory.port, factory)
def __init__(self,
buildmaster_host,
port,
name,
passwd,
basedir,
keepalive,
usePTY=None,
keepaliveTimeout=None,
umask=None,
maxdelay=300,
numcpus=None,
unicode_encoding=None,
allow_shutdown=None,
maxRetries=None):
# note: keepaliveTimeout is ignored, but preserved here for
# backward-compatibility
assert usePTY is None, "worker-side usePTY is not supported anymore"
service.MultiService.__init__(self)
WorkerBase.__init__(self,
name,
basedir,
umask=umask,
unicode_encoding=unicode_encoding)
if keepalive == 0:
keepalive = None
name = unicode2bytes(name, self.bot.unicode_encoding)
passwd = unicode2bytes(passwd, self.bot.unicode_encoding)
self.numcpus = numcpus
self.shutdown_loop = None
self.maxRetries = maxRetries
if allow_shutdown == 'signal':
if not hasattr(signal, 'SIGHUP'):
raise ValueError("Can't install signal handler")
elif allow_shutdown == 'file':
self.shutdown_file = os.path.join(basedir, 'shutdown.stamp')
self.shutdown_mtime = 0
self.allow_shutdown = allow_shutdown
bf = self.bf = BotFactory(buildmaster_host,
port,
keepalive,
maxdelay.bit_length,
maxRetries=self.maxRetries,
maxRetriesCallback=self.gracefulShutdown)
bf.startLogin(credentials.UsernamePassword(name, passwd),
client=self.bot)
self.connection = c = internet.TCPClient(
buildmaster_host, port,
HangCheckFactory(bf, hung_callback=self._hung_connection))
c.setServiceParent(self)
def makeService(self, options):
return internet.TCPClient(
options['host'],
options['port'],
WorkerFactory(
concurrency=options['concurrency'],
# Twisted argument parser set this to 0 or 1.
can_run_cpu_exec=bool(options['can-run-cpu-exec']),
name=options['name']))
def newConnection_inmain(self, target_name, host, port, password):
if target_name in self.targets:
if self.targets[target_name].status != "retry":
return
factory = VNCClientFactory(self, target_name, password)
self.targets[target_name] = factory.getClient()
vncClient = internet.TCPClient(host, port, factory)
vncClient.setServiceParent(self.application)
vncClient.startService()
def __init__(self, hostname, port, secret='12345'):
super(TCPTSClient, self).__init__(name="%s:%s" % (hostname, port))
self.hostname = hostname
self.port = port
self.factory = TCPTSClientFactory()
self.factory.service = self
self.factory.secret = secret
self.connection = internet.TCPClient(self.hostname, self.port,
self.factory)
def reconfigService(self, host, nick, channels, pm_to_nicks=None, port=6667,
allowForce=None, tags=None, password=None, notify_events=None,
showBlameList=True, useRevisions=False,
useSSL=False, lostDelay=None, failedDelay=None, useColors=True,
allowShutdown=None, noticeOnChannel=False, authz=None, **kwargs
):
# need to stash these so we can detect changes later
self.host = host
self.port = port
self.nick = nick
self.join_channels = channels
if pm_to_nicks is None:
pm_to_nicks = []
self.pm_to_nicks = pm_to_nicks
self.password = password
if authz is None:
self.authz = {}
else:
self.authz = authz
self.useRevisions = useRevisions
self.tags = tags
if notify_events is None:
notify_events = {}
self.notify_events = notify_events
self.noticeOnChannel = noticeOnChannel
# deprecated...
if allowForce is not None:
self.authz[('force', 'stop')] = allowForce
if allowShutdown is not None:
self.authz[('shutdown')] = allowShutdown
# ###
# This function is only called in case of reconfig with changes
# We don't try to be smart here. Just restart the bot if config has
# changed.
if self.f is not None:
self.f.shutdown()
self.f = IrcStatusFactory(self.nick, self.password,
self.join_channels, self.pm_to_nicks,
self.authz, self.tags,
self.notify_events, parent=self,
noticeOnChannel=noticeOnChannel,
useRevisions=useRevisions,
showBlameList=showBlameList,
lostDelay=lostDelay,
failedDelay=failedDelay,
useColors=useColors)
if useSSL:
cf = ssl.ClientContextFactory()
c = internet.SSLClient(self.host, self.port, self.f, cf)
else:
c = internet.TCPClient(self.host, self.port, self.f)
c.setServiceParent(self)
def __init__(self,
host,
nick,
channels,
pm_to_nicks=[],
port=6667,
allowForce=False,
categories=None,
password=None,
notify_events={},
noticeOnChannel=False,
showBlameList=True,
useRevisions=False,
useSSL=False,
lostDelay=None,
failedDelay=None,
useColors=True):
# XXX replace method - use class in the factory variable
StatusReceiverMultiService.__init__(self)
assert allowForce in (True, False)
self.host = host
self.port = port
self.nick = nick
self.channels = channels
self.pm_to_nicks = pm_to_nicks
self.password = password
self.allowForce = allowForce
self.useRevisions = useRevisions
self.categories = categories
self.notify_events = notify_events
self.f = self.factory(self.nick,
self.password,
self.channels,
self.pm_to_nicks,
self.categories,
self.notify_events,
noticeOnChannel=noticeOnChannel,
useRevisions=useRevisions,
showBlameList=showBlameList,
lostDelay=lostDelay,
failedDelay=failedDelay,
useColors=useColors)
if useSSL:
if not have_ssl:
raise RuntimeError("useSSL requires PyOpenSSL")
from twisted.internet import ssl
cf = ssl.ClientContextFactory()
c = internet.SSLClient(self.host, self.port, self.f, cf)
else:
c = internet.TCPClient(self.host, self.port, self.f)
c.setServiceParent(self)
def __init__(self,
host,
nick,
channels,
port=6667,
allowForce=False,
categories=None,
password=None,
notify_events={},
noticeOnChannel=False,
showBlameList=True,
useRevisions=False,
useSSL=False,
lostDelay=None,
failedDelay=None):
base.StatusReceiverMultiService.__init__(self)
assert allowForce in (True, False) # TODO: implement others
# need to stash these so we can detect changes later
self.host = host
self.port = port
self.nick = nick
self.channels = channels
self.password = password
self.allowForce = allowForce
self.useRevisions = useRevisions
self.categories = categories
self.notify_events = notify_events
log.msg('Notify events %s' % notify_events)
self.f = IrcStatusFactory(self.nick,
self.password,
self.channels,
self.categories,
self.notify_events,
noticeOnChannel=noticeOnChannel,
useRevisions=useRevisions,
showBlameList=showBlameList,
lostDelay=lostDelay,
failedDelay=failedDelay)
# don't set up an actual ClientContextFactory if we're running tests.
if self.in_test_harness:
return
if useSSL:
# SSL client needs a ClientContextFactory for some SSL mumbo-jumbo
if not have_ssl:
raise RuntimeError("useSSL requires PyOpenSSL")
cf = ssl.ClientContextFactory()
c = internet.SSLClient(self.host, self.port, self.f, cf)
else:
c = internet.TCPClient(self.host, self.port, self.f)
c.setServiceParent(self)
def join(self, address):
key = self._factory_key(address)
if key not in self._factories:
f = ConsensoBotFactory(address.channel)
self._factories[key] = f
s = internet.TCPClient(address.hostname, address.port, f, 20)
s.setServiceParent(self._app)
f.join(address.channel)
else:
f = self._factories[key]
f.join(address.channel)
def makeService(self, options):
"""
Construct the talkbackbot TCP client
"""
if settings.USE_SSL:
bot = internet.SSLClient(settings.HOST, settings.PORT,
TalkBackBotFactory(settings),
ssl.ClientContextFactory())
else:
bot = internet.TCPClient(settings.HOST, settings.PORT,
TalkBackBotFactory(settings))
return bot
def test_reactorParametrizationInClient(self):
"""
L{internet._AbstractClient} supports a C{reactor} keyword arguments
that can be used to parametrize the reactor used to create new client
connections.
"""
reactor = MemoryReactor()
factory = protocol.ClientFactory()
t = internet.TCPClient("127.0.0.1", 1234, factory, reactor=reactor)
t.startService()
self.assertEqual(reactor.tcpClients.pop()[:3], ("127.0.0.1", 1234, factory))
def main():
global screen,s,app,scale
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-d","--display",type='int',dest='display',default=720, help='original width')
parser.add_option("-s","--screen" ,type='int',dest='screen' ,default=1440,help='upscaled width')
parser.add_option("-o",dest='old' ,action='store_true',default=False,help='For 3:4 game')
parser.add_option("-v",dest='vgl' ,action='store_true',default=False,help='Use virtualgl')
parser.add_option("-f",dest='fsrcnnx3' ,action='store_true',default=False,help='Use fsrcnnx3')
# parser.add_option("-w",dest='window' ,action='store_true',default=False,help='windows mode')
opt,arg = parser.parse_args()
h = opt.display
w = int(h/3*4) if opt.old else int(h/9*16)
uh = opt.screen
scale = uh/h
uw = int(scale*w)
if len(arg)>0:
app = arg[0]
if opt.vgl:
os.system(f"Xvfb :1 -screen 0 {w}x{h}x24 &")
os.system(f"DISPLAY=:1 VGL_FORCEALPHA=1 VGL_DRAWABLE=pixmap vglrun wine explorer /desktop=name,{w}x{h} "+app+ " &")
print("Use vgl")
# os.system(f"VGL_FORCEALPHA=1 VGL_DRAWABLE=pixmap xvfb-run -l --server-args=\"-screen 0 {w}x{h}x24\" vglrun wine explorer /desktop=name,{w}x{h} "+app+ " &")
os.system("x11vnc -fs 0.9 -nocursor -display :1 > /dev/null 2>&1 &")
# os.system("x0vncserver -display=:1 -localhost -SecurityTypes none > /dev/null 2>&1 &")
else:
os.system(f"xvfb-run -l --server-args=\"-screen 0 {w}x{h}x24\" wine explorer /desktop=name,{w}x{h} "+app+ " &")
os.system("x11vnc -nocursor -display :99 > /dev/null 2>&1 &")
time.sleep(2)
else:
app = ""
# exit()
# os.system("x11vnc -nocursor -display :1 > /dev/null 2>&1 &")
# os.system("x11vnc -nocursor -multiptr -display :99 > /dev/null 2>&1 &")
# subprocess.call('x11vnc','-display',':99')
time.sleep(1)
pygame.init()
# pygame.mouse.set_cursor((8,8),(0,0),(0,0,0,0,0,0,0,0),(0,0,0,0,0,0,0,0))
screen = pygame.display.set_mode((uw,uh), DOUBLEBUF| NOFRAME | OPENGL, 32)
ctx = moderngl.create_context()
if opt.fsrcnnx3:
s = Shader(w,h,ctx,algo="/fsrcnnx3.glsl",scale=3)
else:
s = Shader(w,h,ctx,algo="/A4K_L_x2_denoise.glsl")
v = Event()
application = service.Application("rfb test") # create Application
vncClient = internet.TCPClient('localhost', 5900, UpscaleFactory(v)) # create the service
vncClient.setServiceParent(application)
vncClient.startService()
reactor.callLater(0.1, v.event_handle)
reactor.run()
