def setUp(self):
self.server = Server()
self.client = Client()
# multicast won't work if we listen over loopback, apparently
self.port1 = reactor.listenMulticast(0, self.server)
self.port2 = reactor.listenMulticast(0, self.client)
self.client.transport.connect("127.0.0.1", self.server.transport.getHost().port)
def main():
p = argparse.ArgumentParser(description='Paradrop daemon running on client')
p.add_argument('--mode', '-m', help='Set the mode to one of [production, local, unittest]',
action='store', type=str, default='production')
p.add_argument('--portal', '-p', help='Set the folder of files for local portal',
action='store', type=str)
p.add_argument('--no-exec', help='Skip execution of configuration commands',
action='store_false', dest='execute')
args = p.parse_args()
# print args
settings.loadSettings(args.mode, [])
update_manager = UpdateManager(reactor)
update_fetcher = UpdateFetcher(update_manager)
WampSession.set_update_fetcher(update_fetcher)
ProcessMonitor.allowedActions = set()
# Start the configuration service as a thread
confd.main.run_thread(execute=args.execute)
airshark_manager = AirsharkManager()
# Globally assign the nexus object so anyone else can access it.
nexus.core = Nexus(update_fetcher, update_manager)
http_server = HttpServer(update_manager, update_fetcher, airshark_manager, args.portal)
setup_http_server(http_server, '0.0.0.0', settings.PORTAL_SERVER_PORT)
reactor.listenMulticast(1900, SsdpResponder(), listenMultiple=True)
reactor.run()
def setUp(self):
self.receiver = dispatch.Receiver()
self.serverPort = reactor.listenMulticast(17778, async.MulticastDatagramServerProtocol(self.receiver, "224.0.0.1"), listenMultiple=True)
self.receiver2 = dispatch.Receiver()
self.serverPort2 = reactor.listenMulticast(17778, async.MulticastDatagramServerProtocol(self.receiver2, "224.0.0.1"), listenMultiple=True)
self.client = async.DatagramClientProtocol()
self.clientPort = reactor.listenUDP(0, self.client)
def main():
init_parser = argparse.ArgumentParser(description="Code or binary over LAN execution", add_help=False)
init_parser.add_argument('--port', action="store", type=int, default=8005, help="Network port to use, default 8005")
group_client_server = init_parser.add_mutually_exclusive_group(required=True)
group_client_server.add_argument('--client', action="store_false", help="Start client with some query")
group_client_server.add_argument('--server', action="store_true", help="Start as server, waiting for connections")
init_parser.add_argument('--version', action='version', version='%(prog)s 0.1')
init_args, other_args = init_parser.parse_known_args()
if init_args.server is False:
parser = argparse.ArgumentParser(parents=[init_parser])
parser.add_argument('--localfile', action="store", type=str, help="Local file to load on servers")
parser.add_argument('--tries', action="store", type=int, default=1, help="How many times to exec")
group_arch_bin_script = parser.add_mutually_exclusive_group()
group_arch_bin_script.add_argument('--archive', action="store_true", help="If localfile is archive")
group_arch_bin_script.add_argument('--executable', action="store_false",
help="If localfile is binary or script")
parser.add_argument('--execstr', action="store", type=str, required=True,
help="Your regular shell exec: filename and args, to be launched on remote machine")
args, other_args = parser.parse_known_args()
elif init_args.server is True:
parser = argparse.ArgumentParser(parents=[init_parser])
parser.add_argument('--whitelist', action="store", type=str, help="File with allowed IP's, in A.B.C.D format")
args, other_args = parser.parse_known_args()
if init_args.server:
reactor.listenMulticast(init_args.port, MulticastDevopsServerProtocol(init_args.port, args.whitelist),
listenMultiple=True)
else:
reactor.listenMulticast(init_args.port, MulticastDevopsClientProtocol(init_args.port, args),
listenMultiple=True)
return reactor.run()
def build(self):
# conexao UDP com os tratores
self.conexao = Echo (self)
reactor.listenMulticast (10000, self.conexao, listenMultiple = True)
# escreve os logs a cada 10 segundos, pra nao perder
Clock.schedule_interval (self.conexao.writeLogs, 10)
return Builder.load_string(kv)
def start(self):
dserver = defer.Deferred()
dclient = defer.Deferred()
try:
self.ssdp = reactor.listenMulticast(SSDP_PORT,
ServerBase(self._node_id,
self._control_uri,
self.iface_send_list,
d=dserver
),
listenMultiple=True)
self.ssdp.setTTL(5)
for iface_ in self.iface_send_list:
d = self.ssdp.joinGroup(SSDP_ADDR, interface=iface_)
d.addErrback(lambda x: _log.error("Failed to join multicast group %s:%s, %s", iface_, SSDP_PORT, x))
d.addCallback(lambda x: _log.debug("Joined multicast group %s:%s, %s", iface_, SSDP_PORT, x))
except:
_log.exception("Multicast listen join failed!!")
# Dont start server some one is alerady running locally
# TODO: Do we need this ?
self.port = reactor.listenMulticast(0, ClientBase(dclient=dclient), interface=self.iface)
_log.debug("SSDP Host: %s" % repr(self.port.getHost()))
# Set ignore port and ips
if self.ssdp and self.ignore_self:
self.ssdp.protocol.set_ignore_list([(x, self.port.getHost().port) for x in self.iface_send_list])
return dserver, dclient
def startPD():
p=Peer(uid=uuid1().hex, name='anon',addr='127.0.0.1')
p_l=PeerContainer(refAdd, refDel)
i=Inducter(('224.0.2.38',8999))
reactor.listenMulticast(8999,i)
h=MessageHandler(p, i.broadcast, p_l)
i.addHandler(h.handle)
def __init__(self, address="224.0.0.251", port=5353):
self.address = address
self.port = port
self.proto = MulticastDNSProtocol(self)
reactor.listenMulticast(port, self.proto, listenMultiple=True)
def main():
log.startLogging(sys.stdout)
parser = argparse.ArgumentParser(description="Exchange files!")
args = parser.parse_args()
# Initialize peer discovery using UDP multicast
multiCastPort = 8006
teiler = TeilerState()
teiler.multiCastPort = multiCastPort
reactor.listenMulticast(multiCastPort,
PeerDiscovery(teiler),
listenMultiple=True)
log.msg("Initiating Peer Discovery")
app = TeilerWindow(teiler)
# Initialize file transfer service
fileReceiver = FileReceiverFactory(teiler, app)
reactor.listenTCP(teiler.tcpPort, fileReceiver)
log.msg("Starting file listener on ", teiler.tcpPort)
# qt4reactor requires runReturn() in order to work
reactor.runReturn()
# filetransfer.sendFile("/home/armin/tempzip.zip",port=teiler.tcpPort,address=teiler.address)
# Create an instance of the application window and run it
app.run()
def StartSSDPServer():
"""Start an SSDP server.
Used for debugging/testing just an SSDP server.
"""
logging.info('SSDPServer started')
reactor.listenMulticast(1900, SSDPServer(), listenMultiple=True)
reactor.run()
def setup(clientPort):
global peerlist
peerlist = PeerList()
_log.info('client_ip = %s', socket.gethostbyname(socket.gethostname()))
br = Broadcaster(peerlist, clientPort)
reactor.listenMulticast(9999, br, listenMultiple=True) #@UndefinedVariable
l = task.LoopingCall(br.sendDatagram)
l.start(3.0)
def born(self, data):
"""Method initiate TCL and UDP listeners."""
lc = LoopingCall(get_metrics, None)
lc.start(2)
reactor.listenUDP(self.UDP_PORT, NotificationUDPProcessor())
reactor.listenMulticast(self.MULTICAST_PORT,
MunticastNotificationProcessor(self.MULTICAST_IP), # add multicast 'born' processing
listenMultiple=True)
endpoints.serverFromString(reactor, "tcp:21999").listen(EchoFactory())
def setup(sessionPort):
global peerlist
peerlist = PeerList()
host = socket.gethostbyname(socket.gethostname())
br = Broadcaster(host, sessionPort)
#reactor.listenUDP(9999, br) #@UndefinedVariable
reactor.listenMulticast(9999, br, listenMultiple=True) #@UndefinedVariable
l = task.LoopingCall(br.sendDatagram)
l.start(2.0)
def __init__(self, torrent):
self.torrent = torrent
self.id = 0
self.swarm_size = 1
self.peers = [None, None] # [0] left, [1] right
self.msgcache = MsgCache()
self.client_factory = PeerProtocol.BTClientFactory(torrent, True)
self.lndp_finder = LNDPFinder(self)
reactor.listenMulticast(MULTICAST_PORT, self.lndp_finder, listenMultiple=True)
def send_udp_mcast(data, mcast_ip, mcast_port):
"""Sends UDP packet to a multicast group without waiting for a response
:param data: (String) data value which have to be send
:param mcast_group: (String) IP of a multicast group
:return: None
"""
# 0 means every port, we don't care
reactor.listenMulticast(0, MulticastSender(data, mcast_ip, mcast_port),
listenMultiple=True)
def run(self):
from twisted.internet import reactor
from twisted.python import log
reactor.listenMulticast(8005, HolaListener(self.queue), listenMultiple=True)
self.reactor = reactor
reactor.callLater(1, self.__checkShutdown)
log.defaultObserver.stop()
reactor.run()
def main():
parser = ArgumentParser()
parser.add_argument('--node_id', '-n',
type=long,
required=True)
parser.add_argument('--verbose', '-v', action='store_true')
args = parser.parse_args()
reactor.listenMulticast(PORT, BFT2F_Node(args.node_id, args.verbose), listenMultiple=True)
reactor.run()
def testMultiListen(self):
c = Server()
p = reactor.listenMulticast(0, c, listenMultiple=True)
self.runUntilSuccess(self.server.transport.joinGroup, "225.0.0.250")
portno = p.getHost().port
c2 = Server()
p2 = reactor.listenMulticast(portno, c2, listenMultiple=True)
self.runUntilSuccess(self.server.transport.joinGroup, "225.0.0.250")
c.transport.write("hello world", ("225.0.0.250", portno))
d = defer.Deferred()
reactor.callLater(0.4, d.callback, None, c, c2, p, p2)
return d
def main():
reactor.disconnectAll()
failover = False
if settings.POOL_FAILOVER_ENABLE:
failover = settings.failover_pool
settings.failover_pool = not settings.failover_pool
pool_host = settings.POOL_HOST
pool_port = settings.POOL_PORT
if failover and settings.POOL_FAILOVER_ENABLE:
pool_host = settings.POOL_HOST_FAILOVER
pool_port = settings.POOL_PORT_FAILOVER
log.warning("Monero Stratum proxy version: %s" % version.VERSION)
log.warning("Trying to connect to Stratum pool at %s:%d" % (pool_host, pool_port))
# Connect to Stratum pool, main monitoring connection
f = SocketTransportClientFactory(pool_host, pool_port,
debug=settings.DEBUG, proxy=None,
event_handler=client_service.ClientMiningService)
job_registry = jobs.JobRegistry(f)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
f.on_connect.addCallback(on_connect)
f.on_disconnect.addCallback(on_disconnect)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connect to the pool
try:
yield f.on_connect
except TransportException:
log.warning("First pool server must be online first time to start failover")
return
# Setup stratum listener
stratum_listener.StratumProxyService._set_upstream_factory(f)
stratum_listener.StratumProxyService._set_custom_user(settings.CUSTOM_USER, settings.CUSTOM_PASSWORD, settings.ENABLE_WORKER_ID, settings.WORKER_ID_FROM_IP)
reactor.listenTCP(settings.STRATUM_PORT, SocketTransportFactory(debug=settings.DEBUG, event_handler=ServiceEventHandler), interface=settings.STRATUM_HOST)
# Setup multicast responder
reactor.listenMulticast(3333, multicast_responder.MulticastResponder((pool_host, pool_port), settings.STRATUM_PORT), listenMultiple=True)
log.warning("-----------------------------------------------------------------------")
if settings.STRATUM_HOST == '0.0.0.0':
log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d (stratum)" % settings.STRATUM_PORT)
else:
log.warning("LISTENING FOR MINERS ON stratum+tcp://%s:%d (stratum)" % \
(settings.STRATUM_HOST, settings.STRATUM_PORT))
log.warning("-----------------------------------------------------------------------")
def start_multicast():
"""
Starts a :class:`Polo` instance for each multicast group configured in\
conf.MULTICAST_ADDRS, initializing all the data structures
"""
for group in conf.MULTICAST_ADDRS:
offered_services[group] = []
user_services[group] = {}
polo = Polo(offered_services[group], user_services[group], group)
polo_instances[group] = polo
reactor.listenMulticast(conf.PORT,
polo,
listenMultiple=False,
interface=group)
def main():
parser = argparse.ArgumentParser(
description='OSC server to control some number of searchlights.')
parser.add_argument('--config_file', type=argparse.FileType(), required=True,
help='YAML config file specifying how the searchlights are set up.')
logging_common.add_logging_args(parser)
args = parser.parse_args()
logging_common.configure_logging_from_args(args)
config = yaml.load(args.config_file)
logging.info('Got config file: %s', pprint.pformat(config))
if not config.get('configuration_database'):
logging.error('Config file does not specify a searchlight configuration database.')
return
config_store = SearchlightConfigStore.create_with_sqlite_database(
config.get('configuration_database'))
osc_receiver = dispatch.Receiver()
reactor.listenMulticast(
config['osc_server']['port'],
osc_server.MulticastDatagramServerProtocol(
osc_receiver, config['osc_server']['address']),
listenMultiple=True)
if not config.get('searchlights'):
logging.error('Config file specifies no searchlights.')
return
name_to_searchlight = {}
for config_values in config.get('searchlights'):
motor_controller = MotorController(reactor, **config_values.pop('motor_controller'))
searchlight = Searchlight(motor_controller, osc_receiver, config_store, **config_values)
name_to_searchlight[searchlight.name] = searchlight
psmove_connection_manager = None
psmove_controller_configs = config.get('psmove_controllers', [])
if psmove_controller_configs:
psmove_connection_manager = PSMoveConnectionManager(
reactor, psmove_controller_configs, name_to_searchlight)
if not config.get('admin_server_port'):
logging.error('Config file does not specify administration server port.')
return
reactor.listenTCP(
config.get('admin_server_port'),
admin_server.AdminServer(name_to_searchlight.values()))
reactor.run()
def startFactory(self):
""" kick off the queue processor """
if MULTICAST:
log.msg("Multicast Listening on [%s] [%d]" % (self.mhost,self.mport))
reactor.listenMulticast(int(self.mport),self.ppc,listenMultiple=True)
else:
log.msg("UDP Listening on [%d]" % (self.mport))
reactor.listenUDP(int(self.mport),self.ppc)
threads.deferToThread(self.ppc.run)
threads.deferToThread(self.process_requests.run)
reactor.addSystemEventTrigger('during','shutdown',self.ppc.stop)
reactor.addSystemEventTrigger('during','shutdown',self.process_requests.stop)
reactor.addSystemEventTrigger('after','shutdown',self.process_requests.wait)
def testMultiListen(self):
c = Server()
p = reactor.listenMulticast(0, c, listenMultiple=True)
self.runUntilSuccess(self.server.transport.joinGroup, "225.0.0.250")
portno = p.getHost().port
c2 = Server()
p2 = reactor.listenMulticast(portno, c2, listenMultiple=True)
self.runUntilSuccess(self.server.transport.joinGroup, "225.0.0.250")
c.transport.write("hello world", ("225.0.0.250", portno))
self.runReactor(0.4, True)
self.assertEquals(c.packets[0][0], "hello world")
self.assertEquals(c2.packets[0][0], "hello world")
p.stopListening()
p2.stopListening()
def build(self):
global g
self.nr = 0
self.config = Configuration()
self.config.purgelines()
self.config.initialize()
game = TTTGame()
self.g = game
self.mp = TTTMulticastDiscoveryCI(TTTMulticastDiscoveryCI.MODES['client'])
reactor.listenMulticast(TTTMulticastDiscoveryCI.PORT, self.mp, listenMultiple=True)
Clock.schedule_once(lambda dt: game.post_init())
Clock.schedule_once(lambda dt: self.discover_server(), 1)
return game
def _discover_multicast():
"""
Local IP discovery protocol via multicast:
- Broadcast 3 ping multicast packet with "ping" in it
- Wait for an answer
- Retrieve the ip address from the returning packet, which is ours
"""
nonce = str(random.randrange(2 ** 64))
p = _LocalNetworkMulticast(nonce)
for attempt in itertools.count():
port = 11000 + random.randint(0, 5000)
try:
mcast = reactor.listenMulticast(port, p)
except CannotListenError:
if attempt >= 10:
raise
continue
else:
break
try:
yield mcast.joinGroup('239.255.255.250', socket.INADDR_ANY)
logging.debug("Sending multicast ping")
for i in xrange(3):
p.transport.write(nonce, ('239.255.255.250', port))
address, = yield p.address_received.get_deferred(5)
finally:
mcast.stopListening()
defer.returnValue(address)
def listenMulticast(self):
from twisted.internet import reactor
from twisted.internet.error import CannotListenError
attempt = 0
port = 11000 + random.randint(0, 5000)
while True:
try:
mcast = reactor.listenMulticast(port, self)
break
except CannotListenError:
port = 11000 + random.randint(0, 5000)
attempt += 1
if _Debug:
print "listenmulticast failed, trying", port
if attempt > 5:
log.msg(
"warning: couldn't listen ony mcast port",
system='network')
d, self.compDef = self.compDef, None
d.callback(None)
dd = mcast.joinGroup('239.255.255.250', socket.INADDR_ANY)
def _cb(x):
if _Debug:
print 'multicast group joined'
def _eb(x):
if _Debug:
print 'multicast group join failed', x
self.completed = True
self.compDef.errback(x)
dd.addCallback(_cb)
dd.addErrback(_eb)
self.mcastPort = port
def ready(self):
self.transmitter = ClientCreator(reactor, amp.AMP).connectTCP(
self.monitor_host, self.monitor_port).addCallback(self.__transmitter_connected).addErrback(transmitter.error)
# wheter we are replaying from pcap or not
if self.mode == 'pcap':
print 'Switching to replay mode'
pcap = self.pcap_f
replayer = Replayer(pcap)
replayer.replay_packets(self.__multicast_handler)
else:
self.multicast_protocol = SSLV_MulticastProtocol(self.multicast_host, self.__multicast_handler)
reactor.listenMulticast(self.multicast_port, self.multicast_protocol, listenMultiple=True)
print "ready"
def search_device(self):
"""
Triggers a UPnP device discovery.
The returned deferred will be called with the L{UPnPDevice} that has
been found in the LAN.
@return: A deferred called with the detected L{UPnPDevice} instance.
@rtype: L{twisted.internet.defer.Deferred}
"""
if self._discovery is not None:
raise ValueError('already used')
self._discovery = defer.Deferred()
self._discovery_timeout = reactor.callLater(6, self._on_discovery_timeout)
attempt = 0
mcast = None
while True:
try:
self.mcast = reactor.listenMulticast(1900+attempt, self)
break
except CannotListenError:
attempt = random.randint(0, 500)
# joined multicast group, starting upnp search
self.mcast.joinGroup('239.255.255.250', socket.INADDR_ANY)
self.transport.write(_UPNP_SEARCH_REQUEST, (_UPNP_MCAST, _UPNP_PORT))
self.transport.write(_UPNP_SEARCH_REQUEST, (_UPNP_MCAST, _UPNP_PORT))
self.transport.write(_UPNP_SEARCH_REQUEST, (_UPNP_MCAST, _UPNP_PORT))
return self._discovery
def __init__(self, interface='', status_port=0, device_target=''):
self.interface = interface
self.device_target = device_target
self.status_port = status_port
self.port = reactor.listenMulticast(SSDP_PORT, self, listenMultiple=True) # pylint: disable=no-member
self.port.joinGroup(SSDP_ADDR, interface=interface)
reactor.addSystemEventTrigger('before', 'shutdown', self.stop) # pylint: disable=no-member
def test_multicast(self):
"""
Test that a multicast group can be joined and messages sent to and
received from it.
"""
c = Server()
p = reactor.listenMulticast(0, c)
addr = self.server.transport.getHost()
joined = self.server.transport.joinGroup("225.0.0.250")
def cbJoined(ignored):
d = self.server.packetReceived = Deferred()
c.transport.write("hello world", ("225.0.0.250", addr.port))
return d
joined.addCallback(cbJoined)
def cbPacket(ignored):
self.assertEquals(self.server.packets[0][0], "hello world")
joined.addCallback(cbPacket)
def cleanup(passthrough):
result = maybeDeferred(p.stopListening)
result.addCallback(lambda ign: passthrough)
return result
joined.addCallback(cleanup)
return joined
userid=config.get("amqp", "user"),
password=config.get("amqp", "pass"),
virtual_host=config.get("amqp", "vhost"),
insist=False)
amqp_exchange = config.get("amqp", "exchange")
amqp_spec = (amqp_conn, amqp_exchange)
else:
amqp_spec = (None, None)
if config.getboolean("carbon", "enable"):
carbon_host = config.get("carbon", "host")
carbon_port = config.get("carbon", "port")
carbon_spec = (carbon_host, carbon_port)
else:
carbon_spec = (None, None)
graphite = GraphiteAggregator(socket.gethostname(), mappings, sanitize_names,
apply_formats, amqp_spec, carbon_spec)
if config.getboolean("gmond","multicast"):
#server = McastServer((config.get("gmond","ip"),
# config.getint("gmond","port")), GangliaCollector)
reactor.listenMulticast(config.getint("gmond","port"), GangliaClient(),
listenMultiple=True)
reactor.run()
# else:
# server = SocketServer.UDPServer((config.get("gmond","ip"),
# config.getint("gmond","port")), GangliaCollector)
#reference https://twistedmatrix.com/documents/current/core/howto/udp.html
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class abc(DatagramProtocol):
def startProtocol(self):
self.transport.setTTL(5)
self.transport.joinGroup("225.0.0.5")
def datagramReceived(self, datagram, address):
print("Datagram %s received from %s" % (repr(datagram), repr(address)))
print(datagram)
if datagram == b"Client1: Hello" or datagram == "Client1: Hello":
self.transport.write(b"Server receives; Hello", address)
reactor.listenMulticast(9999, abc(), listenMultiple=True)
reactor.run()
from __future__ import print_function
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class MulticastHelloWorldServer(DatagramProtocol):
def startProtocol(self):
"""
Called after protocol has started listening.
"""
# Set the TTL>1 so multicast will cross router hops:
self.transport.setTTL(5)
# Join a specific multicast group:
self.transport.joinGroup("228.0.0.5")
def datagramReceived(self, datagram, address):
print("Datagram %s received from %s" % (repr(datagram), repr(address)))
if datagram == b"Hello World" or datagram == "Hello World":
# Rather than replying to the group multicast address, we send the
# reply directly (unicast) to the originating port:
self.transport.write(b"Server: Hello World", address)
reactor.listenMulticast(9999, MulticastHelloWorldServer(), listenMultiple=True)
reactor.run()
dec = data.decode("utf-8")
except:
#print("Décodage UTF-8 impossible")
dec = data
try:
msg = ast.literal_eval(dec)
except:
#print("ast.literal_eval impossible")
msg = dec
if isinstance(msg, dict):
return msg
else:
#print("Message reçu: None")
return None
if __name__ == "__main__":
## Receive
endpoint = TCP4ServerEndpoint(reactor, TCP_PORT)
endpoint.listen(MyTcpServerFactory())
## Send: je reçois aussi ce que j'envoie
reactor.listenMulticast(MULTICAST_PORT,
MyMulticastSender(),
listenMultiple=True)
## Pour les 2
reactor.run()
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class MulticastHelloWorldClient(DatagramProtocol):
def startProtocol(self):
self.transport.joinGroup("228.0.0.5")
self.transport.write(b'Hello World', ("228.0.0.5", 8005))
def datagramReceived(self, datagram, address):
print("Datagram %s received from %s" % (repr(datagram), repr(address)))
reactor.listenMulticast(8005, MulticastHelloWorldClient(), listenMultiple=True)
reactor.run()
global voteCount
prevVot = prevVots + 'v'
voteCount += 1
self.datagramSend(prevVot)
def confirm(self, prevCons):
global prevCon
global conCount
prevCon = prevCons + 'c'
conCount += 1
self.datagramSend(prevCon)
def datagramSend(self, message, address=None):
global mes
print("message for other server", mes)
mes = message.encode("UTF-8")
global port
print(port)
for i in port:
if i != pr_nb:
self.transport.write(mes, ('224.0.0.1', i))
pr_nb = int(sys.argv[1])
dbname = 'example' + str(pr_nb) + '.db'
db = pickledb.load(dbname, False)
reactor.listenMulticast(pr_nb, MulticastServerUDP())
reactor.run()
# if send_port[i] == 3012:
# self.vote_count = self.vote_count+1
# print(self.vote_count)
# if self.vote_count == 2:
# self.transport.write(datagram + b"vote", ("228.0.0.5", send_port[0]))
# self.transport.write(datagram + b"vote", ("228.0.0.5", send_port[2]))
# for i in range(len(send_port)):
# if self.vote_count > 2:
# self.transport.write(datagram + b"vote", ("228.0.0.5", send_port[i]))
# self.vote_count = 1
#self.accept_state = self.accept_state + 1
# if self.vote_count > 2:
# print(message)
# datagram = datagram + b"vote"
# self.broadcast_all(datagram)
# vote_broadcast = data_address + "," + "vote"
# print(vote_broadcast)
# bytes1 = bytes(vote_broadcast, 'utf-8')
# for each in send_port:
# We use listenMultiple=True so that we can run MulticastServer.py and
# MulticastClient.py on same machine:
reactor.listenMulticast(int(port), MulticastPingPong(), listenMultiple=True)
reactor.run()
def create_peer(id, qty, price, msgtype):
senderObj = UdpSender(id, "224.0.0.1", 8005, qty, price, msgtype)
reactor.listenMulticast(8005, senderObj, listenMultiple=True)
def main():
parser = optparse.OptionParser()
parser.add_option('-b',
'--bind',
dest='bind',
help='bind the server to a specific IP',
metavar='IP')
parser.add_option('--config_file',
dest='config_file',
help='change config file location',
metavar='FILE')
parser.add_option('--create_camera_config',
dest='create_camera_config',
help='create new camera configuration file',
metavar='MOUNTPOINT')
parser.add_option('-d',
'--debug',
dest='debug',
action='store_true',
default=False,
help='enable debug logging to file')
parser.add_option('--import_camera_config',
dest='import_camera_config',
help='update server with cameras configuration',
metavar='MOUNTPOINT')
parser.add_option('--log_file',
dest='log_file',
default='autobackup.log',
help='change output log file (default: autobackup.log)',
metavar='FILE')
parser.add_option('-n',
'--name',
dest='server_name',
help='change server name',
metavar='NAME')
parser.add_option(
'--no_create_date_subdir',
dest='no_create_date_subdir',
action='store_true',
default=False,
help='do not create subdirs in ouput_dir for media dates')
parser.add_option('-o',
'--output_dir',
dest='output_dir',
help='output directory for files',
metavar='DIR')
parser.add_option('-q',
'--quiet',
dest='quiet',
action='store_true',
default=False,
help='only log errors to console')
parser.add_option('--update_camera_config',
dest='update_camera_config',
help='update camera with this servers configuration',
metavar='MOUNTPOINT')
(options, args) = parser.parse_args()
log_opts = common.LOG_DEFAULTS.copy()
lf_log_opts = common.LOG_DEFAULTS.copy()
if options.quiet:
log_opts['level'] = logging.WARN
if options.debug:
print 'enabling debug'
lf_log_opts['level'] = logging.DEBUG
logger = logging.getLogger('pc_autobackup')
logger.setLevel(logging.DEBUG)
lf_handler = TimedRotatingFileHandler(options.log_file,
when="midnight",
backupCount=3)
lf_handler.setLevel(lf_log_opts['level'])
lf_log_opts['format'] = '%(asctime)s[%(name)s] %(levelname)s:%(message)s'
formatter = logging.Formatter(lf_log_opts['format'],
lf_log_opts['datefmt'])
lf_handler.setFormatter(formatter)
logger.addHandler(lf_handler)
console = logging.StreamHandler()
console.setLevel(log_opts['level'])
formatter = logging.Formatter(log_opts['format'], log_opts['datefmt'])
console.setFormatter(formatter)
logger.addHandler(console)
if not options.config_file:
options.config_file = common.CONFIG_FILE
config = common.LoadOrCreateConfig(options.config_file)
update_config = False
if options.bind:
config.set('AUTOBACKUP', 'default_interface', options.bind)
update_config = True
if options.no_create_date_subdir:
config.set('AUTOBACKUP', 'create_date_subdir', '0')
update_config = True
if options.output_dir:
config.set('AUTOBACKUP', 'backup_dir', options.output_dir)
update_config = True
if options.server_name:
config.set('AUTOBACKUP', 'server_name', options.server_name)
update_config = True
if update_config:
with open(options.config_file, 'wb') as config_file:
config.write(config_file)
if options.create_camera_config:
UpdateCameraConfig(options.create_camera_config,
create_desc_file=True,
config_file=options.config_file)
sys.exit(0)
if options.import_camera_config:
ImportCameraConfig(options.import_camera_config,
config_file=options.config_file)
sys.exit(0)
if options.update_camera_config:
UpdateCameraConfig(options.update_camera_config,
config_file=options.config_file)
sys.exit(0)
if config.has_option('AUTOBACKUP', 'default_interface'):
interface = config.get('AUTOBACKUP', 'default_interface')
logger.info('PCAutoBackup started on %s', interface)
else:
interface = ""
logger.info('PCAutoBackup started on all interfaces')
logger.info('Server name: %s', config.get('AUTOBACKUP', 'server_name'))
if options.debug:
GetSystemInfo(config_file=options.config_file)
reactor.listenMulticast(1900,
ssdp.SSDPServer(options.config_file),
listenMultiple=True)
logger.info('SSDPServer started')
resource = mediaserver.MediaServer(options.config_file)
factory = Site(resource)
reactor.listenTCP(52235, factory, interface=interface)
logger.info('MediaServer started')
reactor.run()
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class MulticastEchoer(DatagramProtocol):
def startProtocol(self):
"""
Called after protocol has started listening.
"""
# Set the TTL>1 so multicast will cross router hops:
self.transport.setTTL(5)
# Join a specific multicast group:
self.transport.joinGroup("228.0.0.5")
def datagramReceived(self, datagram, address):
print("Data %s received from %s" % (repr(datagram), repr(address)))
if datagram == "Client: Ping":
# Rather than replying to the group multicast address, we send the
# reply directly (unicast) to the originating port:
self.transport.write(b"Server: Pong", address)
# We use listenMultiple=True so that we can run muticast server and client on same machine
reactor.listenMulticast(8005, MulticastEchoer(), listenMultiple=True)
reactor.run()
"""
Reference:
https://twistedmatrix.com/documents/15.1.0/core/howto/udp.html
https://twisted.readthedocs.io/en/twisted-17.9.0/index.html
"""
def makedirs(path):
try:
os.makedirs(path)
except os.error as e:
print "Ignoring os.error: ", e
def take_photo(dest):
print "capturing " + dest
if config.PI_MOCK_CAMERA:
with open(dest, 'w') as outfile:
outfile.write('mock camera. no image!')
else:
cmd = 'raspistill -o %s %s' % (dest, config.PI_RASPISTILL_OPTIONS)
pid = subprocess.call(cmd, shell=True)
print 'done.'
def photo_path(dir, name, suffix):
""" Convert a photo name to a path
Eg. dir/name_suffix.jpg
"""
filename = name + "_" + suffix + '.jpg'
return os.path.join(dir, filename)
reactor.listenMulticast(config.MCAST_PORT, Pi3dScanServer(), listenMultiple=True)
reactor.run()
def main():
reactor.listenMulticast(1001, MulticastPingPong(), listenMultiple=True)
reactor.run()
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class MulticastHelloServer(DatagramProtocol):
def startProtocol(self):
"""
Called after protocol has started listening.
"""
# Set the TTL>1 so multicast will cross router hops:
self.transport.setTTL(5)
# Join a specific multicast group:
self.transport.joinGroup("228.0.0.5")
def datagramReceived(self, datagram, address):
print("Datagram %s received from %s" % (repr(datagram), repr(address)))
if datagram == b"Hello World":
# Rather than replying to the group multicast address, we send the
# reply directly (unicast) to the originating port:
self.transport.write(b"Hello World", address)
# We use listenMultiple=True so that we can run multicast_udp_server.py and
# multicast_udp_client.py on same machine:
reactor.listenMulticast(8005, MulticastHelloServer(), listenMultiple=True)
reactor.run()
indigo.server.log("Intuition: generated watts: " +
gen_watts)
indigo.server.log("Intuition: exported watts: " +
exp_watts)
else:
print "Gen: %s Exp: %s" % (gen_watts, exp_watts)
# Electricity data packet - repeats the data for each of the 3 channels supported by the transmitter
# Used power is channel 0
if root.tag == 'electricity':
for elem in root.findall('chan'):
if elem.get('id') == '0':
used_watts = elem.find('curr').text
# remove the decimal points
if used_watts.endswith('.00'):
used_watts = used_watts[:-3]
if INDIGO == True:
indigo.variable.updateValue("Intuition_Used",
used_watts)
indigo.server.log("Intuition: used watts: " +
used_watts)
else:
print "Used: %s" % used_watts
# also weather packet that can be received
reactor.listenMulticast(multicast_port, NetworkOwl())
reactor.run()
for item in itens:
if itens[item] > stock_total[item]['quantity']:
payload_message = "We have only {} units of {} in our warehouses".format(stock_total[item]['quantity'], item)
status_ok = False
break
if status_ok:
for item in itens:
stock_total[item]['quantity'] -= itens[item]
payload_message = "Your itens are reserved"
version += 1
flush_stock()
update_others(request.get('payload'))
response = {
'source': 'server',
'payload': {
'message': payload_message,
'done': status_ok
}
}
self.request.send(json.dumps(response).encode())
tcp_server = TCPServer((my_address, my_port), TCPHandler)
tcp_thread = threading.Thread(target=tcp_server.serve_forever)
tcp_thread.daemon = True
tcp_thread.start()
reactor.listenMulticast(10000, MulticastingServer(), listenMultiple=True)
reactor.run()
def main():
# listen for reply on different unicast port
reactor.listenMulticast(9999, MulticastPingClient(), listenMultiple=True)
reactor.run()
def runLoop(rules={}, timer_hook=None):
proto = XMProtocol(rules, timer_hook)
reactor.listenMulticast(9898, proto, listenMultiple=True)
reactor.run()
def main(args):
if args.pid_file:
fp = file(args.pid_file, 'w')
fp.write(str(os.getpid()))
fp.close()
if args.port != 3333:
'''User most likely provided host/port
for getwork interface. Let's try to detect
Stratum host/port of given getwork pool.'''
try:
new_host = (yield utils.detect_stratum(args.host, args.port))
except:
log.exception("Stratum host/port autodetection failed")
new_host = None
if new_host != None:
args.host = new_host[0]
args.port = new_host[1]
log.info("Stratum proxy version: %s" % version.VERSION)
if args.tor and args.host != 'pool.itzod.ru':
log.info("Configuring Tor connection")
args.proxy = '127.0.0.1:9050'
args.host = 'pool57wkuu5yuhzb.onion'
args.port = 3333
if args.proxy:
proxy = args.proxy.split(':')
if len(proxy) < 2:
proxy = (proxy, 9050)
else:
proxy = (proxy[0], int(proxy[1]))
log.info("Using proxy %s:%d" % proxy)
else:
proxy = None
if args.pow_algo == 'scrypt':
args.real_target = True
if args.host == 'pool.itzod.ru':
args.host = 'ltcmine.ru'
log.info("Trying to connect to Stratum pool at %s:%d" %
(args.host, args.port))
# Connect to Stratum pool
f = SocketTransportClientFactory(
args.host,
args.port,
debug=args.verbose,
proxy=proxy,
event_handler=client_service.ClientMiningService)
utils.set_hashing_algo(args.pow_algo)
log.info("Setting PoW algo: %s" % args.pow_algo)
job_registry = jobs.JobRegistry(f,
cmd=args.blocknotify_cmd,
no_midstate=args.no_midstate,
real_target=args.real_target,
chk_diff=args.chk_diff)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
workers = worker_registry.WorkerRegistry(f)
f.on_connect.addCallback(on_connect, workers, job_registry)
f.on_disconnect.addCallback(on_disconnect, workers, job_registry)
if args.test:
f.on_connect.addCallback(test_launcher, job_registry)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
# Block until proxy connect to the pool
yield f.on_connect
# Setup getwork listener
if args.getwork_port > 0:
reactor.listenTCP(args.getwork_port,
Site(
getwork_listener.Root(
job_registry,
workers,
stratum_host=args.stratum_host,
stratum_port=args.stratum_port,
custom_lp=args.custom_lp,
custom_stratum=args.custom_stratum,
custom_user=args.custom_user,
custom_password=args.custom_password)),
interface=args.getwork_host)
# Setup stratum listener
if args.stratum_port > 0:
stratum_listener.StratumProxyService._set_upstream_factory(f)
reactor.listenTCP(
args.stratum_port,
SocketTransportFactory(debug=False,
event_handler=ServiceEventHandler))
# Setup multicast responder
reactor.listenMulticast(3333,
multicast_responder.MulticastResponder(
(args.host, args.port), args.stratum_port,
args.getwork_port),
listenMultiple=True)
log.info(
"-----------------------------------------------------------------------"
)
if args.getwork_host == '0.0.0.0' and args.stratum_host == '0.0.0.0':
log.info(
"PROXY IS LISTENING ON ALL IPs ON PORT %d (stratum) AND %d (getwork)"
% (args.stratum_port, args.getwork_port))
else:
log.info("LISTENING FOR MINERS ON http://%s:%d (getwork) and stratum+tcp://%s:%d (stratum)" % \
(args.getwork_host, args.getwork_port, args.stratum_host, args.stratum_port))
log.info(
"-----------------------------------------------------------------------"
)
# Setup clean_job notifier
clean_job_factory = WebSocketClientFactory('ws://localhost:9000',
debug=False)
clean_job_factory.protocol = client_service.CleanJobProtocol
reactor.connectTCP('127.0.0.1', 9000, clean_job_factory)
#!/usr/bin/env python2
from LPDoL.multicast import Inducter
from LPDoL.handler import MessageHandler
from LPDoL.common import *
from uuid import uuid1
from twisted.internet import reactor
def cb(x):
print x
if __name__ == '__main__':
p = Peer(uid=uuid1().hex, name='anon', addr='127.0.0.1')
p_l = PeerContainer(cb, cb)
i = Inducter(('224.0.2.38', 8999))
reactor.listenMulticast(8999, i)
h = MessageHandler(p, i.broadcast, p_l)
i.addHandler(h.handle)
reactor.run()
d = reactor.resolve('google.com')
d.addCallback(lambda r: print(r))
# reactor.listenUDP(8001, UDP())
# reactor.run()
################## my socket
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(('0.0.0.0', 8000))
s.setblocking(False)
# reactor.adoptDatagramPort(s.fileno(), socket.AF_INET, UDP())
# reactor.run()
################## MULTICAST
class MultiUDP(DatagramProtocol):
def startProtocol(self):
self.transport.setTTL(5)
self.transport.joinGroup("228.0.0.5")
def datagramReceived(self, datagram, addr):
print(datagram, addr)
self.transport.write(b"Server: Pong", addr)
reactor.listenMulticast(9999, MultiUDP(), listenMultiple=True)
reactor.run()
from __future__ import print_function
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class MulticastPingClient(DatagramProtocol):
def startProtocol(self):
# Join the multicast address, so we can receive replies:
self.transport.joinGroup("228.0.0.5")
# Send to 228.0.0.5:9999 - all listeners on the multicast address
# (including us) will receive this message.
self.transport.write(b'Hello World', ("228.0.0.5", 3010))
def datagramReceived(self, datagram, address):
print("Datagram %s received from %s" % (repr(datagram), repr(address)))
reactor.listenMulticast(3010, MulticastPingClient(), listenMultiple=True)
reactor.run()
# http://blog.csdn.net/ren911/article/details/5313145
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
from twisted.application.internet import MulticastServer
class MulticastServerUDP(DatagramProtocol):
def startProtocol(self):
print 'Started Listening'
self.transport.joinGroup('192.168.100.2')
def datagramReceived(self, datagram, address):
if datagram == 'UniqueID':
print "Server Received:" + repr(datagram)
self.transport.write("data", address)
reactor.listenMulticast(9999, MulticastServerUDP())
reactor.run()
from __future__ import print_function
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class MulticastPingPong(DatagramProtocol):
def startProtocol(self):
"""
Called after protocol has started listening.
"""
# Set the TTL>1 so multicast will cross router hops:
self.transport.setTTL(5)
# Join a specific multicast group:
self.transport.joinGroup("228.0.0.5")
def datagramReceived(self, datagram, address):
print("Datagram %s received from %s" % (repr(datagram), repr(address)))
if datagram == b"Client: Ping" or datagram == "Client: Ping":
# Rather than replying to the group multicast address, we send the
# reply directly (unicast) to the originating port:
self.transport.write(b"Server: Pong", address)
# We use listenMultiple=True so that we can run multicast_udp_server.py and
# multicast_udp_client.py on same machine:
reactor.listenMulticast(9999, MulticastPingPong(), listenMultiple=True)
reactor.run()
def run_client():
reactor.listenMulticast(8005, MulticastClient(), listenMultiple=True)
reactor.run()
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
multicast_ip = "224.0.0.1"
port = 8001
class Multicast(DatagramProtocol):
def startProtocol(self):
self.transport.joinGroup(multicast_ip)
self.transport.write('Notify', (multicast_ip, port))
def datagramReceived(self, datagram, address):
print "Datagram %s received from %s" % (repr(datagram), repr(address))
if datagram == "Notify":
self.transport.write("Acknowlege", address)
reactor.listenMulticast(port, Multicast(), listenMultiple=True)
reactor.run()
def main(argv):
reactor.listenMulticast(RIP_UDP_PORT,
RIP(inputParser(argv)),
listenMultiple=True)
reactor.run()
def owlReceived(self, address, msg):
if debug: print('%s' % (msg))
# write solar data to one file
if re.match('^S', str(msg)):
f = open(soutfile, 'w')
f.write(str(msg))
f.close()
# write elec data to another file
elif re.match('^E', str(msg)):
f = open(eoutfile, 'w')
f.write(str(msg))
f.close()
# else rubbish data and do nothing
if __name__ == '__main__':
from twisted.internet import reactor
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('-i',
'--iface',
dest='iface',
default='',
help='Network interface to use for getting data.')
options = parser.parse_args()
protocol = OwlIntuitionProtocol(iface=options.iface)
reactor.listenMulticast(MCAST_PORT, protocol, listenMultiple=True)
reactor.run()
def main():
# Listen for multicast on 224.1.2.3:12346
reactor.listenMulticast(12346, MulticastServerUDP("tcpstats.sqlite"))
reactor.run()
offer = remove_offer(id=confirm['id'], message_id=confirm['trade-id'])
trades.append(offer)
return 'Trade succesful!'
def handle_cancel(self, cancel):
remove_offer(id=cancel['id'], message_id=cancel['trade-id'])
return 'Trade cancelled'
def handle_greeting(self, host, port):
peer_list = self.read_peerlist()
if host not in peer_list:
self.add_to_peerlist(host, str(port) + "\n")
msg = create_greeting_response(peer_list)
msg = json.dumps(msg)
self.transport.write(msg, (host, port))
print "Greeting received from " + host + ":" + str(port)
return 'Peerlist sent'
def handle_greeting_response(self, data):
self.peers.update(data['peerlist'])
for key, value in self.peers.iteritems():
self.add_to_peerlist(key, value)
print self.peers
return 'Peers added'
if __name__ == '__main__':
reactor.listenMulticast(8005, Trader("listener1"), listenMultiple=True)
reactor.run()
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
from twisted.application.internet import MulticastServer
class MulticastServerUDP(DatagramProtocol):
def startProtocol(self):
print 'Started Listening'
# Join a specific multicast group, which is the IP we will respond to
self.transport.joinGroup('224.0.0.1')
def datagramReceived(self, datagram, address):
# The uniqueID check is to ensure we only service requests from
# ourselves
if datagram == 'UniqueID':
print "Server Received:" + repr(datagram)
self.transport.write("data", address)
# Note that the join function is picky about having a unique object
# on which to call join. To avoid using startProtocol, the following is
# sufficient:
#reactor.listenMulticast(8005, MulticastServerUDP()).join('224.0.0.1')
# Listen for multicast on 224.0.0.1:8005
reactor.listenMulticast(8005, MulticastServerUDP())
reactor.run()
