def __init__(self, p_serial, idSessao, timeout, ip1, ip2, bytes_min=0, bytes_max=256): self.min_bytes = bytes_min self.max_bytes = bytes_max self.timeout = timeout self.ser = serial.Serial( p_serial, 9600, timeout=self.timeout) #timeout = timeout do método read da Serial self.enq = enquadramento.Enquadramento(self.ser, 0.05) self.arq = ARQ.ARQ(self.enq, idSessao, self.timeout) self.sessao = sessao.Sessao(self.arq, self.timeout) self.tun = Tun("tun1", ip1, ip2, mask="255.255.255.252", mtu=1500, qlen=4) self.tun.start() self.cb_tun = CallbackTun(self.tun, self) #self = próprio enlayce self.sched = poller.Poller() self.sched.adiciona(self.cb_tun) self.cb_serial = CallbackStdin(self) self.timer = CallbackTimer(0.01, self) self.sched.adiciona(self.cb_serial) self.sched.adiciona(self.timer) self.sched.despache()
def __init__(self, apikey, init_keywords=[]): import analysis import poller as p self.sources = sources self.poller = p.Poller(apikey, init_keywords) self.sa = analysis.SentimentAnalysis() self.ta = analysis.TopicAnalysis()
def do_work_or_quit(update: Update, con: CallbackContext) -> int: logger.info(f"Reply is {update.message.text}") if update.message.text == "No": update.message.reply_text('Ok then.! Bye.!', reply_markup=ReplyKeyboardRemove()) return ConversationHandler.END logger.info(f"Chat id : {update.message.chat_id} - " f"State : {con.user_data['state_id']} - " f"District : {con.user_data['district_id']}, " f"Age : {con.user_data['age']}") status = db_operations.BotDB().insert({ "chat_id": update.message.chat_id, "state_id": con.user_data['state_id'], "state_name": con.user_data['state_name'], "district_id": con.user_data['district_id'], "district_name": con.user_data['district_name'], "age": con.user_data['age'] }) if not status: logger.info("User already available in DB.!") user_data = db_operations.BotDB() \ ._get_item(chat_id=update.message.chat_id)[0] district = user_data['district_name'] age = user_data['age'] update.message.reply_text( f'Bot is already checking vaccine availability for you at {district} district ' f'for {age}+ age. If you want to check availability now for {district} district ' f'for {age}+ age, Send /check_now. If you want to stop checking, Send /stop_bot', reply_markup=ReplyKeyboardRemove()) return ConversationHandler.END poller.Poller(num_days=1, wait=CHECK_MINTS) \ .notify_one_user(district=con.user_data['district_id'], age=con.user_data['age'], district_name=con.user_data['district_name'], chat_id=update.message.chat_id, force=True) update.message.reply_text( f'I will check every {CHECK_MINTS} minutes and notify ' f'when there is a slot availability.!' '\nSend /stop_bot to make me stop checking', reply_markup=ReplyKeyboardRemove()) return ConversationHandler.END
def __init__(self, ser, tun, session): self.tun = tun self.arq = arq.ARQ(ser, self.tun, session) self.tun.start() self.sched = poller.Poller() cbE = Callback.CallbackEnq(self.arq, 0.05) cbT = Callback.CallbackTun(self.arq) self.sched.adiciona(cbE) self.sched.adiciona(cbT)
def __init__(self, serialPath, isTun, id): ''' serialPath: interface serial para troca de dados isTun: boolean que indica se será utilizada a interface tun id: identificação da sessão a ser estabelecida ''' self._isTun = isTun if (self._isTun == True): try: self._dev = serial.Serial(serialPath) except: print("Verifique se a porta serial foi criada") print() sys.exit(0) try: self._tun = tun.Tun("tun0", "10.0.0.1", "10.0.0.2", mask="255.255.255.252", mtu=1500, qlen=4) self._tun.start() except Exception: print("Você deve executar o programa como root!!!") print() sys.exit(0) self._poller = poller.Poller() self._arq = arq.ARQ(None, 1) self._ger = gerencia.GER(None, id, 10) self._enq = framing.Framing(self._dev, 1, 1024, 3) self._tunLayer = tunlayer.TunLayer(self._tun) else: try: self._dev = serial.Serial(serialPath) except: print("Verifique se a porta serial foi criada") print() sys.exit(0) self._poller = poller.Poller() self._arq = arq.ARQ(None, 1) self._ger = gerencia.GER(None, id, 10) self._enq = framing.Framing(self._dev, 1, 1024, 3) self._fake = fakelayer.FakeLayer(sys.stdin, 10)
def inicia(self): ''' Inicia o protocolo ''' self.s.start() sched = poller.Poller() sched.adiciona(self.cb) sched.adiciona(self.e) sched.adiciona(self.a) sched.adiciona(self.s) sched.despache()
def __init__(self, porta, tun): self.serial = porta self.enq = Enq.Enquadramento(self.serial) self.arq = ARQ.ARQ(self.enq) self.tun = tun self.tun.start() self.cbTun = CallbackTun(self.tun, self) self.sched = poller.Poller() self.sched.adiciona(self.cbTun) self.cbSerial = CallbackStdin(self) self.sched.adiciona(self.cbSerial) self.sched.despache()
def __init__(self, ip): ''' O construtor da classe recebe como parâmetro o ip do servidor (IPv6) ''' self.retransmitions = 0 self.p = poller.Poller() self.ip = ip self.coapRequest = bytearray() self.servidor = (ip,5683) self.sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP) self.sock.bind(('::', 0)) self.fd = self.sock self.enable() self.disable_timeout() self.base_timeout = random.uniform(coap.ACK_TIMEOUT,coap.ACK_TIMEOUT*coap.ACK_RANDOM_FACTOR) self.timeout = random.uniform(coap.ACK_TIMEOUT,coap.ACK_TIMEOUT*coap.ACK_RANDOM_FACTOR) self.state = coap.idle
def __init__(self, ip, Uri): ''' Construtor do CoAP: Recebe como parâmetro um IP(IVP6) mais a Uri que será utilizada como destino ao enviar mensagens para o servidor. Cria um socket e vincula-o com o IP fornecido. ''' global Teste_Get self.Poll = poller.Poller() #Objeto que fará o despache dos datagramas self.ip = ip self.servidor = (ip, 5683) self.sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP) self.sock.bind((ip, 0)) self.fd = self.sock self.enable() self.disable_timeout() self.base_timeout = 2 * self.ACK_TIMEOUT_FACTOR self.timeout = 2 * self.ACK_TIMEOUT_FACTOR self.First_Byte = 0x41 # Indica Confirmavel(0), Não-Confirmável(1),Confirmação(2) ou Reset(3) 2bits # tamannho do token a ser usado self.code_Get = 0x01 # GET Class 000 Detail 00001 #Ack é T 10 e code 0.00 self.code_Post = 0x02 self.code_Put = 0x03 self.code_Delete = 0x04 # Valores que foram definidos segundo a RFC 7252 para envio de mensagem COAP self.code_Content_Format = 0x45 self.MID1 = random.randint(0, 255) #Byte randomico para Message ID self.MID2 = random.randint(0, 255) #Byte randomico para Message ID self.payload_config = None self.payload_Date = None self.Uri = Uri self.Token = random.randint(0, 255) ##Byte randomico para Message ID self.state = self.idle self.send = bytearray() self.ack = bytearray() self.Send_ack = bytearray() self.cont = 0 self.Atual_Timeout_Ack = 2 self.Periodo = 0
def check_now(update: Update, _: CallbackContext) -> int: chat_id = update.message.chat_id logger.info(f"{chat_id} wants to check availability now.!") user_data = db_operations.BotDB()._get_item(chat_id=chat_id) if len(user_data) == 0: logger.info(f"User data not found for {chat_id}") update.message.reply_text( 'Looks like you are not registered with the bot, to do that Send' ' /start', reply_markup=ReplyKeyboardRemove()) return ConversationHandler.END logger.info("Got data from DB for {}".format(chat_id)) user_data = user_data[0] poller.Poller(num_days=1, wait=CHECK_MINTS) \ .notify_one_user(district=user_data['district_id'], age=user_data['age'], district_name=user_data['district_name'], chat_id=chat_id, force=True) return ConversationHandler.END
def __init__(self, ser, tun, Start_tun): if (Start_tun == 0): tun.start() print("Aguardando em", ser.port) arq = Arq( None, 1) #'''Criando objetos que vão ser usados pelo poller para fazer Int_tun = Tun_Tun(tun) # o monitoramento dos eventos ''' Fake = Fake_app(sys.stdin, 1) cb = Enquadramento(ser) Manager = Session_Manager(None, 5) Fake.Fake_send(Manager) arq.get_framming(cb) arq.get_Tun(Int_tun) Manager.Get_Tun(Int_tun) Manager.get_Arq( arq) #objeto para enviar primeiro quadro para conection request Manager.Get_Fake(Fake) Manager.Start_Conection() arq.get_Manager(Manager) Int_tun.Tun_send( Manager ) # '''Camada utilizada para testar com captura do teclado''' cb.vem_top(arq) sched = poller.Poller() sched.adiciona(Manager) sched.adiciona(cb) # '''Adicionando os eventos desejados ao poller''' sched.adiciona(arq) sched.adiciona(Fake) sched.adiciona(Int_tun) sched.despache()
import poller import db import ConfigParser if __name__ == "__main__": #pdb.set_trace() FORMAT = "%(asctime)-15s %(message)s" logging.basicConfig(format=FORMAT) logging.log("watch starting up") logging.log("reading configuation file") conf_file = "watch.rc" global conf_parser = ConfigParser.SafeConfigParser() config.readfp(open('watch.rc')) logging.log("connecting to database...") db_conn = None db.check_db(conf_parser.get("db", "file"), db_conn) logging.log("connected") new_video_handler = notifier.NewVideoHandler() poller = poller.Poller(conf_parser.get("poller", "directory"), conf_parser.get("poller", "delay"), new_video_handler) poller.poll() logging.log("watch exiting...")
from ARQ import Arq import sys if __name__ == "__main__": ser = serial.Serial( '/dev/pts/5', 9600, timeout=5) #porta serial que será monitorada pelo poller print("Aguardando em", ser.port) arq = Arq(None, 5) #'''Criando objetos que vão ser usados pelo poller para fazer # o monitoramento dos eventos ''' Fake = Fake_app(sys.stdin, 5) cb = Enquadramento(ser) #objeto para enviar primeiro quadro para conection request arq.get_framming(cb) Fake.Fake_send( arq) # '''Camada utilizada para testar com captura do teclado''' cb.vem_top(arq) sched = poller.Poller() sched.adiciona(cb) # '''Adicionando os eventos desejados ao poller''' sched.adiciona(arq) sched.adiciona(Fake) sched.despache() #print
import poller from constants import fin_sources if __name__ == '__main__': p = poller.Poller('blah', []) print( p.get_articles(['AMD', 'trump', 'fed', 'russia', 'market', 'congress'], fin_sources))
def init_from_config_file(config_file): try: open(config_file) except: raise BaseException("Unreadable configuration file '%s'" % config_file) defaults = {"stream": "stdout"} config = ConfigParser.SafeConfigParser(defaults=defaults) config.read(config_file) port = config.get("poller", "port") polling_interval = config.getfloat("poller", "polling_interval") p = poller.Poller(port, polling_interval) # TODO: move this part to a factory-like function in the loggers.py file logger_sections = config.get("poller", "loggers").split(" ") for logger_section in logger_sections: logger_type = config.get(logger_section, "type") if logger_type == "ScreenLogger": stream_name = config.get(logger_section, "stream") if stream_name == "stdout": stream = sys.stdout elif stream_name == "stderr": stream = sys.stderr else: raise BaseException("Invalid stream '%s'" % stream_name) logger = loggers.ScreenLogger(stream) elif logger_type == "FileLogger": append = config.getboolean(logger_section, "append") filename = config.get(logger_section, "filename") logger = loggers.FileLogger(filename, append) elif logger_type == "MySQLLogger": user = config.get(logger_section, "username") pwd = config.get(logger_section, "password") database = config.get(logger_section, "database") table = config.get(logger_section, "table") logger = loggers.MySQLLogger(user, pwd, database, table) else: raise BaseException("Invalid logger '%s'" % logger_type) p.add_logger(logger) # TODO: move this part to a factory-like function in the monitor.py file monitor_sections = config.get("poller", "monitors").split(" ") for monitor_section in monitor_sections: conditions = config.get(monitor_section, "conditions").split(",") m = monitor.Monitor(conditions) # TODO: move this part either in the above function or in a similar function in callbacks.py callback_sections = config.get(monitor_section, "callbacks").split(" ") for callback_section in callback_sections: callback_type = config.get(callback_section, "type") if callback_type == "WriteToFile": append = config.getboolean(callback_section, "append") filename = config.get(callback_section, "filename") callback = callbacks.WriteToFile(filename, append) elif callback_type == "SendEmail": from_address = config.get(callback_section, "from") recipients = config.get(callback_section, "recipients").split(",") min_interval = config.getfloat(callback_section, "min_interval") callback = callbacks.SendEmail(from_address, recipients, min_interval) elif callback_type == "CallScript": options = {"script_path": config.get(callback_section, "path")} if config.has_option(callback_section, "uid_gid"): uid, gid = config.get(callback_section, "uid_gid").split() options['uid'] = int(uid) options['gid'] = int(gid) callback = callbacks.CallScript(**options) else: raise BaseException("Invalid callback '%s'" % callback_type) m.add_warning_callback(callback) p.add_monitor(m) return p
def __init__(self): self.vhandler = new_video_handler() self.poller = poller.Poller('/tmp/', 10, self.vhandler)
mapping_mod_lock = threading.Lock() # Map: (src_host, src_port) -> server # Useful for removing connections src_to_svr = {} # Map: server_fd -> server # Useful for handling server connections fd_to_svr = {} # Map: socket_fd -> (writer_socket, reader_socket) # Useful for doing transfers of data fd_to_pair = {} poll = poller.Poller() def do_send(reader, writer): """ Handles sending from a reader socket to a writer socket, as well as closing dead sockets. """ logger.debug("Sending A Message From %i -> %i", reader.fileno(), writer.fileno()) try: logger.debug("Reading Message From %i", reader.fileno()) data = writer.recv(4096) logger.debug("Read Message Of Length %i", len(data)) except socket.error as err:
from flask import Flask from log_handlers import ch, fh from config import BOT_TOKEN import routes import logging import poller app = Flask(__name__, static_url_path='/static') app.register_blueprint(routes.api) app.logger.addHandler(ch) app.logger.addHandler(fh) app.logger.setLevel(logging.INFO) if __name__ == '__main__': pollerobj = poller.Poller() pollerobj.daemon = True pollerobj.start() app.run(host='0.0.0.0', port=5000, threaded=True) pollerobj.join()