def main(): # TODO: parse configuration file to retreive # sender's and receiver's ip addresses config_dict = parse_config() if not config_dict: print 'no config params' return sender_name = config_dict['IP'] + '_sender' recv_name = config_dict['IP'] + '_receiver' print 'sender name: ' + sender_name print 'receiver name: ' + recv_name s_obj = Sender() r_obj = Receiver() s_obj.ip_address = config_dict['IP'] r_obj.ip_address = config_dict['IP'] s_obj.multicast_address = config_dict['multicast'] r_obj.multicast_address = config_dict['multicast'] Pyro4.Daemon.serveSimple( { s_obj: sender_name, r_obj: recv_name }, ns=False, port=45000, host=config_dict["IP"] )
def __init__(self): # This are the global variables self.functions_dict = { "phone/mediacenter/play": self.play, "phone/mediacenter/stop": self.stop, "phone/mediacenter/increase_volume": self.increase_volume, "phone/mediacenter/decrease_volume": self.decrease_volume, "phone/mediacenter/pause": self.pause, "phone/mediacenter/loadfile": self.load_file, "phone/mediacenter/position/get": self.get_position } self.sender = Sender() self.client = mqtt.Client() self.client.connect("localhost", 1883, 60) self.client.on_connect = self.on_connect self.client.on_message = self.on_message self.client.on_disconnect = self.on_disconnect self.player = mediaplayer(1, 'MainThread') self.player.exitEvent = self.exit_event self.player.pauseEvent = self.pause_event self.player.playEvent = self.play_event self.player.positionEvent = self.position_event self.player.seekEvent = self.relative_event self.player.stopEvent = self.stop_event self.player.start() self.status = dict() self.count = 0
def __init__(self, config=None): """Initialise the Connector and starts to listen to incoming messages. :param config: Configuration to use (default config if None). """ self.log = logging.getLogger(self.__class__.__name__) if config is None: config = ConnConfig() self.log.info("Falling back to default configuration.") # errors up to here are allowed to terminate the program mappings = self._read_mappings(config.mappings) self.mapper = Mapper(mappings) self.log.debug("Mappings read.") self.sender = Sender(config.send.address, config.send.port, config.broker.endpoint_prefix + config.connector_id, config.broker.topic, config.connector_id) self.log.info("Sender created.") self.receiver = Receiver(self.RECEIVER_NAME, config.listen.address, config.listen.port) self.log.info("Receiver created.") self.receiver.listen("/", self.handle_receive)
def postIpDel(request): form = IpForm(request.REQUEST, request.FILES) if not form.is_valid(): return json_response({"status": FORM_ERR, "result": 'Ошибка формы'}) login = form.cleaned_data['user_login'] del_ips = json.loads(form.cleaned_data['ip_list']) kwargs = {'action': 'del_ip', 'user': login, 'ip_list': '{ip_list:' + json.dumps(del_ips) + '}'} from models import WebApiSetting web_api_settings = WebApiSetting.objects.all(); if len(web_api_settings)>0: sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url) status, reason, resp = sd.sendData(kwargs) if status == ERROR400: return json_response({"status":LOGIN_ERR, "result": "Неверное указано имя пользователя"}) elif status != SUCCESS: logging.error("videoclient.configuration.web_api_users.wiews.postIpDel(connection failed) :" + 'Ошибка соединения при получении списка ip адресов пользователя') return json_response({"status":ERROR, "result": "Повторите запрос позже"}) else: logging.error("videoclient.configuration.web_api_users.wiews.postIpDel(connection failed) :" + 'Отсутствуют настройки для WEB API') return json_response({"status":ERROR, "result": "Повторите запрос позже"}) return json_response({"status": OK, "result": "IP-адреса удалены (" + str(len(del_ips)) + ')'})
def __init__(self, addr, client_id): self.sender = Sender(addr) self.model = utility.getNewModel() self.client_id = client_id self.datasets = 0 self.weights = self.model.get_weights() self.sent = True
def run(self): self.is_running = True if self.is_listening: if self.is_verbose: print "\033[34m[*]\033[0m starting the listener ...." ''' START Listener ''' self.listener = Listener(open_sock=self.sock, isVerbose=self.is_verbose) self.listener.daemon = True self.listener.start() if self.is_verbose: print "\033[34m[*]\033[0m starting the sender ...." ''' START Sender''' self.sender = Sender(sock=self.sock, messages=self.messages, peers=self.peer, isVerbose=self.is_verbose, msg_freq=self.msgs_freq, wait_time=self.wait_time, gtp_port=self.gtp_port) self.sender_daemon = True self.sender.start() self.sender.join() time.sleep(5) self.stop()
def run_mirror(coord, transmission_protocol, identifier, sender_ipc_focus, receiver_ipc_focus, receiver_ipc_light, senders_ipc_mirrors, receivers_ipc_mirrors): mirror = Mirror(identifier=identifier, coord=coord) mirror.sender_focus_ = Sender(sender_ipc_focus, transmission_protocol, verbose=False) mirror.receiver_focus_ = Receiver(receiver_ipc_focus, transmission_protocol, verbose=False) mirror.receiver_light_src_ = Receiver(receiver_ipc_light, transmission_protocol, verbose=False) for i, ipc in senders_ipc_mirrors.items(): mirror.senders_mirrors_[i] = Sender(ipc, transmission_protocol, verbose=False) for i, ipc in receivers_ipc_mirrors.items(): mirror.receivers_mirrors_[i] = Receiver(ipc, transmission_protocol, verbose=False) if identifier == 0: mirror.run(is_first_to_adjust=True) else: mirror.run()
def main(): CONNECTION_STRING = os.getenv('EdgeHubConnectionString') CA_CERTIFICATE = os.getenv('EdgeModuleCACertificateFile', False) sender = Sender(CONNECTION_STRING, CA_CERTIFICATE) print("connected to "+CONNECTION_STRING) global r r = sr.Recognizer() with sr.Microphone() as source: while True: # obtain audio from the microphone print("Say something!") audio = r.listen(source) # recognize speech using Sphinx try: if sender: msg_properties = { 'detection_index': str(detection_index) } json_formatted = json.dumps({"text":r.recognize_sphinx(audio)}) sender.send_event_to_output(json_formatted, msg_properties, detection_index) print("Sphinx thinks you said " + r.recognize_sphinx(audio)) except sr.UnknownValueError: print("Sphinx could not understand audio") except sr.RequestError as e: print("Sphinx error; {0}".format(e))
def test1(key, sent): # Initialize Sender and Receiver with key S = Sender(key) R = Receiver(key) print '### SEND ###' print sent print '############' # Loops if there is an error with the transfer while True: # Builds & encrypts packets to send C = S.send(sent) print '### ENCRYPTED PACKETS ###' for c in C: print repr(c) print '#########################' # Decrypts & rebuilds packets in correct order err, received = R.receive(C) if (err == None): break else: print 'Uh Oh' sys.exit(1) print '### RECEIVE ###' print received print '###############' test = sent == received print 'sent = received? ' + str(test) print '###############\n' return test
def OnActionStart(self, event): handler = rt.RichTextHTMLHandler() handler.SetFlags(rt.RICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64) handler.SetFontSizeMapping([7,9,11,12,14,22,100]) import cStringIO stream = cStringIO.StringIO() if not handler.SaveStream(self.richTextPanel.rtc.GetBuffer(), stream): return htmldata = stream.getvalue() text = content.mime_message(htmldata, "hello hello this is a test", "this is a test", "*****@*****.**", "*****@*****.**").as_string() with open('email-example.eml', 'w') as f: f.write(text) #start send listctrl = self.list_ctrl _count = listctrl.GetItemCount() _host = config.read_config(config.HOST) _port = config.read_config(config.PORT) _user = config.read_config(config.ACCOUNT_NAME) _password = config.read_config(config.PASSWORD) _from = config.read_config(config.FROM) sender = Sender(_host, _port) sender.login(_user, _password) for i in range(_count): sender.send(_from, listctrl.GetItem(i, 1).GetText(), text)
def __init__(self, args): self.sender = Sender(args.port, train=True) self.algorithm = args.algorithm curr_file_path = os.path.dirname(os.path.abspath(__file__)) saved_models_path = os.path.join(curr_file_path, 'saved_models') make_sure_path_exists(saved_models_path) dagger_path = os.path.join(saved_models_path, 'dagger') reinforce_path = os.path.join(saved_models_path, 'reinforce') if self.algorithm == 'dagger': self.learner = Dagger(state_dim=self.sender.state_dim, action_cnt=self.sender.action_cnt, train=True, save_vars=dagger_path, restore_vars=None, debug=True) elif self.algorithm == 'reinforce': self.learner = Reinforce(state_dim=self.sender.state_dim, action_cnt=self.sender.action_cnt, train=True, save_vars=reinforce_path, restore_vars=None, debug=True) self.sender.set_sample_action(self.learner.sample_action) self.max_batches = 2000 self.episodes_per_batch = 1
def main(): receiver = Receiver() sender = Sender() thread.start_new_thread(receiver.listen, ()) time.sleep(1) sender.send()
def reset(self): """Must be called before running rollout().""" self.cleanup() self.port = get_open_udp_port() #start sender as an instance of Sender class sys.stderr.write('Starting sender...\n') self.sender = Sender(self.port, train=True) self.sender.set_sample_action(self.sample_action) self.sender.set_update_Qnet(self.update_Qnet) # start receiver in a subprocess sys.stderr.write('Starting receiver...\n') receiver_src = path.join(project_root.DIR, 'env', 'run_receiver.py') # path of run_receiver.py recv_cmd = 'python %s $MAHIMAHI_BASE %s' % (receiver_src, self.port) cmd = "%s -- sh -c '%s'" % (self.mahimahi_cmd, recv_cmd) sys.stderr.write('$ %s\n' % cmd) #Popen: Execute a child program in a new process. #preexec_fn is set to a callable object, this object will be called in the child process just before the child is executed. (Unix only) #os.setsid: To keep the child process running while the parent process exit. self.receiver = Popen(cmd, preexec_fn=os.setsid, shell=True) # sender completes the handshake sent from receiver self.sender.handshake() state = [ self.sender.delay_ewma, self.sender.send_rate_ewma, self.sender.delivery_rate_ewma, self.sender.cwnd ] return state
def __init__(self, config, log): Sender.__init__(self, config, log) self.access_key = config.get('Messenger', 'gcm_access_key') self.base_deeplink_url = config.get('Messenger', 'base_deeplink_url') self.gcm = GCM(self.access_key) self.canonical_ids = [] self.unregistered_devices = []
def __init__(self, config, log): Sender.__init__(self, config, log) self.access_key = config.get('Messenger', 'gcm_access_key') self.base_deeplink_url = config.get('Messenger', 'base_deeplink_url') self.gcm = GCM2(self.access_key) self.canonical_ids = [] self.unregistered_devices = []
def postTableStatistics(request): form = StatisticForm(request.REQUEST, request.FILES) if not form.is_valid(): return json_response({"status": FORM_ERR, "result": 'Повторите запрос позже'}) data = dict() login = form.cleaned_data['user_login'] s_date = form.cleaned_data['start_date'] e_date = form.cleaned_data['end_date'] query = form.cleaned_data['query'] sorto = form.cleaned_data["sorto"] data['sorto'] = sorto data['up'] = form.cleaned_data['up'] kwargs = {'user': login, 'query': query, 'start_date': s_date, 'end_date': e_date} from models import WebApiSetting web_api_settings = WebApiSetting.objects.all(); if len(web_api_settings)==0: logging.error("videoclient.configuration.web_api_users.wiews.postIpDel(connection failed) :" + 'Отсутствуют настройки для WEB API') return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'}) sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].stat_url) status, reason, resp = sd.sendData(kwargs) del sd if status == ERROR400: return json_response({"status": LOGIN_ERR, "result": 'Неизвестный пользователь'}) if status != SUCCESS: return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'}) ipstat = json.loads(resp) #вычисляем суммы столбцов и строк таблицы total = {} column_list = ['detect', 'detect_and_identification', 'fanstudio'] for column_name in column_list: total[column_name] = 0 total['total'] = 0 for host in ipstat: host['total'] = 0 for column_name in column_list: total[column_name] += host[column_name] total['total'] += host[column_name] host['total'] += host[column_name] #сортируем sort_fields = ["ip", 'detect', 'detect_and_identification', 'fanstudio', 'total'] if sorto > 0 and sorto <= len(sort_fields): sort = [[sort_fields[sorto - 1]]] ipstat = GlobalSortUser(ipstat, sort, 1, up=form.cleaned_data["up"]) data['table'] = ipstat data['total'] = total from django.template import loader if ipstat: result = loader.render_to_string('stat_table.html', data) else: result = False return json_response({'result': result, 'status': OK})
def __init__(self, config, log): Sender.__init__(self, config, log) self.sandbox = config.getboolean('Messenger', 'apns_sandbox') self.certificate_path = config.get('Messenger', 'apns_certificate_path') self.topic = config.get('Messenger', 'apns_topic') self.apn = APNsClient(self.certificate_path, use_sandbox=self.sandbox, log=log) self.canonical_ids = [] self.unregistered_devices = []
def create_frames(self): sender_page = Sender(self.container, self, self.user_name) self.frames.update({"sender_page": sender_page}) sender_page.grid(row=0, column=0, sticky="nsew") home_page = Home(self.container, self, self.user_name) self.frames["home_page"] = home_page home_page.grid(row=0, column=0, sticky="nsew")
def testSendDataWithNullData(getFixtures): try: pubsub = "foo" sender = Sender(getFixtures.topic) sender.sendData(None, 1) except Exception as ex: assert (type(ex) is ValueError)
def __init__(self, config, log): Sender.__init__(self, config, log) self.base_deeplink_url = config.get('Messenger', 'base_deeplink_url') app = generate_fcm_app( config.get('Messenger', 'google_application_credentials')) self.FCM = FCM(app) self.canonical_ids = [] self.unregistered_devices = []
def main(): args = get_args() sender = Sender(type=args.type, dst_ip=args.dst_ip, dst_port=args.dport, src_port=args.sport, length=args.plen or 1) sender.send_data()
def __init__(self, Twitter_UserID, CqHost, GroupID, CqToken): self.sender = Sender(CqHost, GroupID, CqToken) self.sender.start() self.t = TweetApi(Twitter_UserID) while True: for i in self.t.updateTweet(): self.sender.send(i) sleep(Config.CheckSec)
def __init__(self): super().__init__() self.__sender = Sender(Sender.DEFAULT_IP, Sender.DEFAULT_PORT) self.setupUi(self) self.__socket_created = False self.__sender.log_message_signal.connect(self.write_in_log) self.__sender.file_sent_signal.connect(self.enable_components)
def verify(self, plain_text): sender = Sender(self) receiver = Receiver(self) self.generate_keys(sender, receiver) cypher_text = self.encode(plain_text, sender.get_key()) decoded_text = self.decode(cypher_text, receiver.get_key()) if plain_text == decoded_text: return True return False
def bootstrap_connection(self): """ Initializes the receiver and sender threads """ self.receiver = Receiver(self.conn_socket, self.receiver_q, self.config.debug_token) self.receiver.start() self.sender = Sender(self.conn_socket, self.sender_q, self.config.debug_token) self.sender.start() self.config.state = State.UNSECURED_CONN
def update_data(): result = [] sender = None for origin_class in cachcat_crawler.__all__: page = 1 print(origin_class) while page <= 1: d = getattr(cachcat_crawler, origin_class)(page=page) result += d.new_items page += 1 object_data = { 'Notices': { 'data': sorted(result, key=lambda x: x['posted_at']), 'id_key': 'id' }, } for name, info in object_data.items(): data_objects = [] LEANCLOUD_OBJECT_DATA = load_json(os.path.join('leancloud_data', name)) data_dict = {} for item in info['data']: if data_changed( LEANCLOUD_OBJECT_DATA.get( object_id_key(name, item.get(info['id_key'])), {}), item): if info['id_key'] not in item: continue data_objects.append( leancloud_object(name, item, info['id_key'])) data_dict[item.get(info['id_key'])] = item print(name + " Total Count:" + str(len(info['data']))) print(name + " Changed Count:" + str(len(data_objects))) i = 0 batch_size = 50 while True: if len(data_objects[i:i + batch_size]) > 0: leancloud.Object.save_all(data_objects[i:i + batch_size]) i += batch_size else: break for data_object in data_objects: OBJECT_ID_MAP[object_id_key(name, data_object.get( info['id_key']))] = data_object.id LEANCLOUD_OBJECT_DATA[object_id_key( name, data_object.get(info['id_key']))] = data_dict[data_object.get( info['id_key'])] write_json('local_config/object_id_map.json', OBJECT_ID_MAP) write_json(os.path.join('leancloud_data', name), LEANCLOUD_OBJECT_DATA) for data_object in data_objects: if sender is None: sender = Sender() sender.send(data_dict[data_object.get(info['id_key'])], data_object.id)
class CoapClass(ProtocolClient): def __init__(self): self.port = 5683 self.reg = Registry() self.send = Sender() #self.coapSensors = self.reg.getCoapSensors() def dataProcessing(self, receivedData): if (receivedData["registred"] != True): print(receivedData['regInfos']) dbIds = self.reg.registerResourceIC(receivedData['localId'], receivedData['regInfos']) dbIds = True if (dbIds != False): print(' ') print('call reg') dbIds = self.reg.consultRegister(receivedData['localId']) if (dbIds != False): dbIds = self.reg.registerResourceIC( receivedData['localId'], receivedData['regInfos']) #print(self.coapSensors) else: print('erro no cadastro') else: print('Sensor without status identified') #if is a sensor without state dbIds = self.reg.registerResourceIC(receivedData['localId'], receivedData['regInfos']) if (dbIds != False): #send data to IC self.send.sendDataIC(dbIds, receivedData['data']) def startListening(self): print("\033[33mSTART LISTENING COAP INITIALIZED\033[m") server = CoAPServer("0.0.0.0", 5683) try: server.listen(10) except KeyboardInterrupt: print("Server Shutdown") server.close() print("Exiting...") def requestSensorData(self): print("\033[35mREQUEST SENSOR DATA INITIALIZED\033[m") path = 'data' #for sensor in self.coapSensors: client = HelperClient(server=(self.coapSensors["sensor"]["address"], 5683)) self.response = client.get(path) self.data = json.loads(self.response.payload) print(self.data) #dbIds = self.reg.consultRegister(self.data['localId']) #self.send.sendDataIC(dbIds,self.data) print('Sended')
def __init__(self): self.names = utils.get_names() self.actions = {j:i for i,j in self.names.items()} # special case for stopping the car when a stop or red light signal is detected self.actions[-1] = 'stop' # parts self.sender = Sender() self.decisor = Decisor() self.capture = Capture()
def submit(d): header = Header(d["method"], d["path"], d["httpversion"]) for i in d['headers']: header.add_header(i['header_name'], i['header_value']) header.build_from_text() print(header.payload) s = Sender() r = Response() resp = r.input_text(s.send(d["protocol"], d["hostname"], header.payload)) return resp
def __init__(self, packet_sender): print 'Init Connection' self.ee = EventEmitter() self._sender = Sender(packet_sender) self._receiver = Receiver(packet_sender) @self._receiver.ee.on('data') def on_data(data): self.ee.emit('data', data)
def main(): setting.init() host = input("Your IP or hostname: ") port = int(input("Your port: ")) receiver = Receiver(host, port) partner_host = input("Partner's IP or hostname: ") partner_port = int(input("Partner's port: ")) sender = Sender(partner_host, partner_port) threads = [receiver.start(), sender.start()]
def run_node(transmission_protocol, identifier, sender_ipc_topology, receiver_ipc_topology, senders_ipc_neighbor, receivers_ipc_neighbor): node = Node(identifier=identifier) node.sender_des_node_ = Sender(sender_ipc_topology, transmission_protocol, verbose=False) node.receiver_des_node_ = Receiver(receiver_ipc_topology, transmission_protocol, verbose=False) for i, ipc in senders_ipc_neighbor.items(): node.senders_neighbors_[i] = Sender(ipc, transmission_protocol, verbose=False) for i, ipc in receivers_ipc_neighbor.items(): node.receivers_neighbors_[i] = Receiver(ipc, transmission_protocol, verbose=False) node.run()
def update_status(): if "To" in request.form and "MessageStatus" in request.form: LOGGER.info( f"STATUS UPDATE {request.form['To']}: {request.values['MessageStatus']}" ) try: sender = Sender(request.form["To"]) sender.update(request.values["MessageStatus"]) except Exception as e: LOGGER.error(e) return str(MessagingResponse())
def stream_sdata(self, datasize, cl_port): if self.state != 2: logging.error('stream_sdata: unexpected cur_state=%s', self.state) return # to_addr = (self.cl_ip, cl_port) sender = Sender(dst_addr = to_addr, proto = self.proto, datasize = datasize, tx_type = self.tx_type, file_url = self.file_url ) sender.init_send()
def main(): users = Users() receiver = Receiver() sender = Sender() while True: receiver.read_emails(users) for user in users.users_map.values(): if user.modified: sender.send_news(user.email, list(user.topics_set)) user.modified = False print ('Sleeping') sleep(10) print ('Waking up')
def monitor_tilt(): sender = Sender() while True: beacons = distinct(blescan.parse_events(sock, 10)) for beacon in beacons: if beacon['uuid'] in TILTS.keys(): sender.add_data({ 'color': TILTS[beacon['uuid']], 'timestamp': datetime.datetime.now().isoformat(), 'temp': to_celsius(beacon['major']), 'gravity': beacon['minor'] }) time.sleep(10)
def __init__(self, source_addr, dest_addr): self.source_addr = source_addr self.dest_addr = dest_addr self.q = Queue() self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.bind(source_addr) self.connections = {} self.users = self.get_users() self.r = Receiver(self.sock, self.q, self.connections) self.s = Sender(self.sock, self.q) self.r.start() self.s.start()
def getTableIp(request): form = UserForm(request.REQUEST, request.FILES) data = dict() ips = [] if form.is_valid(): login = form.cleaned_data["user_login"] sorto = form.cleaned_data["sorto"] up = form.cleaned_data["up"] data.update(form.cleaned_data) kwargs = {'action': 'get_ip', 'user': login} from models import WebApiSetting web_api_settings = WebApiSetting.objects.all(); if len(web_api_settings)>0: sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url) status, reason, resp_str = sd.sendData(kwargs) if status == ERROR400: data["error"] = LOGIN_ERR elif status != SUCCESS: data["error"] = ERROR else: resp = json.loads(resp_str) if 'ip_list' in resp: ips = resp['ip_list'] else: logging.error("videoclient.configuration.web_api_users.wiews.getTableIp(connection failed) :" + 'Отсутствуют настройки для WEB API') data["error"] = ERROR else: data["user_login"] = '' data["error"] = FORM_ERR if 'error' in data: return json_response({'status': data["error"], 'result': ''}) #сортируем sort_fields = ["ip"] sorto = form.cleaned_data["sorto"] if sorto > 0 and sorto <= len(sort_fields): ips = sorted(ips, reverse=(up == 0)) data["ip_list"] = ips from django.template import loader result = loader.render_to_string('ip_table.html', data, context_instance=RequestContext(request)) return json_response({'status': OK, 'result': result})
def __send_broadcast_frame(self, frame): """ Method that send broadcast frame if possible or push the frame to the queue of all Workers. This is necessary because we are not able to identify ACK frames because of the missing sequence number on WiWo frames. """ if self.__are_workers_available_for_broadcast_frame(): self.__set_workers_to_wait_response(frame) Sender.send(frame, self.__iface_name) else: time.sleep(1) # TODO: Fix this code, it's not clear. if self.__are_workers_available_for_broadcast_frame(): self.__set_workers_to_wait_response(frame) Sender.send(frame, self.__iface_name)
def main(): sender = Sender('localhost') sender.connect() sender.create_queue('inbox') sender.send_message('inbox', 'hello') sender.disconnect() receiver = Receiver('localhost') receiver.connect() receiver.receive('inbox') receiver.disconnect()
def _send(self, frame, iface_name): self.__communication_status = Worker.COMMUNICATION_WAITING self.__last_frame_sent = frame frame = Sender.send(frame, iface_name) log_line = "- [SENT]: %s" % repr(frame) self.__frame_log.append(log_line) return frame
def sender_query(self, mac=None, sort='last_seen', time_window=None, advanced=None, count=None): """Query the database for a sender by it's MAC address. If mac is None - return a list of all senders. sort can start with `-' to change sort direction time_window - recently seen (X seconds) senders only """ # Parse sorting order direction = 1 if sort.startswith('-'): direction = -1 sort = sort[1:] # Build query where = {} if mac is not None: where['mac'] = mac.lower() if time_window: now = time() where['aggregate.last_seen'] = { '$gt': now - time_window } if advanced is not None: where.update(advanced) senders = self.knowledge.find(where).sort(sort, direction) if count is not None: senders = senders[:count] return Sender.create_from_db(senders)
def __init__(self, config, log): """ APNs Push Sender uses MODIFIED (watch out if you want to update it) PyAPNs module: https://github.com/djacobs/PyAPNs APNs documentation: https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW4 """ Sender.__init__(self, config, log) self.sent_queue = {} self.batch_size = int(config.get('Messenger', 'apns_batch_size')) self.sandbox = config.get('Messenger', 'apns_sandbox') == 'true' self.certificate_path = config.get('Messenger', 'apns_certificate_path') set_logger(log) self.apns = APNs(use_sandbox=self.sandbox, cert_file=self.certificate_path, enhanced=True, write_retries=self.connection_error_retries) self.apns.gateway_server.register_response_listener(self.process_malformed_notification) self.apns.gateway_server.register_error_listener(self.process_failed_notification)
def main(): global indexer, uploader, sender, receiver, downloader setup_signals() logging.info("Asink client started at %s" % (time.strftime("%a, %d %b %Y %X GMT", time.gmtime()))) #create all threads which will be used to process events indexer = Indexer() uploader = Uploader() sender = Sender() receiver = Receiver() downloader = Downloader() #create and set up queues which are used to pass events between threads uploader_queue = Queue() indexer.uploader_queue = uploader_queue uploader.queue = uploader_queue #set on watcher when initialized sender_queue = Queue() uploader.sender_queue = sender_queue sender.queue = sender_queue downloader_queue = Queue() receiver.downloader_queue = downloader_queue downloader.queue = downloader_queue #setup storage provider storage = setup_storage() uploader.storage = storage.clone() downloader.storage = storage #start all threads watcher.start_watching(uploader_queue) indexer.start() uploader.start() sender.start() receiver.start() downloader.start() #sleep until signaled, which will call sig_handler while True: time.sleep(86400) #= 24 hours just for fun
def send(self, url): for output in self.output.keys(): classes = Sender.__subclasses__() for cls in classes: if cls.is_registrar_for(output): params = self.output.get(output) params['subject'] = self.subject params['status'] = self.status params['dryrun'] = self.dryrun params['verbose'] = self.verbose sender = cls(**params) sender.send(url)
class Connection: def __init__(self, packet_sender): print 'Init Connection' self.ee = EventEmitter() self._sender = Sender(packet_sender) self._receiver = Receiver(packet_sender) @self._receiver.ee.on('data') def on_data(data): self.ee.emit('data', data) def send(self, data): self._sender.send(data) def receive(self, packet): if packet.getIsAcknowledgement(): self._sender.verifyAcknowledgement(packet.getSequenceNumber()) else: self._receiver.receive(packet)
def __init__(self, tsid, ssid): Sender.__init__(self, tsid, ssid) self.mid = "" self.timer = Timer() self.uid2player = {} self.presenter = None self.cache_billboard = {} self.cc = CacheCenter(tsid, ssid) self.mode = Question self.idle_state = IdleState(self) self.ready_state = ReadyState(self) self.timing_state = TimingState(self) self.timeup_state = TimeupState(self) self.statistics_state = StatisticsState(self) self.answer_state = AnswerState(self) self.announce_state = AnnounceState(self) self.award_state = AwardState(self) self.ending_state = EndingState(self) self.state = self.idle_state self.SetState(self.idle_state) self.loopGetBillboard()
def getUsersList(): from models import WebApiSetting web_api_settings = WebApiSetting.objects.all(); if len(web_api_settings)>0: sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url) kwargs = {'action': 'get_users'} status, reason, resp_str = sd.sendData(kwargs) #print '>>',resp_str #resp_str = '{"users":[{"login": "******", "daemon_restrictions":{"detect":{"rpsec":10,"rpmin":10},"detect_and_identification":{"rpsec":10,"rpmin":10},"fanstudio":{"rpsec":10,"rpmin":10}},"ip_list":["192.168.0.166","192.168.0.152"]},{"login": "******", "daemon_restrictions":{"detect":{"rpsec":10,"rpmin":10},"detect_and_identification":{"rpsec":10,"rpmin":10},"fanstudio":{"rpsec":10,"rpmin":10}},"ip_list":["192.168.0.166","192.168.0.152","192.168.0.6","192.168.1.1","192.168.0.55","192.168.0.2","192.16.0.166","19.16.0.1","192.168.0.3","192.168.0.152","192.168.1.166","192.168.1.2"]}]}' if status != SUCCESS: resp = {} else: resp = json.loads(resp_str) if 'users' in resp: users = resp["users"] else: users = [] else: users = [] return users
def postDataStatistics(request): form = StatisticForm(request.REQUEST, request.FILES) data = dict() if not form.is_valid(): return json_response({"status": FORM_ERR, "result": 'Повторите запрос позже'}) login = form.cleaned_data["user_login"] s_date = form.cleaned_data['start_date'] e_date = form.cleaned_data['end_date'] query = form.cleaned_data['query'] data["user_login"] = login kwargs = {'user': login, 'query': query, 'start_date': s_date, 'end_date': e_date} from models import WebApiSetting web_api_settings = WebApiSetting.objects.all(); if len(web_api_settings)==0: logging.error("videoclient.configuration.web_api_users.wiews.postDataStatistics(connection failed) :" + 'Отсутствуют настройки для WEB API') return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'}) sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].stat_url) status, reason, resp = sd.sendData(kwargs) del sd if status == ERROR400: return json_response({"status": LOGIN_ERR, "result": 'Неизвестный пользователь'}) if status != SUCCESS: return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'}) stat = json.loads(resp) #если данных для отображения на графике нет, то выводим сообщение if not filter(lambda x: len(filter(lambda x:x[1] > 0, x['data'])) > 0, stat): return json_response({"status": NO_DATA, "result": 'Отсутствуют данные за указанный период'}) e = {} e['resp'] = resp return json_response({'result': e, 'status': OK})
def postChangeKeyAccess(request): form = UserForm(request.REQUEST, request.FILES) if not form.is_valid(): return json_response({"status": FORM_ERR, "result": 'Ошибка формы'}) login = form.cleaned_data["user_login"] new_key = passgen(16) kwargs = {'action': 'change_password', 'login': login, 'new_password': new_key} from models import WebApiSetting web_api_settings = WebApiSetting.objects.all(); if len(web_api_settings)==0: logging.error("videoclient.configuration.web_api_users.wiews.postChangeKeyAccess(connection failed) :" + 'Отсутствуют настройки для WEB API') return json_response({"status": ERROR, "result": 'Повторите запрос позже'}) sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url) status, reason, resp = sd.sendData(kwargs) if status == ERROR400: return json_response({"status":LOGIN_ERR, "result": "Неверное указано имя пользователя"}) elif status != SUCCESS: logging.error("videoclient.configuration.web_api_users.wiews.changeKeyAccess(connection failed) :" + 'Ошибка соединения при получении списка ip адресов пользователя') return json_response({"status":ERROR, "result": "Повторите запрос позже"}) return json_response({'status': OK, 'result': str(new_key)})
def changeNotifyTypeByBalance(db): """ Принудительно изменяет тип оповещений с sms на емаил при балансе ниже нуля О каждом изменении оповещает пользователя на смс и мыло """ from sender import Sender accounts = db.getAccountsForChangeNotify() logging.info("found %d account for change notify type" % len(accounts)) sender = Sender(db) for account in accounts: logging.info("process account %s" % account) acc = db.getAccount(account['id']) if acc is None: logging.error('аккаунт не найден') continue #сменили тип нотификейшенов res = db.setAccountNotify(acc['id'], 'email') logging.debug("change type result %s" % res) message = "%s: balance < 0, notify type change to email" % acc['login'] res1 = sender.sendNotify(acc, message, 'Notify type change by balance', 'sms') res2 = sender.sendNotify(acc, message, 'Notify type change by balance', 'email') logging.debug('result sms - %s; email - %s' % (res1, res2)) if res1 is not True or res2 is not True: logging.error(res1) logging.error(res2) continue logging.info('success notification of change notify type') return len(accounts)
def do_work(self, url): if not isValidScheme(url): logger.warning("not vaild_scheme") return None try: response = yield self.fetch(url) except tornado.httpclient.HTTPError as e: # import traceback # traceback.print_exc() # TODO # Some bug here. Too many file open. # with open('httperror.txt', "a") as f: # f.write("Url: %s HTTPError: %s \n"% (url,e.code)) logger.error("Url: %s HTTPError: %s " % (url, e.code)) except: import traceback traceback.print_exc() logger.error("Unknow error with url: %s" % url) else: url_gen = self.parse(response) self.fetch_finished.append(url) sender = Sender() for u in url_gen: sender.add_url(u) logging.info("fetched %s" % url) self.fetching -= 1
def init( self, host, port, peers, dirName ): logging.info( 'Initializing new peer ' + self.getPeerKey( host, port ) ) self.filesDir = dirName self.host = host self.port = port self.peers = peers self.peerKey = self.getPeerKey( host, port ) self.activePeers = {} self.waitingQueries = [] self.joined = False self.status = Status( self.peerKey ) self.status.registerPeer( self.peerKey, {} ) self.sender = Sender( self ) self.rQueue = Queue() self.shutdownFlag = False self.start()
def __init__(self): QMainWindow.__init__(self) # make variables self.voltage = 0 self.current = 0 # load gui.ui self.ui = loadUi('../gui/gui.ui') self.ui.setAttribute(QtCore.Qt.WA_DeleteOnClose, True) self.ui.destroyed.connect(self.shutdown) # show window self.ui.show() # make new log object self.log = Log(self.ui) # make new sender object self.sender = Sender(self.ui, self.log) # set events self.set_events() # initial reset self.sender.reset() # new listener self.listener = Listener() # new_data_received signal self.listener.data_received.connect(self.new_data_received) # start listener self.listener.start() # new interpreter self.interpreter = Interpreter(self.log, self.ui) # add tree self.add_tree()
def __init__(self, parent=None): QtGui.QMainWindow.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.addCarriers() self.thread = Sender() self.connect(self.ui.actionAbout, QtCore.SIGNAL('triggered()'), self.showAbout) self.connect(self.ui.actionQuit, QtCore.SIGNAL('triggered()'), exit) self.connect(self.ui.button, QtCore.SIGNAL('clicked()'), self.toggle) self.connect(self.thread, QtCore.SIGNAL("finished()"), self.done) self.connect(self.thread, QtCore.SIGNAL("terminated()"), self.done) self.connect(self.thread, QtCore.SIGNAL("plusOne()"), self.plusOne) self.connect(self.thread, QtCore.SIGNAL("sendingError()"), self.stop) self.ui.server.setText('127.0.0.1:25') #set default self.ui.message.setPlainText('SPAM!') self.ui.statusBar().showMessage('Ready') #broken
def main(): create_queue() sender = Sender() receiver = Receiver() sender.start() receiver.start()
def run(self): while True: try: self.rep_ip = self._replication_interface() self.uuid = self._my_uuid() break except: msg = ('Failed to get replication interface or uuid. ' 'Aborting.') return logger.error(msg) ctx = zmq.Context() # fs diffs are sent via this publisher. rep_pub = ctx.socket(zmq.PUB) rep_pub.bind('tcp://%s:%d' % (self.rep_ip, self.data_port)) # synchronization messages are received in this pull socket meta_pull = ctx.socket(zmq.PULL) meta_pull.RCVTIMEO = 100 meta_pull.bind('tcp://%s:%d' % (self.rep_ip, self.meta_port)) total_sleep = 0 while True: if (os.getppid() != self.ppid): logger.error('Parent exited. Aborting.') break while(not self.pubq.empty()): msg = self.pubq.get() rep_pub.send(msg) # check for any recv's coming num_msgs = 0 while (num_msgs < 1000): try: self.recv_meta = meta_pull.recv_json() num_msgs = num_msgs + 1 snap_id = self.recv_meta['id'] if (self.recv_meta['msg'] == 'begin'): rw = Receiver(self.recv_meta) self.receivers[snap_id] = rw rw.start() elif (snap_id not in self.senders): logger.error('Unknown snap_id(%s) received. Ignoring' % snap_id) else: self.senders[snap_id].q.put(self.recv_meta) except zmq.error.Again: break self._prune_workers((self.receivers, self.senders)) if (int(time.time()) - self.prune_time > 3600): self.prune_time = int(time.time()) for rs in ReplicaShare.objects.all(): prune_receive_trail(rs.id, logger) for r in Replica.objects.all(): prune_replica_trail(r.id, logger) if (total_sleep >= 60 and len(self.senders) < 50): try: for r in get_replicas(logger): rt = get_replica_trail(r.id, logger) now = datetime.utcnow().replace(second=0, microsecond=0, tzinfo=utc) sw = None snap_name = 'replication' rt2 = ReplicaTrail.objects.filter().order_by('-id') if (len(rt2) != 0): snap_name = ('%s_%d' % (snap_name, rt2[0].id + 1)) else: snap_name = ('%s_1' % snap_name) snap_id = ('%s_%s_%s_%s' % (self.uuid, r.pool, r.share, snap_name)) if (len(rt) == 0): logger.debug('new sender for snap: %s' % snap_id) sw = Sender(r, self.rep_ip, self.pubq, Queue(), snap_name, self.meta_port, self.data_port, r.meta_port, self.uuid, snap_id) elif (rt[0].status == 'succeeded'): if (((now - rt[0].end_ts).total_seconds() > (r.frequency * 60))): logger.debug('incremental sender for snap: %s' % snap_id) sw = Sender(r, self.rep_ip, self.pubq, Queue(), snap_name, self.meta_port, self.data_port, r.meta_port, self.uuid, snap_id, rt[0]) else: continue elif (rt[0].status == 'pending'): prev_snap_id = ('%s_%s_%s_%s' % (self.uuid, r.pool, r.share, rt[0].snap_name)) if (prev_snap_id in self.senders): logger.debug('send process ongoing for snap: ' '%s' % snap_id) continue logger.debug('%s not found in senders. Previous ' 'sender must have Aborted. Marking ' 'it as failed' % prev_snap_id) msg = ('Sender process Aborted. See logs for ' 'more information') data = {'status': 'failed', 'end_ts': now.strftime(settings.SNAP_TS_FORMAT), 'error': msg, 'send_failed': now, } update_replica_status(rt[0].id, data, logger) continue elif (rt[0].status == 'failed'): snap_name = rt[0].snap_name # if num_failed attempts > 10, disable the replica num_tries = 0 for rto in rt: if (rto.status != 'failed' or num_tries >= self.MAX_ATTEMPTS or rto.end_ts < r.ts): break num_tries = num_tries + 1 if (num_tries >= self.MAX_ATTEMPTS): logger.info('Maximum attempts(%d) reached ' 'for snap: %s. Disabling the ' 'replica.' % (self.MAX_ATTEMPTS, snap_id)) disable_replica(r.id, logger) continue logger.info('previous backup failed for snap: ' '%s. Starting a new one. Attempt ' '%d/%d.' % (snap_id, num_tries, self.MAX_ATTEMPTS)) prev_rt = None for rto in rt: if (rto.status == 'succeeded'): prev_rt = rto break sw = Sender(r, self.rep_ip, self.pubq, Queue(), snap_name, self.meta_port, self.data_port, r.meta_port, self.uuid, snap_id, prev_rt) else: logger.error('unknown replica trail status: %s. ' 'ignoring snap: %s' % (rt[0].status, snap_id)) continue self.senders[snap_id] = sw sw.daemon = True sw.start() total_sleep = 0 except DatabaseError, e: e_msg = ('Error getting the list of enabled replica ' 'tasks. Moving on') logger.error(e_msg) logger.exception(e) time.sleep(1) total_sleep = total_sleep + 1