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()