def __init__(self):
self._config = Configuracao()
self._gestao_d = Gestao_download()
self._loop_controle = True
self._thread_conexao_servidores = []
self._thread_controle = {}
self._iniciar_threads()
def __init__(self):
self._loop_gestao = True
self._thread_gestao = []
self._download_em_espera = {}
self._download_em_andamento = []
self._download_finalizados = []
self._iniciar_servicos()
self._config = Configuracao()
def __init__(self, arquivo, path_destino, servidor):
'''
arquivo - dicionario com as informacoes dos arquivos para download
servidor - objeto com as informacoes para conexao com servidor
'''
self._servidor = servidor
self._config_servidor = servidor.obj_ftp
self._arquivo = arquivo
self._config = Configuracao()
self._path_destino = path_destino
def __init__(self):
self._fim_conexao = 'fim'
self._cmd_desligar = False
self._mensage = ''
self._data = bytes()
self._config = Configuracao()
self._gestao_ftp = Gestao_ftp()
self.ftp = Ftp()
self._bkp_conversor = Backup_dict()
self._loop_controle = True
self._thread_servico = {}
self._thread_controle = {}
self._threads_finalizados = {}
self._threads_ftps = {}
self._lista_bkp_executando = []
self._verifica_servico = 'Verifica servicos'
self._threads_ativos = 'Threads ativos'
self._reg_serv_finalizados = 'Registra servicos'
self._iniciar_thread_controle()
def criar_banco():
try:
if Configuracao.os_system() == 'Windows':
path_db = 'c:/nbackup/db/nbackup.db'
else:
path_db = '/home/marcelo/python/nbackup/db/nbackup.db'
arquivo = open(path_db)
except FileNotFoundError:
Backup.create_table()
Arquivo.create_table()
Log.info('criando banco de dados')
class Gestao_ftp:
def __init__(self):
self._config = Configuracao()
self._ftp = self._config.get_server_config().config_ftp()
self._ftp_andamento = {}
self._ftp_finalizado = []
self._erros = {}
def adicionar(self, info_ftp):
self._info_ftp = info_ftp
thread = Ftp_thread(self._ftp, info_ftp['path'], info_ftp['nome'])
self._ftp_andamento[info_ftp['nome']] = thread
thread.start()
resposta = {
'resposta':'ftp_pronto_download',
'conteudo':self._info_ftp['nome']
}
Log.info('adicionando e iniciando thread ftp: {}'.format(info_ftp['nome']))
return resposta
def desligar(self, nome_backup):
is_desligado = False
try:
thread = self._ftp_andamento[nome_backup]
thread.desligar_servidor()
self._ftp_finalizado.append(thread)
del self._ftp_andamento[nome_backup]
is_desligado = thread.is_desligado()
Log.info('desligando ftp: {}'.format(nome_backup))
except KeyError:
Log.error('KeyError: ftp: {} nao encontrado'.format(nome_backup))
self._erros['KeyError'] = 'ftp {} nao encontrado'.format(nome_backup)
return is_desligado
def get_em_andamento(self):
return self._ftp_andamento
'''
def is_rodando_ftp(self):
is_rodando = False
keys = self._ftp_andamento.keys()
for key in keys:
thread = self._ftp_andamento[key]
is_rodando = thread.is_desligado()
return is_rodando
'''
def is_rodando_ftp(self):
rodando = False
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if sock.connect_ex((self._ftp.host, self._ftp.porta)) == 0:
rodando = True
sock.close()
return rodando
def is_erros(self):
return (len(self._erros) > 0)
def get_erros(self):
return self._erros
def get_ftp_finalizados(self):
return self._ftp_andamento
def __init__(self):
self._config = Configuracao()
self._ftp = self._config.get_server_config().config_ftp()
self._ftp_andamento = {}
self._ftp_finalizado = []
self._erros = {}
from peewee import *
import datetime
from configuracao.config import Configuracao
path_db = Configuracao.config_path() + 'db/nbcliente.db'
db = SqliteDatabase(path_db)
class BaseModel(Model):
class Meta:
database = db
class Servidor(BaseModel):
nome = CharField(max_length=40)
host = CharField(max_length=100)
porta = IntegerField()
qtd_conexoes = IntegerField()
def dict_servidor(self):
json = {
'nome': nome,
'host': host,
'porta': porta,
'qtd_conexoes': qtd_conexoes
}
class Backup(BaseModel):
def __init__(self):
config_server = Configuracao().get_server_config()
self._os = Configuracao.os_system()
self.config = config_server.config_ftp()
from peewee import *
import datetime
from configuracao.config import Configuracao
config = Configuracao()
path_db = config.get_path() + 'db/nbackup.db'
db = SqliteDatabase(path_db)
class BaseModel(Model):
class Meta:
database = db
class Backup(BaseModel):
nome = CharField()
tipo = CharField()
backup_auto = CharField(null=True)
tempo_execucao = FloatField(null=True)
data_execucao = DateTimeField()
#fonte = CharField()
#path_origem = CharField()
#path_destino = CharField()
periodo = CharField()
dia_semana = CharField()
hora_execucao = DateTimeField()
sc_pre_execucao = CharField(null=True)
sc_pos_execucao = CharField(null=True)
sc_backup = CharField(null=True)
@staticmethod
def is_backup_executado(nome, data_execucao, hora_execucao):
class Gestao_download:
def __init__(self):
self._loop_gestao = True
self._thread_gestao = []
self._download_em_espera = {}
self._download_em_andamento = []
self._download_finalizados = []
self._iniciar_servicos()
self._config = Configuracao()
def adicionar(self, servidor, lista_arquivos):
print('servidor: {}'.format(servidor))
print('lista_arquivos: {}'.format(lista_arquivos))
'''
servidor - configuracao do servidor remoto
arquivos - lista de arquivos para download
'''
path_destino = self._config.get_backup_dir(servidor.nome)
arquivos = lista_arquivos['conteudo']
for arquivo in arquivos:
download_ftp = Download_ftp(arquivo, path_destino, servidor)
thread = Download_thread(download_ftp, arquivo['backup'])
self._download_em_espera[arquivo['backup']] = thread
Log.info('Gestao download bkps adicionados, servidor: {}'.format(
servidor.nome))
def get_downloads_executando(self):
'''
Quantos downloads estao executando
'''
return len(self._download_em_andamento)
def executa_download(self, nome_backup):
thread = self._download_em_espera[nome_backup]
self._download_em_andamento.append(thread)
del self._download_em_espera[nome_backup]
thread.start()
Log.info('iniciando thread {}'.format(nome_backup))
def _remove_download_finalizado(self):
while self._loop_gestao:
if len(self._download_em_andamento) > 0:
tamanho_lista = len(self._download_em_andamento)
for index in range(tamanho_lista):
thread = self._download_em_andamento[index]
if thread.is_executado():
self._download_finalizados.append(thread)
del self._download_em_andamento[index]
time.sleep(10)
def _iniciar_servicos(self):
self._loop_gestao = True
monitor_finalizado = Thread(target=self._remove_download_finalizado,
name='monitor_finalizados')
monitor_finalizado.start()
self._thread_gestao.append(monitor_finalizado)
Log.info('iniciando thread: monitor finalizados')
def get_msg_em_espera(self):
dicionario = None
keys = list(self._download_em_espera.keys())
selecao = keys[:1]
for keys in selecao:
thread = self._download_em_espera[keys]
dicionario = {
'servidor': thread.get_download_ftp().get_servidor(),
'mensagem': thread.get_download_ftp().msg_abrir_ftp()
}
return dicionario
def get_msg_finalizados(self):
lista_msg = []
for thread in self._download_finalizados:
download_ftp = thread.get_download_ftp()
mensagem = {
'servidor': download_ftp.get_servidor(),
'comando': download_ftp.msg_fechar_ftp()
}
lista_msg.append(mensagem)
return lista_msg
def remove_finalizado(self, nome_backup):
for thread in self._download_finalizados:
if nome_backup == thread.name:
self._download_finalizados.remove(thread)
def is_executando(self):
return self._loop_gestao
def parar_servicos(self):
self._loop_gestao = False
def is_download(self):
is_espera = False
if len(self._download_em_espera) > 0 or len(
self._download_em_andamento) > 0 or len(
self._download_finalizados) > 0:
is_espera = True
return is_espera
def is_servidos_exec(self):
resposta = False
for thread in self._thread_gestao:
resposta = thread.is_alive()
return resposta
from configuracao.config import Configuracao
from comunicacao.servidor import SelectorServer
from db.modelos import Persistir
from util.util import Log
Persistir.criar_db()
config = Configuracao()
config_servidor = config.get_servidor()
servidor = SelectorServer(config_servidor.host, config_servidor.porta,
config_servidor.qtd_conexoes)
servidor.serve_forever()
Log.info('iniciando servidor')
def _reinicia_threads_controle(self):
self._loop_controle = False
time.sleep(65)
self._config = Configuracao()
self._iniciar_thread_controle()
Log.info('reiniciando threads')
class Controle:
def __init__(self):
self._fim_conexao = 'fim'
self._cmd_desligar = False
self._mensage = ''
self._data = bytes()
self._config = Configuracao()
self._gestao_ftp = Gestao_ftp()
self.ftp = Ftp()
self._bkp_conversor = Backup_dict()
self._loop_controle = True
self._thread_servico = {}
self._thread_controle = {}
self._threads_finalizados = {}
self._threads_ftps = {}
self._lista_bkp_executando = []
self._verifica_servico = 'Verifica servicos'
self._threads_ativos = 'Threads ativos'
self._reg_serv_finalizados = 'Registra servicos'
self._iniciar_thread_controle()
def set_data(self, data):
self._data = data
self._decode_data(self._data)
def _decode_data(self, data):
if data:
self._mensagem = data.decode('utf-8')
def is_data(self):
is_data = True
if not self._data:
is_data = False
return is_data
def processar_mensagem(self):
data_json = json.loads(self._data)
print('processar_mensagem:data_json: {}'.format(data_json))
comando = data_json['comando']
del data_json['comando']
if comando == 'bkp_list':
self._resposta = self._lista_backups()
elif comando == 'update_lst_bkp':
self._resposta = self._atualizar_config_bkps(data_json)
elif comando == 'list_bkps_prontos':
self._resposta = self._backups_prontos()
elif comando == 'iniciar_ftp':
self._resposta = self._iniciar_ftp(data_json)
elif comando == 'fechar_ftp':
self._resposta = self._fechar_ftp(data_json)
elif comando == 'desligar':
self._resposta = 'desligando'
self._desligar_servidor()
elif comando == 'reiniciar':
self._resposta = 'reiniciando servicos'
self._reinicia_threads_controle()
elif comando == 'teste':
self._resposta = 'ok'
else:
self._resposta = "comando_nao_encontrado"
self._data = None
def _atualizar_config_bkps(self, comando):
Log.info('salvando configuracoes recebidas pelo ncliente')
self._config.salvar_config_bkps(comando)
resposta = {'resposta': 'salvar_bkps_ok'}
return json.dumps(resposta)
def _lista_backups(self):
list_backup = self._config.get_backups()
size_list = len(list_backup)
list_str = []
for i in range(size_list):
list_str.append(list_backup[i].get_dict())
backup_json = json.dumps(list_str)
return backup_json
def _add_backup(self, lista_para_add):
pass
def _backups_prontos(self):
arquivos = Arquivo.get_nao_enviados()
lista_arquivos = []
for arquivo in arquivos:
d = {
'id': arquivo.id,
'arquivo': arquivo.nome,
'path': arquivo.path,
'hash_verificacao': arquivo.hash_verificacao,
'data_criacao': arquivo.data_criacao,
'tamanho': arquivo.tamanho,
'backup': arquivo.backup.nome,
'is_enviado': arquivo.is_enviado
}
lista_arquivos.append(d)
resposta = {'resposta': 'lst_bkps_prontos', 'conteudo': lista_arquivos}
Log.info('criando lista de arquivos preparados para backup')
return json.dumps(resposta)
# def _iniciar_ftp(self, comando):
# print('iniciar_ftp:comando: {}'.format(comando))
# if not self._gestao_ftp.is_rodando_ftp():
# resposta = self._gestao_ftp.adicionar(comando['backup'])
# Log.info('nao foi possivel iniciar ftp: {}, existe um rodando'.format(comando['backup']))
# else:
# resposta = {
# 'resposta':'ftp_rodando',
# 'conteudo':'ftp_ocupado'
# }
# Log.info('iniciando ftp {}.'.format(comando['backup']))
#
# return json.dumps(resposta)
def _iniciar_ftp(self, comando):
self.ftp.iniciar()
resposta = {'resposta': 'ftp_pronto_download'}
Log.info('iniciando ftp {}.'.format(comando['backup']))
return json.dumps(resposta)
# def _fechar_ftp(self, comando):
# is_desligado = self._gestao_ftp.desligar(comando['nome'])
# Log.info('desligando ftp: {}.'.format(comando['nome']))
# str_id = comando['id_arquivo']
# id = int(str_id)
# Arquivo.set_enviado(id)
# Log.info('salvando alteracoes no banco de dados, arquivo id: {}'.format(str_id))
#
# resposta = {'resposta':'ok',
# 'conteudo':'download arquivo executado com sucesso'
# }
#
# return json.dumps(resposta)
def _fechar_ftp(self, comando):
self.ftp.parar()
Log.info('desligando ftp: {}.'.format(comando['nome']))
str_id = comando['id_arquivo']
id = int(str_id)
Arquivo.set_enviado(id)
Log.info(
'salvando alteracoes no banco de dados, arquivo id: {}'.format(
str_id))
resposta = {
'resposta': 'ok',
'conteudo': 'download arquivo executado com sucesso'
}
return json.dumps(resposta)
def _iniciar_thread_controle(self):
self._loop_controle = True
thread_verificacao = threading.Thread(target=self._verifica_servicos,
name=self._verifica_servico)
self._thread_controle[self._verifica_servico] = thread_verificacao
thread_verificacao.start()
Log.info('iniciando thread: {}'.format(self._verifica_servico))
thread_ativos = threading.Thread(target=self._verifica_thread_ativos,
name=self._threads_ativos)
self._thread_controle[self._threads_ativos] = thread_ativos
thread_ativos.start()
Log.info('iniciando thread: {}'.format(self._verifica_thread_ativos))
thread_reg_finalizado = threading.Thread(
target=self._registar_servicos_finalizados,
name=self._reg_serv_finalizados)
self._thread_controle[
self._reg_serv_finalizados] = thread_reg_finalizado
thread_reg_finalizado.start()
Log.info('iniciando thread: {}'.format(self._reg_serv_finalizados))
def _reinicia_threads_controle(self):
self._loop_controle = False
time.sleep(65)
self._config = Configuracao()
self._iniciar_thread_controle()
Log.info('reiniciando threads')
def _desligar_servidor(self):
self._loop_controle = False
time.sleep(65)
self._cmd_desligar = True
Log.info('desligando servidor')
def _verifica_servicos(self):
dict_servicos = self._criar_servicos_diario()
while self._loop_controle:
lista_nome_servicos = list(dict_servicos.keys())
for key in lista_nome_servicos:
servico = dict_servicos[key]
if servico.verifica_integridade_config():
if self._verifica_servico_executado(servico.get_backup()):
del dict_servicos[key]
elif servico.verifica_execucao():
self._add_servico_thread(servico)
del dict_servicos[key]
else:
del dict_servicos[key]
time.sleep(600)
def _verifica_servico_executado(self, backup):
'''
Verrifica se o backup já foi executado no dia corrente
Caso o servidor seja reiniciado nao executar os servicos de backup novamente
'''
resultado = False
data = Conv_data.get_date_now()
hora = Conv_data.str_to_time(backup.hora_execucao)
bkp = Backup_db.is_backup_executado(backup.nome, data, hora)
if bkp != None:
resultado = True
return resultado
def _add_servico_thread(self, serv):
thread = ServicoThread(serv)
self._thread_servico[serv.get_nome()] = thread
thread.set_inicio_thread(time.time())
thread.start()
print('thread iniciado: {}'.format(thread.get_nome()))
def _verifica_thread_ativos(self):
while self._loop_controle:
lista_thread_ativos = list(self._thread_servico.keys())
for key in lista_thread_ativos:
thread = self._thread_servico.get(key)
if not thread.is_alive():
print('backup finalizado: {}'.format(thread.get_nome()))
thread.set_final_thread(time.time())
self._threads_finalizados[thread.get_nome()] = thread
del self._thread_servico[key]
time.sleep(60)
def _registar_servicos_finalizados(self):
while self._loop_controle:
lista_finalizados = list(self._threads_finalizados.keys())
for key in lista_finalizados:
thread = self._threads_finalizados[key]
t_execucao = (thread.get_final_thread() -
thread.get_inicio_thread())
servico = thread.get_servico()
backup = servico.get_backup()
arq = None
if servico.verifica_backup_existe():
print('_registar_servicos_finalizados:if:')
arq = servico.get_info_arquivo_backup()
print('_registar_servicos_finalizados:fim if:')
self._registro = Registro(backup,
servico.get_resultado(),
tempo_execucao=t_execucao,
arquivo=arq)
self._registro.registrar()
Log.info('registando servico finalizado: {}'.format(arq.nome))
del self._threads_finalizados[key]
time.sleep(60)
def _criar_servicos_diario(self):
lista_backup = self._config.get_backups()
self._dict_servicos = {}
for backup in lista_backup:
if backup.periodo == 'diario':
servico_diario = Servico_diario(backup)
self._dict_servicos[backup.nome] = servico_diario
return self._dict_servicos
def get_shutdown(self):
return 'desligando'.encode('utf-8')
def get_running(self):
return self._cmd_desligar
def enviar_resposta(self):
print('self._resposta: {}'.format(self._resposta))
return self._resposta.encode('utf-8')
#!/usr/bin/env python3
from registro.registro import Registro
from configuracao.config import Configuracao
from servidor.server import SelectorServer
from util.util import Log
Registro.criar_banco()
config = Configuracao()
config_server = config.get_server_config()
server = SelectorServer(config_server.host, config_server.porta, config_server.qtd_conexoes)
server.run_server()
Log.info('iniciando aplicacao')
from peewee import *
import datetime
from util.util import Log
from configuracao.config import Configuracao
from util.util import Log
config = Configuracao()
path = config.config_path() + 'db/dbcliente.db'
db = SqliteDatabase(path)
class Persistir:
@staticmethod
def transacoes(nome_servidor, status, descricao):
config = Transacoes()
config.data_envio = datetime.datetime.now()
config.nome_servidor = nome_servidor
config.descricao = descricao
config.status = status
config.save()
Log.info('transacao salva')
@staticmethod
def criar_db():
try:
arquivo = open(path)
arquivo.close()
except FileNotFoundError:
Transacoes.create_table()
Log.info('criando banco de dados')
from configuracao.config import Configuracao
from comunicacao.nbservidor import ConexaoThread
import json
import time
config = Configuracao()
servidor = config.get_servidores()[0]
lista_bkps = {'comando': 'list_bkps_prontos'}
thread1 = ConexaoThread(servidor, lista_bkps)
thread1.start()
iniciar_ftp = {
'comando': 'iniciar_ftp',
'backup': {
'path': '/home/marcelo/backup/backup1',
'arquivo': 'backup_1_terca_0745.zip',
'nome': 'backup_1'
}
}
thread2 = ConexaoThread(servidor, iniciar_ftp)
thread2.start()
loop = True
while loop:
if not thread1.is_alive():
print('if 1')
conteudo = thread1.get_conteudo()
print('conteudo: {}'.format(conteudo))
class ControleApp:
TIPO_ERRO = 'erro'
TIPO_SUCESSO = 'sucesso'
def __init__(self):
self._config = Configuracao()
self._gestao_d = Gestao_download()
self._loop_controle = True
self._thread_conexao_servidores = []
self._thread_controle = {}
self._iniciar_threads()
def _iniciar_threads(self):
self._loop_controle = True
self._verificacao_servidores = 'verificacao_servidores'
verf_conex_serv = Thread(target=self._monitor_conexao_servidores,
name=self._verificacao_servidores)
verf_conex_serv.start()
self._thread_controle[self._verificacao_servidores] = verf_conex_serv
Log.info('Iniciando Thread: {}'.format(self._verificacao_servidores))
self._verifica_bkps_prontos = 'verifica_bkps_prontos'
verifica_bkps_prontos = Thread(target=self._verificar_bkps_prontos,
name=self._verifica_bkps_prontos)
verifica_bkps_prontos.start()
self._thread_controle[
self._verifica_bkps_prontos] = verifica_bkps_prontos
Log.info('Iniciando Thread: {}'.format(self._verifica_bkps_prontos))
self._verifica_download_concluido = 'monitor_bkps_finalizados'
monitor_download_concluido = Thread(
target=self._monitor_download_concluido,
name=self._verifica_download_concluido)
monitor_download_concluido.start()
self._thread_controle[
self._verifica_download_concluido] = monitor_download_concluido
Log.info('Iniciando Thread:{}'.format(
self._verifica_download_concluido))
self._monitor_download_finalizado = 'monitor_download_finalizados'
monitor_download_finalizados = Thread(
target=self._fecha_ftp_servidor,
name=self._monitor_download_finalizado)
monitor_download_finalizados.start()
self._thread_controle[
self._monitor_download_finalizado] = monitor_download_finalizados
Log.info('Iniciando Thread: {}'.format(
self._monitor_download_finalizado))
self._monitor_download_andamento = 'monitor_download_andamento'
monitor_download_andamento = Thread(
target=self._monitor_execucao_download,
name=self._monitor_download_andamento)
monitor_download_andamento.start()
self._thread_controle[
self._monitor_download_andamento] = monitor_download_andamento
Log.info('Iniciando Thread: {}'.format(
self._monitor_download_andamento))
def _reiniciar_threads(self):
Log.info('reiniciando thread')
self._loop_controle = False
time.sleep(60)
self._iniciar_threads()
def set_data(self, data):
self._data = data
self._decode_data(self._data)
def _decode_data(self, data):
if data:
self._mensagem = data.decode('utf-8')
def is_data(self):
is_data = True
if not self._data:
is_data = False
return is_data
def processar_mensagem(self):
data_json = json.loads(self._data.decode('utf-8'))
print('data_json: {}'.format(data_json))
comando = data_json['comando']
del data_json['comando']
if comando == 'lst_bkps_update':
self._atualizar_lst_bkps(data_json)
self._atualizar_servidores(data_json)
else:
print('comando nao encontrado')
def _atualizar_lst_bkps(self, data_json):
if self._config.salvar_servidores(data_json):
self._resposta = self._criar_resposta(TIPO_SUCESSO, 'sucesso')
else:
self._resposta = self._criar_resposta(TIPO_ERRO, 'erro')
def _atualizar_servidores(self, data_json):
keys = data_json.keys()
for key in keys:
str_servidor = data_json[key]
servidor = Servidor(str_servidor)
mensagem = {
'comando': 'update_lst_bkp',
'backups': servidor.backups
}
self._enviar_mensagem_servidor(servidor, mensagem)
def _enviar_mensagem_servidor(self, servidor, mensagem):
print('---enviar_mensagem----')
print('servidor: {}'.format(servidor.nome))
print('mensagem: {}'.format(mensagem))
thread = ConexaoThread(servidor, mensagem)
thread.start()
self._thread_conexao_servidores.append(thread)
Log.info('enviando mensagem')
def _verificar_bkps_prontos(self):
lista_servidores = self._config.get_servidores()
while self._loop_controle:
for servidor in lista_servidores:
tratamento = Tratamento_Servidor(servidor)
if tratamento.is_execucao(
) and not self._gestao_d.is_download():
mensagem = {'comando': 'list_bkps_prontos'}
self._enviar_mensagem_servidor(servidor, mensagem)
Log.info('verificação de backups prontos')
time.sleep(300)
def _monitor_conexao_servidores(self):
while self._loop_controle:
range_lista = len(self._thread_conexao_servidores)
for thread in self._thread_conexao_servidores:
if thread.is_comunicacao():
self._tratamento_resposta(thread.get_resposta(),
thread.get_conteudo(),
thread.get_servidor())
self._thread_conexao_servidores.remove(thread)
time.sleep(5)
def _tratamento_resposta(self, resposta, conteudo, servidor):
print('---_tratamento_resposta---')
print('conteudo: {}'.format(conteudo))
print('servidor: {}'.format(servidor.nome))
if resposta == 'ok' and resposta == 'ftp_rodando':
Persistir.transacoes(servidor.nome, resposta, conteudo)
elif resposta == 'lst_bkps_prontos':
self._adicionar_download_fila(servidor, conteudo)
elif resposta == 'salvar_bkps_ok':
Persistir.transacoes(servidor.nome, resposta)
elif resposta == 'ftp_pronto_download':
print('ftp_pronto_download')
Log.info('ftp pronto para download, servidor {}'.format(
servidor.nome))
self._gestao_d.executa_download()
def _fecha_ftp_servidor(self):
lista_finalizados = self._gestao_d.get_msg_finalizados()
for mensagem in lista_finalizados:
servidor = mensagem['servidor']
Log.info('fechando ftp, servidor {}'.format(servidor))
del mensagem['servidor']
self._enviar_mensagem_servidor(servidor, mensagem)
self._gestao_d.remove_finalizado(mensagem['nome'])
def _monitor_execucao_download(self):
while self._loop_controle:
if self._gestao_d.get_downloads_executando() == 0:
comando = self._gestao_d.get_msg_em_espera()
if comando != None:
servidor = comando['servidor']
mensagem = comando['mensagem']
self._enviar_mensagem_servidor(servidor, mensagem)
time.sleep(90)
def _adicionar_download_fila(self, servidor, conteudo):
self._gestao_d.adicionar(servidor, conteudo)
def _monitor_download_concluido(self):
while self._loop_controle:
for mensagem in self._gestao_d.get_msg_finalizados():
self._enviar_mensagem_servidor(mensagem['servidor'],
mensagem['comando'])
self._gestao_d.remove_finalizado(mensagem['comando']['nome'])
time.sleep(5)
def _byte_to_json(self):
return json.loads(self._data.decode('utf-8'))
def _criar_resposta(self, tipo, mensagem):
dict = {tipo: mensagem}
return json.dumps(dict)
def enviar_resposta(self):
return self._resposta.encode('utf-8')
