def test_listenWithIsDeprecated(self):
"""
L{PosixReactorBase} implements the deprecated L{IReactorArbitrary}, and
L{PosixReactorBase.listenWith} is a part of that interface. To avoid
unnecessary deprecation warnings when importing posixbase, the
L{twisted.internet.interfaces._IReactorArbitrary} alias that doesn't
have the deprecation warning is imported, and instead
L{PosixReactorBase.listenWith} generates its own deprecation warning.
"""
class fakePort:
def __init__(self, *args, **kw):
pass
def startListening(self):
pass
reactor = TrivialReactor()
reactor.listenWith(fakePort)
warnings = self.flushWarnings([self.test_listenWithIsDeprecated])
self.assertEqual(len(warnings), 1)
self.assertEqual(warnings[0]['category'], DeprecationWarning)
self.assertEqual(
"listenWith is deprecated since Twisted 10.1. "
"See IReactorFDSet.",
warnings[0]['message'])
def test_listenWithIsDeprecated(self):
"""
L{PosixReactorBase} implements the deprecated L{IReactorArbitrary}, and
L{PosixReactorBase.listenWith} is a part of that interface. To avoid
unnecessary deprecation warnings when importing posixbase, the
L{twisted.internet.interfaces._IReactorArbitrary} alias that doesn't
have the deprecation warning is imported, and instead
L{PosixReactorBase.listenWith} generates its own deprecation warning.
"""
class fakePort:
def __init__(self, *args, **kw):
pass
def startListening(self):
pass
reactor = TrivialReactor()
reactor.listenWith(fakePort)
warnings = self.flushWarnings([self.test_listenWithIsDeprecated])
self.assertEqual(len(warnings), 1)
self.assertEqual(warnings[0]['category'], DeprecationWarning)
self.assertEqual(
"listenWith is deprecated since Twisted 10.1. "
"See IReactorFDSet.", warnings[0]['message'])
def setUp(self):
self.l = []
self.group = 'test-' + ''.join(
[chr(random.randint(0, 255)) for x in range(4)]).encode('hex')
h = Hasher(self.group)
reactor.listenWith(twispread.MultiPort, protocol=h)
h.startNewGroup()
self.l.append(h)
for i in xrange(4):
h = Hasher(self.group)
reactor.listenWith(twispread.MultiPort, protocol=h)
self.l.append(h)
for n in self.l:
n.stream = StringIO()
n.log.addHandler(logging.StreamHandler(n.stream))
n.log.setLevel(logging.DEBUG)
self.tointro = list(self.l[1:])
for h in self.tointro:
df = self.l[0].introduceNewServer(h.serverId)
df.addCallback(self.introd, h)
for i in xrange(50):
reactor.iterate(0.01)
def setUp(self):
self.l = []
self.group = 'test-' + ''.join([chr(random.randint(0,255)) for x in range(4)]).encode('hex')
h = Storer(self.group)
reactor.listenWith(twispread.MultiPort, protocol=h)
h.startNewGroup()
self.l.append(h)
for i in xrange(10):
reactor.iterate(0.01)
self.a = self.b = self.x = None
def setUp(self):
self.l = []
self.group = 'test-' + ''.join(
[chr(random.randint(0, 255)) for x in range(4)]).encode('hex')
h = Storer(self.group)
reactor.listenWith(twispread.MultiPort, protocol=h)
h.startNewGroup()
self.l.append(h)
for i in xrange(10):
reactor.iterate(0.01)
self.a = self.b = self.x = None
def _setup_protocols(root):
from twisted.internet import reactor
protocols = [
#child_path config_key port_class_import, factory_class_import
('tcp', 'proxy', 'orbited.cometsession.Port', 'orbited.proxy.ProxyFactory'),
]
for child_path, config_key, port_class_import, factory_class_import in protocols:
if config.map['[global]'].get('%s.enabled' % config_key) == '1':
port_class = _import(port_class_import)
factory_class = _import(factory_class_import)
reactor.listenWith(port_class, factory=factory_class(), resource=root, childName=child_path)
logger.info('%s protocol active' % config_key)
def _setup_protocols(root):
from twisted.internet import reactor
protocols = [
#child_path config_key port_class_import, factory_class_import
('tcp', 'proxy', 'orbited.cometsession.Port', 'orbited.proxy.ProxyFactory'),
]
for child_path, config_key, port_class_import, factory_class_import in protocols:
if config.map['[global]'].get('%s.enabled' % config_key) == '1':
port_class = _import(port_class_import)
factory_class = _import(factory_class_import)
reactor.listenWith(port_class, factory=factory_class(), resource=root, childName=child_path)
logger.info('%s protocol active' % config_key)
def _setup_protocols(root):
from twisted.internet import reactor
protocols = [
# child_path config_key port_class_import, factory_class_import
("tcp", "proxy", "orbited.cometsession.Port", "orbited.proxy.ProxyFactory")
]
for child_path, config_key, port_class_import, factory_class_import in protocols:
if config.map["[global]"].get("%s.enabled" % config_key) == "1":
port_class = _import(port_class_import)
factory_class = _import(factory_class_import)
reactor.listenWith(port_class, factory=factory_class(), resource=root, childName=child_path)
logger.info("%s protocol active" % config_key)
def test2(self):
## add another
self.a = self.l[0]
self.b = Storer(self.group)
reactor.listenWith(twispread.MultiPort, protocol=self.b)
self.a.log.addHandler(logging.StreamHandler())
self.a.log.setLevel(logging.DEBUG)
df = self.a.introduceNewServer(self.b.serverId)
df.addCallback(self.done2)
self.b.max = 5
for i in xrange(30):
reactor.iterate(0.05)
self.assertEqual(self.a.store, self.x)
self.assertEqual(self.a.store, self.b.store)
def test2(self):
## add another
self.a = self.l[0]
self.b = Storer(self.group)
reactor.listenWith(twispread.MultiPort, protocol=self.b)
self.a.log.addHandler(logging.StreamHandler())
self.a.log.setLevel(logging.DEBUG)
df = self.a.introduceNewServer(self.b.serverId)
df.addCallback(self.done2)
self.b.max=5
for i in xrange(30):
reactor.iterate(0.05)
self.assertEqual(self.a.store, self.x)
self.assertEqual(self.a.store, self.b.store)
def do_setup(self):
# Create our combined PB-server/fd-passing channel
self.have_properties()
realm = PorterRealm(self)
checker = checkers.FlexibleCredentialsChecker()
checker.addUser(self._username, self._password)
p = portal.Portal(realm, [checker])
serverfactory = pb.PBServerFactory(p)
try:
# Rather than a normal listenTCP() or listenUNIX(), we use
# listenWith so that we can specify our particular Port, which
# creates Transports that we know how to pass FDs over.
try:
os.unlink(self._socketPath)
except OSError:
pass
self._socketlistener = reactor.listenWith(
fdserver.FDPort, self._socketPath, serverfactory)
self.debug("Now listening on socketPath %s" % self._socketPath)
except error.CannotListenError, e:
self.warning("Failed to create socket %s" % self._socketPath)
m = messages.Error(T_(N_(
"Network error: socket path %s is not available."),
self._socketPath))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
def setUp(self):
self.l = []
self.group = "test-" + "".join([chr(random.randint(0, 255)) for x in range(4)]).encode("hex")
for i in range(3):
e = Storer()
p = reactor.listenWith(twispread.Port, protocol=e)
p.join_group(self.group)
self.l.append(e)
def setUp(self):
self.l = []
self.group = 'test-' + ''.join(
[chr(random.randint(0, 255)) for x in range(4)]).encode('hex')
for i in range(3):
e = Storer()
p = reactor.listenWith(twispread.Port, protocol=e)
p.join_group(self.group)
self.l.append(e)
def __init__(self, portType, *args, **kwargs):
EventStream.__init__(self)
put = self.put
class _ReadDescrEventStreamProto(Protocol):
def dataReceived(self, data):
put(data)
self.port = reactor.listenWith(portType, _ReadDescrEventStreamProto(), *args, **kwargs)
def cancel(port):
port.stopListening()
self.put.set_deleted_cb(cancel, self.port)
def listen(self, bouncer, portNum, unsafeTracebacks=0):
portal = fportal.BouncerPortal(self, bouncer)
factory = pb.PBServerFactory(portal, unsafeTracebacks=unsafeTracebacks)
tport = reactor.listenWith(fdserver.PassableServerPort, portNum,
factory)
self._tport = tport
self.debug('Listening for feed requests on TCP port %d',
self.getPortNum())
def listenWith(self, portType, *args, **kw):
"""
Start an instance of the given C{portType} listening.
@type portType: type which implements C{IListeningPort}
"""
self.extraPorts.append((portType, args, kw))
if self.running:
from twisted.internet import reactor
p = reactor.listenWith(portType, *args, **kw)
self._extraListeners[(portType, args, kw)] = p
return p
def listen(self, bouncer, portNum, unsafeTracebacks=0):
portal = fportal.BouncerPortal(self, bouncer)
factory = pb.PBServerFactory(portal,
unsafeTracebacks=unsafeTracebacks)
tport = reactor.listenWith(fdserver.PassableServerPort, portNum,
factory)
self._tport = tport
self.debug('Listening for feed requests on TCP port %d',
self.getPortNum())
def listenWith(self, portType, *args, **kw):
"""
Start an instance of the given C{portType} listening.
@type portType: type which implements C{IListeningPort}
"""
self.extraPorts.append((portType, args, kw))
if self.running:
from twisted.internet import reactor
p = reactor.listenWith(portType, *args, **kw)
self._extraListeners[(portType, args, kw)] = p
return p
def test_basic(self):
deferred = Deferred()
packet = tst_icmp_pkt()
class TstProto(Protocol):
def dataReceived(self, data):
if data == packet:
deferred.callback(None)
proto = TstProto()
port = reactor.listenWith(L2Port, proto, iface = 'lo', filter='icmp')
port.send(packet)
yield deferred
def setUp(self):
self.l = []
self.group = 'test-' + ''.join([chr(random.randint(0,255)) for x in range(4)]).encode('hex')
h = Hasher(self.group)
reactor.listenWith(twispread.MultiPort, protocol=h)
h.startNewGroup()
self.l.append(h)
for i in xrange(4):
h = Hasher(self.group)
reactor.listenWith(twispread.MultiPort, protocol=h)
self.l.append(h)
for n in self.l:
n.stream = StringIO()
n.log.addHandler(logging.StreamHandler(n.stream))
n.log.setLevel(logging.DEBUG)
self.tointro = list(self.l[1:])
for h in self.tointro:
df = self.l[0].introduceNewServer(h.serverId)
df.addCallback(self.introd, h)
for i in xrange(50):
reactor.iterate(0.01)
def __init__(self, portType, *args, **kwargs):
EventStream.__init__(self)
put = self.put
class _ReadDescrEventStreamProto(Protocol):
def dataReceived(self, data):
put(data)
self.port = reactor.listenWith(portType, _ReadDescrEventStreamProto(),
*args, **kwargs)
def cancel(port):
port.stopListening()
self.put.set_deleted_cb(cancel, self.port)
def listen(self):
assert self._port is None
assert self.avatarClass is not None
# FIXME: we should hand a username and password to log in with to
# the job process instead of allowing anonymous
checker = checkers.FlexibleCredentialsChecker()
checker.allowPasswordless(True)
p = portal.Portal(self, [checker])
f = pb.PBServerFactory(p)
try:
os.unlink(self._socketPath)
except OSError:
pass
# Rather than a listenUNIX(), we use listenWith so that we can specify
# our particular Port, which creates Transports that we know how to
# pass FDs over.
port = reactor.listenWith(fdserver.FDPort, self._socketPath, f)
self._port = port
def listen(self):
assert self._port is None
assert self.avatarClass is not None
# FIXME: we should hand a username and password to log in with to
# the job process instead of allowing anonymous
checker = checkers.FlexibleCredentialsChecker()
checker.allowPasswordless(True)
p = portal.Portal(self, [checker])
f = pb.PBServerFactory(p)
try:
os.unlink(self._socketPath)
except OSError:
pass
# Rather than a listenUNIX(), we use listenWith so that we can specify
# our particular Port, which creates Transports that we know how to
# pass FDs over.
self.debug("Listening for FD's on unix socket %s", self._socketPath)
port = reactor.listenWith(fdserver.FDPort, self._socketPath, f)
self._port = port
def main(start=True, argv=None):
try:
import twisted
except ImportError:
print "Orbited requires Twisted, which is not installed. See http://twistedmatrix.com/trac/ for installation instructions."
sys.exit(1)
#################
# This corrects a bug in Twisted 8.2.0 for certain Python 2.6 builds on Windows
# Twisted ticket: http://twistedmatrix.com/trac/ticket/3868
# -mario
try:
from twisted.python import lockfile
except ImportError:
from orbited import __path__ as orbited_path
sys.path.append(os.path.join(orbited_path[0],"hotfixes","win32api"))
from twisted.python import lockfile
lockfile.kill = None
#################
from optparse import OptionParser
parser = OptionParser()
parser.add_option(
"-c",
"--config",
dest="config",
default=None,
help="path to configuration file"
)
parser.add_option(
"-v",
"--version",
dest="version",
action="store_true",
default=False,
help="print Orbited version"
)
parser.add_option(
"-p",
"--profile",
dest="profile",
action="store_true",
default=False,
help="run Orbited with a profiler"
)
parser.add_option(
"-q",
"--quickstart",
dest="quickstart",
action="store_true",
default=False,
help="run Orbited on port 8000 and MorbidQ on port 61613"
)
if argv == None:
argv = sys.argv[1:]
(options, args) = parser.parse_args(argv)
if args:
print 'the "orbited" command does not accept positional arguments. type "orbited -h" for options.'
sys.exit(1)
if options.version:
print "Orbited version: %s" % (version,)
sys.exit(0)
if options.quickstart:
config.map['[listen]'].append('http://:8000')
config.map['[listen]'].append('stomp://:61613')
config.map['[access]'][('localhost',61613)] = ['*']
print "Quickstarting Orbited"
else:
# load configuration from configuration
# file and from command line arguments.
config.setup(options=options)
logging.setup(config.map)
# we can now safely get loggers.
global logger; logger = logging.get_logger('orbited.start')
############
# This crude garbage corrects a bug in twisted
# Orbited ticket: http://orbited.org/ticket/111
# Twisted ticket: http://twistedmatrix.com/trac/ticket/2447
# XXX : do we still need this?
# -mcarter 9/24/09
# import twisted.web.http
# twisted.web.http.HTTPChannel.setTimeout = lambda self, arg: None
# twisted.web.http.HTTPChannel.resetTimeout = lambda self: None
############
# NB: we need to install the reactor before using twisted.
reactor_name = config.map['[global]'].get('reactor')
if reactor_name:
install = _import('twisted.internet.%sreactor.install' % reactor_name)
install()
logger.info('using %s reactor' % reactor_name)
from twisted.internet import reactor
from twisted.web import resource
from twisted.web import server
from twisted.web import static
# import orbited.system
if 'INDEX' in config.map['[static]']:
root = static.File(config.map['[static]']['INDEX'])
else:
root = resource.Resource()
static_files = static.File(os.path.join(os.path.dirname(__file__), 'static'))
root.putChild('static', static_files)
# Note: hard coding timeout to 120.
site = server.Site(root, timeout=120)
from proxy import ProxyFactory
from csp_twisted import CometPort
reactor.listenWith(CometPort, factory=ProxyFactory(), resource=root, childName='csp')
_setup_static(root, config.map)
start_listening(site, config.map, logger)
# switch uid and gid to configured user and group.
if os.name == 'posix' and os.getuid() == 0:
user = config.map['[global]'].get('user')
group = config.map['[global]'].get('group')
if user:
import pwd
import grp
try:
pw = pwd.getpwnam(user)
uid = pw.pw_uid
if group:
gr = grp.getgrnam(group)
gid = gr.gr_gid
else:
gid = pw.pw_gid
gr = grp.getgrgid(gid)
group = gr.gr_name
except Exception, e:
logger.error('Aborting; Unknown user or group: %s' % e)
sys.exit(1)
logger.info('switching to user %s (uid=%d) and group %s (gid=%d)' % (user, uid, group, gid))
os.setgid(gid)
os.setuid(uid)
else:
logger.error('Aborting; You must define a user (and optionally a group) in the configuration file.')
sys.exit(1)
def do_setup(self):
# Create our combined PB-server/fd-passing channel
self.have_properties()
realm = PorterRealm(self)
checker = checkers.FlexibleCredentialsChecker()
checker.addUser(self._username, self._password)
if not self._requirePassword:
checker.allowPasswordless(True)
p = portal.Portal(realm, [checker])
serverfactory = pb.PBServerFactory(p)
try:
# Rather than a normal listenTCP() or listenUNIX(), we use
# listenWith so that we can specify our particular Port, which
# creates Transports that we know how to pass FDs over.
try:
os.unlink(self._socketPath)
except OSError:
pass
self._socketlistener = reactor.listenWith(
fdserver.FDPort, self._socketPath,
serverfactory, mode=self._socketMode)
self.info("Now listening on socketPath %s", self._socketPath)
except error.CannotListenError:
self.warning("Failed to create socket %s" % self._socketPath)
m = messages.Error(T_(N_(
"Network error: socket path %s is not available."),
self._socketPath))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
# Create the class that deals with the specific protocol we're proxying
# in this porter.
try:
proto = reflect.namedAny(self._porterProtocol)
self.debug("Created proto %r" % proto)
except (ImportError, AttributeError):
self.warning("Failed to import protocol '%s', defaulting to HTTP" %
self._porterProtocol)
proto = HTTPPorterProtocol
# And of course we also want to listen for incoming requests in the
# appropriate protocol (HTTP, RTSP, etc.)
factory = PorterProtocolFactory(self, proto)
try:
reactor.listenWith(
fdserver.PassableServerPort, self._port, factory,
interface=self._interface)
self.info("Now listening on interface %r on port %d",
self._interface, self._port)
except error.CannotListenError:
self.warning("Failed to listen on interface %r on port %d",
self._interface, self._port)
m = messages.Error(T_(N_(
"Network error: TCP port %d is not available."), self._port))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
reactor.listenUDP(port, factory, interface, maxPacketSize)
except error.CannotListenError, msg:
log.msg('error on UDP port %s: %s' % (port, msg))
return
for port, factory, ctxFactory, backlog, interface in self.sslPorts:
try:
reactor.listenSSL(port, factory, ctxFactory, backlog,
interface)
except error.CannotListenError, msg:
log.msg('error on SSL port %s: %s' % (port, msg))
return
for portType, args, kw in self.extraPorts:
# The tuple(kw.items()) is because we can't use a dictionary
# or a list in a dictionary key.
self._extraListeners[(portType, args, tuple(
kw.items()))] = (reactor.listenWith(portType, *args, **kw))
for host, port, factory, ctxFactory, timeout, bindAddress in self.sslConnectors:
reactor.connectSSL(host, port, factory, ctxFactory, timeout,
bindAddress)
for host, port, factory, timeout, bindAddress in self.tcpConnectors:
reactor.connectTCP(host, port, factory, timeout, bindAddress)
for rhost, rport, protocol, lport, interface, size in self.udpConnectors:
reactor.connectUDP(rhost, rport, protocol, lport, interface,
size)
for address, factory, timeout in self.unixConnectors:
reactor.connectUNIX(address, factory, timeout)
for connectorType, args, kw in self.extraConnectors:
reactor.connectWith(connectorType, *args, **kw)
for service in self.services.values():
return
for port, factory, interface, maxPacketSize in self.udpPorts:
try:
reactor.listenUDP(port, factory, interface, maxPacketSize)
except error.CannotListenError, msg:
log.msg('error on UDP port %s: %s' % (port, msg))
return
for port, factory, ctxFactory, backlog, interface in self.sslPorts:
try:
reactor.listenSSL(port, factory, ctxFactory, backlog, interface)
except error.CannotListenError, msg:
log.msg('error on SSL port %s: %s' % (port, msg))
return
for portType, args, kw in self.extraPorts:
self._extraListeners[(portType, args, tuple(kw.items()))] = (
reactor.listenWith(portType, *args, **kw))
for host, port, factory, ctxFactory, timeout, bindAddress in self.sslConnectors:
reactor.connectSSL(host, port, factory, ctxFactory, timeout, bindAddress)
for host, port, factory, timeout, bindAddress in self.tcpConnectors:
reactor.connectTCP(host, port, factory, timeout, bindAddress)
for rhost, rport, protocol, lport, interface, size in self.udpConnectors:
reactor.connectUDP(rhost, rport, protocol, lport, interface, size)
for address, factory, timeout in self.unixConnectors:
reactor.connectUNIX(address, factory, timeout)
for connectorType, args, kw in self.extraConnectors:
reactor.connectWith(connectorType, *args, **kw)
for service in self.services.values():
service.startService()
self.running = 1
def run(self, save=1, installSignalHandlers=1):
"""run(save=1, installSignalHandlers=1)
# Copyright (c) 2001-2010 Twisted Matrix Laboratories.
# See LICENSE for details.
from twisted.internet import reactor, protocol
from twisted.pair import ethernet, rawudp, ip
from twisted.pair import tuntap
class MyProto(protocol.DatagramProtocol):
def datagramReceived(self, *a, **kw):
print a, kw
p_udp = rawudp.RawUDPProtocol()
p_udp.addProto(42, MyProto())
p_ip = ip.IPProtocol()
p_ip.addProto(17, p_udp)
p_eth = ethernet.EthernetProtocol()
p_eth.addProto(0x800, p_ip)
reactor.listenWith(tuntap.TuntapPort,
interface='tap0', proto=p_eth, reactor=reactor)
reactor.run()
return error.NoResource("<script>alert('whoops');</script>")
# print 'returning self.connections[%s]' % (path,)
return self.connections[path]
def removeConn(self, conn):
if conn.key in self.connections:
del self.connections[conn.key]
def connectionMade(self, conn):
self.listeningPort.connectionMade(conn)
if __name__ == "__main__":
class EchoProtocol(Protocol):
def dataReceived(self, data):
print "RECV:", data
self.transport.write("Echo: " + data)
def connectionMade(self):
print "Connection Opened"
def connectionLost(self):
print "Connection Lost"
class EchoFactory(Factory):
protocol = EchoProtocol
factory = EchoFactory()
reactor.listenWith(Port, 7778, factory)
reactor.run()
l = L2TPV3ControlHeader(data)
print "packet received from %s, len %s %s" % (source, len(data), l)
if l.control_id == 0:
# find the assigned connection id AVP
l.control_id = struct.unpack("!I", l.get(0, 61, 9, 1).data)[0]
print "proposed connection id : %d" % l.control_id
# get the control connection
if not (source, dest, l.control_id) in controlConnections:
controlConnections[(source, dest, l.control_id)] = \
L2TPV3ControlConnection(source, dest, l.control_id)
controlConnections[(source, dest, l.control_id)].datagramReceived(
self, source, dest, data)
elif (source, dest, sess_id) in connections:
connections[(source, dest, sess_id)].datagramReceived(
source, dest, data[4:])
else:
print "data packet with invalid session received"
# TODO should probably send a disconnect message at this point.
if __name__ == "__main__":
log.startLogging(sys.stdout)
p_l2tpv3 = L2TPV3()
p_ip = ip.IPProtocol()
p_ip.addProto(115, p_l2tpv3)
rsock = reactor.listenWith(RawSocket, ip=routerid, protnum=115,
proto=p_ip, reactor=reactor)
reactor.run()
_clients = []
def __init__(self, xsser):
self.xsser = xsser
def post(self, data):
for c in self._clients:
c.transport.write(cgi.escape(data)+'<br/>')
#c.transport.flush()
if __name__ == '__main__':
if orbited_main:
print "orbited!"
root = orbited_main()
import orbited.transports.base
from orbited import cometsession
tcpresource = resource.Resource()
# root.putChild("tcp", tcpresource)
#site = server.Site(root)
# reactor.listenTcp(site, 9999)
reactor.listenWith(cometsession.Port, factory=ServerFactory(xsser),
resource=root, childName='xssertcp')
root.putChild("xsser", XSSerMainResource("xsser", xsser))
root.putChild("checker", XSSerCheckerResource("checker", xsser))
else:
factory = ServerFactory(None)
reactor.listenTCP(19084, factory)
reactor.run()
def doRead(self):
"""Called when my socket is ready for reading."""
read = 0
while read < self.maxThroughput:
try:
data, addr = self.socket.recvfrom(self.maxPacketSize)
read += len(data)
ip = self.decoder.decode(data)
if isinstance(ip.child(),ImpactPacket.UDP) and \
ip.child().get_uh_dport() == self.port:
self.protocol.datagramReceived(ip, addr)
except socket.error, se:
no = se.args[0]
if no in (EAGAIN, EINTR, EWOULDBLOCK):
return
if (no == ECONNREFUSED) or (platformType == "win32" and no == WSAECONNRESET):
# XXX for the moment we don't deal with connection refused
# in non-connected UDP sockets.
pass
else:
raise
## except:
## log.deferr()
echo = Echo()
echo.setFakeSrc("127.0.0.1")
reactor.listenWith(RawUDPPort, proto=echo, port=9999, interface="localhost", reactor=reactor)
reactor.run()
def do_setup(self):
# Create our combined PB-server/fd-passing channel
self.have_properties()
realm = PorterRealm(self)
checker = checkers.FlexibleCredentialsChecker()
checker.addUser(self._username, self._password)
if not self._requirePassword:
checker.allowPasswordless(True)
p = portal.Portal(realm, [checker])
serverfactory = pb.PBServerFactory(p)
try:
# Rather than a normal listenTCP() or listenUNIX(), we use
# listenWith so that we can specify our particular Port, which
# creates Transports that we know how to pass FDs over.
try:
os.unlink(self._socketPath)
except OSError:
pass
self._socketlistener = reactor.listenWith(fdserver.FDPort,
self._socketPath,
serverfactory,
mode=self._socketMode)
self.info("Now listening on socketPath %s", self._socketPath)
except error.CannotListenError:
self.warning("Failed to create socket %s" % self._socketPath)
m = messages.Error(
T_(N_("Network error: socket path %s is not available."),
self._socketPath))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
# Create the class that deals with the specific protocol we're proxying
# in this porter.
try:
proto = reflect.namedAny(self._porterProtocol)
self.debug("Created proto %r" % proto)
except (ImportError, AttributeError):
self.warning("Failed to import protocol '%s', defaulting to HTTP" %
self._porterProtocol)
proto = HTTPPorterProtocol
# And of course we also want to listen for incoming requests in the
# appropriate protocol (HTTP, RTSP, etc.)
factory = PorterProtocolFactory(self, proto)
try:
reactor.listenWith(fdserver.PassableServerPort,
self._port,
factory,
interface=self._interface)
self.info("Now listening on interface %r on port %d",
self._interface, self._port)
except error.CannotListenError:
self.warning("Failed to listen on interface %r on port %d",
self._interface, self._port)
m = messages.Error(
T_(N_("Network error: TCP port %d is not available."),
self._port))
self.addMessage(m)
self.setMood(moods.sad)
return defer.fail(errors.ComponentSetupHandledError())
import socket
from twisted.internet import protocol, reactor, udp
class Echo(protocol.DatagramProtocol):
def datagramReceived(self, data, host, port):
print(data, host, port)
class RawUDPPort(udp.Port):
"""Raw udp port."""
socketType = socket.SOCK_RAW # Overide socket type.
reactor.listenWith(RawUDPPort, proto=Echo(), port=9999, reactor=reactor)
reactor.run()
del self.connections[conn.key]
def connectionMade(self, conn):
self.listeningPort.connectionMade(conn)
if __name__ == "__main__":
# Let's illustrate the benefit of using the Port. Here we're using an
# implementation of the normal twisted protocol with the comet session
# Port. It looks the same way that we would use any protocol with
# a TCP port, but the transport is a comet connection and not the
# usual TCP connection.
class EchoProtocol(Protocol):
def dataReceived(self, data):
print "RECV:", data
self.transport.write("Echo: " + data)
def connectionMade(self):
print "Connection Opened"
def connectionLost(self):
print "Connection Lost"
class EchoFactory(Factory):
protocol = EchoProtocol
factory = EchoFactory()
reactor.listenWith(Port, 7778, factory)
reactor.run()
from twisted.internet import reactor, protocol
from csp.twisted.port import CometPort
class Echo(protocol.Protocol):
def dataReceived(self, data):
self.transport.write(data)
class EchoFactory(protocol.Factory):
protocol = Echo
if __name__ == "__main__":
print "echo listening on CSP@8000"
reactor.listenWith(CometPort, port=8000, factory=EchoFactory())
reactor.run()
def __init__(self, xsser):
self.xsser = xsser
def post(self, data):
for c in self._clients:
c.transport.write(cgi.escape(data) + '<br/>')
#c.transport.flush()
if __name__ == '__main__':
if orbited_main:
print "orbited!"
root = orbited_main()
import orbited.transports.base
from orbited import cometsession
tcpresource = resource.Resource()
# root.putChild("tcp", tcpresource)
#site = server.Site(root)
# reactor.listenTcp(site, 9999)
reactor.listenWith(cometsession.Port,
factory=ServerFactory(xsser),
resource=root,
childName='xssertcp')
root.putChild("xsser", XSSerMainResource("xsser", xsser))
root.putChild("checker", XSSerCheckerResource("checker", xsser))
else:
factory = ServerFactory(None)
reactor.listenTCP(19084, factory)
reactor.run()
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
from twisted.internet import reactor, protocol
from twisted.pair import ethernet, rawudp, ip
from twisted.pair import tuntap
class MyProto(protocol.DatagramProtocol):
def datagramReceived(self, *a, **kw):
print a, kw
p_udp = rawudp.RawUDPProtocol()
p_udp.addProto(42, MyProto())
p_ip = ip.IPProtocol()
p_ip.addProto(17, p_udp)
p_eth = ethernet.EthernetProtocol()
p_eth.addProto(0x800, p_ip)
reactor.listenWith(tuntap.TuntapPort,
interface='tap0',
proto=p_eth,
reactor=reactor)
reactor.run()
