def makeService(self, options):
"""
This service is like the desktop, but is not responsible for
controlling the kernel server process.
"""
from codenode.frontend.search import search
search.create_index()
web_app_service = service.MultiService()
web_resource = webResourceFactory(settings.MEDIA_ROOT)
serverlog = options['server_log']
web_resource_factory = server.Site(web_resource, logPath=serverlog)
frontend_server = internet.TCPServer(options['port'],
web_resource_factory,
interface=options['host'])
frontend_server.setServiceParent(web_app_service)
if options['devel_mode']:
from twisted.conch.manhole import ColoredManhole
from twisted.conch.insults import insults
from twisted.conch.telnet import TelnetTransport, TelnetBootstrapProtocol
from twisted.internet import protocol
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
ColoredManhole, globals())
telnel_manhole = internet.TCPServer(6023, f)
telnel_manhole.setServiceParent(web_app_service)
return web_app_service
def make_service(args):
def chain_protocol_factory():
return insults.ServerProtocol(args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
m = service.MultiService()
# Telnet manhole
if True:
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
tsvc = internet.TCPServer(args['telnet'], f) # @UndefinedVariable
tsvc.setServiceParent(m)
# SSH manhole
if False:
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(
user="******")
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chain_protocol_factory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
csvc = internet.TCPServer(args['ssh'], f) # @UndefinedVariable
csvc.setServiceParent(m)
return m
def _buildProtocol(self):
return TelnetTransport(
TelnetBootstrapProtocol,
insults.ServerProtocol,
_ManholeShell,
dict(self.namespace),
)
def start(_settings, _backend, telnet_port=8023):
"""
Start telnet server
"""
global settings
global backend
backend = _backend
# Settings
settings = _settings()
# Thread sensitive interface for stdout/stdin
std.setup()
# Telnet
telnet_factory = ServerFactory()
telnet_factory.protocol = lambda: TelnetTransport(TelnetDeployer)
# Handle signals
def handle_sigint(signal, frame):
if active_sessions:
print 'Running, %i active session(s).' % len(active_sessions)
else:
print 'No active sessions, exiting'
reactor.stop()
signal.signal(signal.SIGINT, handle_sigint)
# Run the reactor!
print 'Listening telnet on localhost:%s...' % telnet_port
reactor.listenTCP(telnet_port, telnet_factory)
reactor.run()
def _makeService(args):
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(
admin="password")
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
tsvc = internet.TCPServer(args['telnet'], f)
def chainProtocolFactory():
return insults.ServerProtocol(args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chainProtocolFactory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
#csvc = internet.TCPServer(args['ssh'], f)
m = service.MultiService()
tsvc.setServiceParent(m)
#csvc.setServiceParent(m)
return m
def makeService(factory, port, *args, **kw):
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, factory, *args, **kw)
tsvc = internet.TCPServer(port, f)
return tsvc
def run_interface(config):
factory = ServerFactory()
factory.protocol = lambda: TelnetTransport(JunctionTelnetInterface)
port = int(config['App']['TelnetInterfacePort'])
logging.info("starting telnet cli interface on port %d" % port)
service = TCPServer(port, factory)
service.startService()
def makeService(self, options):
backendServices = service.MultiService()
clientManager = core.EngineClientManager() #sessions
clientManager.setServiceParent(backendServices)
processManager = core.EngineProcessManager()
processManager.setServiceParent(backendServices)
backend = core.Backend(processManager, clientManager)
backend.updateEngineTypes()
backendEngineBus = core.EngineBus(backend)
eng_proxy_factory = server.Site(BackendRoot(backend, backendEngineBus))
internet.TCPServer(
options['port'], eng_proxy_factory,
interface=options['host']).setServiceParent(backendServices)
if options['devel_mode']:
from twisted.conch.manhole import ColoredManhole
from twisted.conch.insults import insults
from twisted.conch.telnet import TelnetTransport, TelnetBootstrapProtocol
from twisted.internet import protocol
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
ColoredManhole, globals())
telnet_manhole = internet.TCPServer(6024, f)
telnet_manhole.setServiceParent(backendServices)
return backendServices
def main(reason, *args):
Log.w(main.listeningPort)
if main.listeningPort:
return
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, ColoredManhole)
main.listeningPort = reactor.listenTCP(8007, f, interface='localhost')
def getService(self):
r = Realm()
p = portal.Portal(r)
f = protocol.ServerFactory()
f.canaryservice = self
f.logger = self.logger
f.banner = self.banner
f.protocol = lambda: TelnetTransport(AlertAuthTelnetProtocol, p)
return internet.TCPServer(self.port, f, interface=self.listen_addr)
def start(port=None, host=None, telnet_vars=None):
from twisted.internet import reactor
port = int(port) if port else 6023
host = host or '127.0.0.1'
telnet_vars = telnet_vars or {}
factory = protocol.ServerFactory()
factory.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults
.ServerProtocol, ColoredManhole,
telnet_vars)
return reactor.listenTCP(port, factory, interface=host)
def __init__(self):
print "Starting up network server.."
#self.protocol is the TYPE of protocol which gets created
#it's only the function which gets called, not the actual protocol
self.parent = 0
self.child = ServerFactory()
self.child.protocol = lambda: TelnetTransport(MyProtocol)
self.protocol = self.child.protocol
self.child.id = 1
self.child.clList = {}
self.child.parent = self
self.clList = self.child.clList
print "Factory, protocol and class initialisation done."
def makeDebugCLIService(self, args):
"""
This is dangerous, and should only ever be enabled by explicit user config and only for non-production use
:param args:
:return:
"""
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
return internet.TCPServer(args['telnet'], f)
def make_manhole (self, xmpp_message, room, nick, message):
"""
Open up a manhole and announce our currentl ip.
"""
# control args.
args = \
{
'protocolFactory' : ColoredManhole,
'protocolArgs' : (None,),
'telnet' : 6023,
'ssh' : 6022,
}
# protocol factory.
def chainProtocolFactory():
return insults.ServerProtocol(
args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
# server factory.
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
# checker, realms.
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(pedram="iampedram")
tsvc = internet.TCPServer(args['telnet'], f)
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chainProtocolFactory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
csvc = internet.TCPServer(args['ssh'], f)
m = service.MultiService()
application = service.Application("Interactive Python Interpreter")
# scaffold.
tsvc.setServiceParent(m)
csvc.setServiceParent(m)
m.setServiceParent(application)
# determine IP address and announce.
ipaddr = requests.get("http://ifconfig.me/all.json").json()['ip_addr']
return "(successful) manhole opened @ %s" % ipaddr
def start(root_node,
auth_backend=None,
port=8023,
logfile=None,
extra_loggers=None):
"""
Start telnet server
"""
# Set logging
if logfile:
logging.basicConfig(filename=logfile, level=logging.DEBUG)
else:
logging.basicConfig(filename='/dev/stdout', level=logging.DEBUG)
# Thread sensitive interface for stdout/stdin
std.setup()
# Telnet
factory = ServerFactory()
factory.connectionPool = set() # List of currently, active connections
factory.protocol = lambda: TelnetTransport(TelnetDeployer)
factory.root_node = root_node()
factory.auth_backend = auth_backend
factory.extra_loggers = extra_loggers or []
# Handle signals
def handle_sigint(signal, frame):
if factory.connectionPool:
logging.info('Running, %i active session(s).' %
len(factory.connectionPool))
else:
logging.info('No active sessions, exiting')
reactor.stop()
signal.signal(signal.SIGINT, handle_sigint)
# Run the reactor!
logging.info(
'Listening for incoming telnet connections on localhost:%s...' % port)
# Set process name
suffix = (' --log "%s"' % logfile if logfile else '')
setproctitle('deploy:%s telnet-server --port %i%s' %
(root_node.__class__.__name__, port, suffix))
# Run server
reactor.listenTCP(port, factory)
reactor.run()
def run():
initialize_logger(logging.INFO)
factory = ServerFactory()
factory.protocol = lambda: TelnetTransport(MudTelnetProtocol)
endpoints.serverFromString(reactor, "tcp:8023").listen(factory)
round_timer = task.LoopingCall(game_loop.perform_round)
round_timer.start(game_loop.ROUND_TIME)
db_timer = task.LoopingCall(game_loop.save_databases)
db_timer.start(game_loop.DB_SAVE_TIME)
heal_timer = task.LoopingCall(game_loop.perform_heal)
heal_timer.start(game_loop.HEAL_TIME)
regen_timer = task.LoopingCall(game_loop.perform_regen)
regen_timer.start(game_loop.REGEN_TIME)
print "running on port 8023..."
reactor.run()
def genSSHProtocol(args):
checker = Auth.LDAPChecker(Settings.LDAPServer, Settings.LDAPManager,
Settings.LDAPPass, Settings.LDAPBase)
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
#tsvc = internet.TCPServer(args['telnet'], f)
def chainProtocolFactory():
return insults.ServerProtocol(args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chainProtocolFactory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
return f
def makeService(self, options):
"""
This service is like the desktop, but is not responsible for
controlling the kernel server process.
"""
from codenode.frontend.search import search
search.create_index()
web_app_service = service.MultiService()
if options['devel_mode']:
staticfiles = os.path.join(lib_path, 'frontend', 'static')
else:
staticfiles = options['static_files']
datafiles = options['env_path'] + "/data/plot_images" #XXX
#Temporary hack
if not os.path.exists(datafiles):
os.mkdir(datafiles)
web_resource = webResourceFactory(staticfiles, datafiles)
serverlog = options['server_log']
web_resource_factory = server.Site(web_resource, logPath=serverlog)
frontend_server = internet.TCPServer(options['port'],
web_resource_factory,
interface=options['host'])
frontend_server.setServiceParent(web_app_service)
if options['devel_mode']:
from twisted.conch.manhole import ColoredManhole
from twisted.conch.insults import insults
from twisted.conch.telnet import TelnetTransport, TelnetBootstrapProtocol
from twisted.internet import protocol
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
ColoredManhole, globals())
telnel_manhole = internet.TCPServer(6023, f)
telnel_manhole.setServiceParent(web_app_service)
return web_app_service
def telent_server_main(self):
_q_s = self
class CustomTelnetProtocol(TelnetProtocol):
_state = None
_user = None
_pass = None
def connectionMade(self):
self._state = None
self._user = None
self._pass = None
self.transport.write(b'PC login: '******'server': 'telnet_server',
'action': 'connection',
'ip': self.transport.getPeer().host,
'port': self.transport.getPeer().port
}
])
def dataReceived(self, data):
data = data.strip()
if self._state == b'Username':
self._user = data
self._state = b"Password"
self.transport.write(b'Password: '******'Password':
self._pass = data
if self._user == _q_s.username and self._pass == _q_s.password:
_q_s.logs.info([
"servers", {
'server': 'telnet_server',
'action': 'login',
'status': 'success',
'ip': self.transport.getPeer().host,
'port': self.transport.getPeer().port,
'username': _q_s.username.decode('utf-8'),
'password': _q_s.password.decode('utf-8')
}
])
else:
_q_s.logs.info([
"servers", {
'server': 'telnet_server',
'action': 'login',
'status': 'failed',
'ip': self.transport.getPeer().host,
'port': self.transport.getPeer().port,
'username': self._user.decode('utf-8'),
'password': self._pass.decode('utf-8')
}
])
self.transport.loseConnection()
else:
self.transport.loseConnection()
def connectionLost(self, reason):
self._state = None
self._user = None
self._pass = None
factory = Factory()
factory.protocol = lambda: TelnetTransport(CustomTelnetProtocol)
reactor.listenTCP(port=self.port, factory=factory, interface=self.ip)
reactor.run()
#connect to blam
BLAM = blam.blam(config['mysql_server_host'], config['mysql_server_port'],
config['mysql_server_user'], config['mysql_server_pw'],
config['mysql_blam_db'])
log.msg("blam connected")
#if there are receivers create a mailer
if config['notify']:
MAILER = mailer(config['smtp_server'], config['from_address'],
config['notify'])
log.msg("mailer created")
LOWBAT = {}
#set the battery voltage that triggers lowbattery
BATTERY_THRESHOLD = float(config['battery_threshold'])
#Dict for last time position was received
LASTPOS = {}
#twisted code
factory = ServerFactory()
factory.protocol = lambda: TelnetTransport(BPSTelnetProtocol)
application = Application("BPS")
service = TCPServer(config['port'], factory)
service.setServiceParent(application)
reactor.callLater(30, monitor)
#reactor.run()
def buildProtocol(self, addr):
self.transport = TelnetTransport(TelnetClient)
self.transport.factory = self
return self.transport
from hendrix.experience import hey_joe
from hendrix.facilities.resources import NamedResource
from twisted.python import log
message_resource = NamedResource('hendrix-demo')
from twisted.conch.telnet import TelnetTransport, TelnetProtocol
from twisted.internet.protocol import ServerFactory
class TelnetToWebsocket(TelnetProtocol):
def dataReceived(self, data):
hxdispatcher.send('noodly_messages', data)
telnet_server_factory = ServerFactory()
telnet_server_factory.protocol = lambda: TelnetTransport(TelnetToWebsocket)
deployer = HendrixDeploy(options={'wsgi': 'hendrix_demo.wsgi.application'})
deployer.resources.append(message_resource)
log.startLogging(sys.stdout)
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = hey_joe.MyServerProtocol
deployer.reactor.listenTCP(9000, factory)
deployer.reactor.listenTCP(6565, telnet_server_factory)
deployer.run()
def __call__(self):
auth = CustomAuthenticatingTelnetProtocol
#auth = StatefulTelnetProtocol
args = (self.portal, )
return TelnetTransport(auth, *args)
def buildProtocol(self, addr):
p = TelnetTransport(TelnetClient)
p.factory = self
return p
def make_manhole(namespace):
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, ColoredManhole,
namespace)
return f
def _protocol(self):
return TelnetTransport(SwitchShellFactory(self.switch_core))
def main(*args, **kwargs):
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, ColoredManhole)
reactor.listenTCP(8007, f, interface='localhost')
#print checker.users
def run_one_tick():
game.run_one_tick()
game = Game()
game_runner = task.LoopingCall(run_one_tick)
game_runner.start(1.0)
def do_save():
print("Saving game...", end=' ')
game.save()
print("done!")
print("Updating portal passwords...")
for player in list(game.player_store.values()):
for checker in list(portal_.checkers.values()):
checker.users[player['name']] = player['password']
do_save()
game_saver = task.LoopingCall(do_save)
game_saver.start(60.0)
factory = protocol.ServerFactory()
factory.protocol = lambda: TelnetTransport(RegisteringTelnetProtocol, portal_)
log.startLogging(sys.stdout)
reactor.listenTCP(4242, factory)
reactor.run()
def protocol():
return TelnetTransport(self.protocol, self)
def buildProtocol(self, addr):
protocol = TelnetTransport(TelnetPrinter)
protocol.factory = self
return protocol
