def main():
""" Parse the options, generate the data and send. """
usage = 'usage: %prog [options] <network> <channel>'
parser = OptionParser(usage)
parser.add_option('-s', '--stdin', dest='stdin', action='store_true',
default=False, help='Read notice data from stdin.')
parser.add_option('-f', '--formatter', dest='formatter',
help='formatter to apply to notice body')
options, args = parser.parse_args()
if len(args) < 3:
parser.print_help()
sys.exit(1)
botnick = args.pop(0)
network = args.pop(0)
channel = args.pop(0)
if options.stdin:
data = sys.stdin.read()
else:
data = args.pop(0)
if options.formatter:
if options.formatter in FORMATTERS:
data = FORMATTERS[options.formatter](data)
client = SupyClient()
reactor.listenUNIXDatagram(0, client)
client.sendNotice(botnick, network, channel, data)
def main():
""" Parse the options, generate the data and send. """
usage = 'usage: %prog [options] <network> <channel>'
parser = OptionParser(usage)
parser.add_option('-s',
'--stdin',
dest='stdin',
action='store_true',
default=False,
help='Read notice data from stdin.')
parser.add_option('-f',
'--formatter',
dest='formatter',
help='formatter to apply to notice body')
options, args = parser.parse_args()
if len(args) < 3:
parser.print_help()
sys.exit(1)
botnick = args.pop(0)
network = args.pop(0)
channel = args.pop(0)
if options.stdin:
data = sys.stdin.read()
else:
data = args.pop(0)
if options.formatter:
if options.formatter in FORMATTERS:
data = FORMATTERS[options.formatter](data)
client = SupyClient()
reactor.listenUNIXDatagram(0, client)
client.sendNotice(botnick, network, channel, data)
def test_protocol():
import os
p2pdprd_listening_sock = "/tmp/p2p-dprd.sock"
my_listening_sock = "/tmp/test.sock"
protocol = IPCProtocol(p2pdprd_listening_sock, my_listening_sock)
# Delete the unix socket path if it already exists
import os
if os.path.exists(my_listening_sock):
os.remove(my_listening_sock)
reactor.listenUNIXDatagram(my_listening_sock, protocol)
reactor.run()
def test_protocol():
import os
p2pdprd_listening_sock = "/tmp/p2p-dprd.sock"
my_listening_sock = "/tmp/test.sock"
protocol = IPCProtocol(p2pdprd_listening_sock, my_listening_sock)
# Delete the unix socket path if it already exists
import os
if os.path.exists(my_listening_sock):
os.remove(my_listening_sock)
reactor.listenUNIXDatagram(my_listening_sock, protocol)
reactor.run()
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
d = defer.gatherResults([sp.deferredStarted, cp.deferredStarted])
def write(ignored):
cp.transport.write("hi")
return defer.gatherResults([sp.deferredGotWhat,
cp.deferredGotBack])
def cleanup(ignored):
d1 = defer.maybeDeferred(s.stopListening)
d1.addCallback(lambda x : os.unlink(clientaddr))
d2 = defer.maybeDeferred(c.stopListening)
d2.addCallback(lambda x : os.unlink(serveraddr))
return defer.gatherResults([d1, d2])
def _cbTestExchange(ignored):
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
d.addCallback(write)
d.addCallback(cleanup)
d.addCallback(_cbTestExchange)
return d
def openServerMode(self, iface=None):
try:
self._lport = reactor.listenUNIXDatagram(iface, self)
except Exception as why:
raise error.CarrierError(why)
return self
def test_exchange(self):
"""
Test that a datagram can be sent to and received by a server and vice
versa.
"""
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
self.addCleanup(s.stopListening)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress=clientaddr)
self.addCleanup(c.stopListening)
d = defer.gatherResults([sp.deferredStarted, cp.deferredStarted])
def write(ignored):
cp.transport.write(b"hi")
return defer.gatherResults([sp.deferredGotWhat,
cp.deferredGotBack])
def _cbTestExchange(ignored):
self.assertEqual(b"hi", sp.gotwhat)
self.assertEqual(clientaddr, sp.gotfrom)
self.assertEqual(b"hi back", cp.gotback)
d.addCallback(write)
d.addCallback(_cbTestExchange)
return d
def openServerMode(self, iface=None):
try:
self._lport = reactor.listenUNIXDatagram(iface, self)
except Exception:
raise error.CarrierError(sys.exc_info()[1])
return self
def openServerMode(self, iface):
try:
self._lport = reactor.listenUNIXDatagram(iface, self)
except Exception:
raise error.CarrierError(sys.exc_info()[1])
return self
def testCannotListen(self):
addr = self.mktemp()
p = ServerProto()
s = reactor.listenUNIXDatagram(addr, p)
self.failUnlessRaises(error.CannotListenError, reactor.listenUNIXDatagram, addr, p)
s.stopListening()
os.unlink(addr)
def test_exchange(self):
"""
Test that a datagram can be sent to and received by a server and vice
versa.
"""
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
self.addCleanup(s.stopListening)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress=clientaddr)
self.addCleanup(c.stopListening)
d = defer.gatherResults([sp.deferredStarted, cp.deferredStarted])
def write(ignored):
cp.transport.write(b"hi")
return defer.gatherResults(
[sp.deferredGotWhat, cp.deferredGotBack])
def _cbTestExchange(ignored):
self.assertEqual(b"hi", sp.gotwhat)
self.assertEqual(clientaddr, sp.gotfrom)
self.assertEqual(b"hi back", cp.gotback)
d.addCallback(write)
d.addCallback(_cbTestExchange)
return d
def testCannotListen(self):
addr = self.mktemp()
p = ServerProto()
s = reactor.listenUNIXDatagram(addr, p)
self.failUnlessRaises(error.CannotListenError, reactor.listenUNIXDatagram, addr, p)
s.stopListening()
os.unlink(addr)
def __init__(self, socket_path):
self._initialized = False
self.path = socket_path
self.transport = reactor.listenUNIXDatagram(self.path, UNIXSocketProtocol())
reactor.addSystemEventTrigger('during', 'shutdown', self.close)
self.transport.deferred = None ## placeholder for the deferred used by a request
self._initialized = True
def __init__(self, socket_path):
self._initialized = False
self.path = socket_path
self.transport = reactor.listenUNIXDatagram(self.path,
UNIXSocketProtocol())
reactor.addSystemEventTrigger('during', 'shutdown', self.close)
self.transport.deferred = None ## placeholder for the deferred used by a request
self._initialized = True
def testRepr(self):
filename = self.mktemp()
f = ServerProto()
p = reactor.listenUNIXDatagram(filename, f)
self.failIf(str(p).find(filename) == -1)
def stoppedListening(ign):
self.failIf(str(p).find(filename) != -1)
return defer.maybeDeferred(p.stopListening).addCallback(stoppedListening)
def __init__(self):
socket_path = process.runtime.file('opensips.sock')
unlink(socket_path)
self.path = socket_path
self.transport = reactor.listenUNIXDatagram(self.path,
UNIXSocketProtocol())
self.transport.requests = {}
reactor.addSystemEventTrigger('during', 'shutdown', self.close)
def __init__(self, irc):
callbacks.Plugin.__init__(self, irc)
self.server = SupyUDP(self)
self.path = os.path.expanduser('~/.supybot-external-notice.%s' %
self.nick)
if os.path.exists(self.path):
os.remove(self.path)
self.listener = reactor.listenUNIXDatagram(self.path, self.server)
os.chmod(self.path, 200)
def testRepr(self):
filename = self.mktemp()
f = ServerProto()
p = reactor.listenUNIXDatagram(filename, f)
self.failIf(str(p).find(filename) == -1)
def stoppedListening(ign):
self.failIf(str(p).find(filename) != -1)
return defer.maybeDeferred(p.stopListening).addCallback(stoppedListening)
def test_cannotListen(self):
"""
L{IReactorUNIXDatagram.listenUNIXDatagram} raises
L{error.CannotListenError} if the unix socket specified is already in
use.
"""
addr = self.mktemp()
p = ServerProto()
s = reactor.listenUNIXDatagram(addr, p)
self.assertRaises(error.CannotListenError, reactor.listenUNIXDatagram, addr, p)
s.stopListening()
os.unlink(addr)
def test_cannotListen(self):
"""
L{IReactorUNIXDatagram.listenUNIXDatagram} raises
L{error.CannotListenError} if the unix socket specified is already in
use.
"""
addr = self.mktemp()
p = ServerProto()
s = reactor.listenUNIXDatagram(addr, p)
self.failUnlessRaises(error.CannotListenError, reactor.listenUNIXDatagram, addr, p)
s.stopListening()
os.unlink(addr)
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
spinUntil(lambda:sp.started and cp.started)
cp.transport.write("hi")
spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back")
s.stopListening()
c.stopListening()
os.unlink(clientaddr)
os.unlink(serveraddr)
spinWhile(lambda:s.connected and c.connected)
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
def _reprTest(self, serverProto, protocolName):
"""
Test the C{__str__} and C{__repr__} implementations of a UNIX datagram
port when used with the given protocol.
"""
filename = self.mktemp()
unixPort = reactor.listenUNIXDatagram(filename, serverProto)
connectedString = "<%s on %r>" % (protocolName, filename)
self.assertEqual(repr(unixPort), connectedString)
self.assertEqual(str(unixPort), connectedString)
stopDeferred = defer.maybeDeferred(unixPort.stopListening)
def stoppedListening(ign):
unconnectedString = "<%s (not listening)>" % (protocolName,)
self.assertEqual(repr(unixPort), unconnectedString)
self.assertEqual(str(unixPort), unconnectedString)
stopDeferred.addCallback(stoppedListening)
return stopDeferred
def _reprTest(self, serverProto, protocolName):
"""
Test the C{__str__} and C{__repr__} implementations of a UNIX datagram
port when used with the given protocol.
"""
filename = self.mktemp()
unixPort = reactor.listenUNIXDatagram(filename, serverProto)
connectedString = "<%s on %r>" % (protocolName, filename)
self.assertEqual(repr(unixPort), connectedString)
self.assertEqual(str(unixPort), connectedString)
stopDeferred = defer.maybeDeferred(unixPort.stopListening)
def stoppedListening(ign):
unconnectedString = "<%s (not listening)>" % (protocolName, )
self.assertEqual(repr(unixPort), unconnectedString)
self.assertEqual(str(unixPort), unconnectedString)
stopDeferred.addCallback(stoppedListening)
return stopDeferred
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
spinUntil(lambda:sp.started and cp.started)
cp.transport.write("hi")
spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back")
s.stopListening()
c.stopListening()
os.unlink(clientaddr)
os.unlink(serveraddr)
spinWhile(lambda:s.connected and c.connected)
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
def listen_from(sock):
conn = lambda proto: reactor.listenUNIXDatagram(sock, proto, 32*1024)
dbus = Databus(conn)
dbus.connect()
return(dbus)
log.startLogging(sys.stderr)
myip = socket.gethostbyname(os.uname()[1])
process = BgpProcess(1257, myip)
factory = BgpFactory()
factory.process = process
try:
process.db_conn = psycopg2.connect(
"dbname='flow' user='******' host='localhost' password='******'")
except:
print "I am unable to connect to the flow database"
named_pipe_file = '/tmp/flowd'
nf_factory = NfFactory(process)
# try:
# os.unlink(named_pipe_file)
# except:
# pass
# os.mkfifo(named_pipe_file)
reactor.listenTCP(179, factory)
reactor.listenUNIXDatagram(named_pipe_file, nf_factory)
reactor.run()
# os.unlink(named_pipe_file)
def openServerMode(self, iface=None):
try:
self._lport = reactor.listenUNIXDatagram(iface, self)
except Exception, why:
raise error.CarrierError(why)
process = BgpProcess(1257, myip)
factory = BgpFactory()
factory.process = process
try:
process.db_conn = psycopg2.connect("dbname='flow' user='******' host='localhost' password='******'");
except:
print "I am unable to connect to the flow database"
named_pipe_file = '/tmp/flowd'
nf_factory = NfFactory(process)
# try:
# os.unlink(named_pipe_file)
# except:
# pass
# os.mkfifo(named_pipe_file)
reactor.listenTCP(179, factory)
reactor.listenUNIXDatagram(named_pipe_file, nf_factory)
reactor.run()
# os.unlink(named_pipe_file)
def listen_from(sock):
conn = lambda proto: reactor.listenUNIXDatagram(sock, proto, 32 * 1024)
dbus = Databus(conn)
dbus.connect()
return (dbus)
