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