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 criar_db():
try:
arquivo = open(path)
arquivo.close()
except FileNotFoundError:
Transacoes.create_table()
Log.info('criando banco de dados')
def close_connection(self, conn):
peername = self.current_peers[conn.fileno()]
Log.info('conexao fechada: {}'.format(peername))
del self.current_peers[conn.fileno()]
self.selector.unregister(conn)
conn.close()
def registrar(self):
mbackup = Backup()
mbackup.nome = self._backup.nome
mbackup.tipo = self._backup.tipo
mbackup.data_execucao = Conv_data.get_date_now()
mbackup.periodo = self._backup.periodo
if self._tempo_execucao != None:
mbackup.tempo_execucao = self._tempo_execucao
mbackup.dia_semana = self._backup.dia_semana
split_hora = self._backup.hora_execucao.split(':')
int_hora = int(split_hora[0])
int_minutos = int(split_hora[1])
_hora_execucao = datetime.time(hour=int_hora, minute=int_minutos)
mbackup.hora_execucao = _hora_execucao
mbackup.sc_pre_execucao = self._resultado_execucao['executa_sc_pre']
mbackup.sc_pos_execucao = self._resultado_execucao['executa_sc_pos']
mbackup.backup_auto = self._backup.backup_auto
if self._backup.backup_auto == 'Sim':
mbackup.sc_backup = self._resultado_execucao['executa_backup_auto']
else:
mbackup.sc_backup = self._resultado_execucao['executa_sc_nativo']
mbackup.save()
if self._arquivo != None:
m_arquivo = Arquivo()
m_arquivo.nome = self._arquivo.nome
m_arquivo.path = self._arquivo.path
m_arquivo.hash_verificacao = self._arquivo.hash_verificacao
m_arquivo.data_criacao = self._arquivo.data_criacao
m_arquivo.tamanho = self._arquivo.tamanho
m_arquivo.backup = mbackup
m_arquivo.save()
Log.info('registrando no banco de dados')
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 _set_servidor(self):
path = self.config_path() + 'json_modelos/config_servidor.json'
with open(path) as servidor:
_json = json.load(servidor)
s = _json['servidor_local']
self._servidor = Servidor_local(s)
Log.info('leitura do arquivo: config_servidores.json')
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')
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 _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 _set_backup(self):
with open(self._path + 'configuracao/backup_list.json') as backup_json:
data = json.load(backup_json)
b = data['backups']
self._backup_list = []
for i in b:
backup = Backup(i)
self._backup_list.append(backup)
Log.info('[configuracao] leitura do arquivo backup_list.json')
def _set_usuario(self):
with open(self._path + 'configuracao/login.json') as login_json:
_json = json.load(login_json)
self._usuarios = []
for u in _json['login']:
usuario = Usuario(u)
self._usuarios.append(usuario)
Log.info('[configuracao] leitura do arquivo login.json')
def iniciar_servidor(self):
authorizer = DummyAuthorizer()
authorizer.add_user(self._config.usuario, self._config.senha, self._dir, perm=self._config.permissao)
handler = FTPHandler
handler.authorizer = authorizer
try:
self._server = FTPServer((self._config.host, self._config.porta), handler)
self._server.serve_forever(timeout=5)
except OSError:
Log.error('Erro ao iniciar FTP')
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')
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 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 _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 _set_servidores(self):
path = self.config_path() + 'json_modelos/servidores.json'
self._lista_servidores = []
if os.path.exists(path):
arquivo = open(path)
servidores = json.load(arquivo)
keys = servidores.keys()
for k in keys:
dict_server = servidores[k]
serv = Servidor(dict_server)
self._lista_servidores.append(serv)
else:
self._lista_servidores = None
Log.info('leitura do arquivo: servidores.json')
def serve_forever(self):
last_report_time = time.time()
Log.info('Iniciando servidor')
while self._server_on_running:
events = self.selector.select(timeout=0.2)
for key, mask in events:
handler = key.data
handler(key.fileobj, mask)
cur_time = time.time()
if cur_time - last_report_time > 1:
last_report_time = cur_time
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(self):
resultado = False
try:
time.sleep(5)
self._ftp = ftplib.FTP('')
self._ftp.connect(self._config_servidor.host,
self._config_servidor.porta)
self._ftp.login(user=self._config_servidor.usuario,
passwd=self._config_servidor.senha)
destino = self._path_destino + '/' + self._arquivo['arquivo']
self._ftp.retrbinary("RETR " + self._arquivo['arquivo'],
open(destino, 'wb').write)
resultado = True
except ftplib.all_errors as msg:
Log.info('[download_ftp] erro ftp: {}'.format(msg))
resultado = False
def on_read(self, conn, mask):
try:
data = conn.recv(1024)
self._controle.set_data(data)
if self._controle.is_data():
self._controle.processar_mensagem()
conn.send(self._controle.enviar_resposta())
if self._controle.get_running():
Log.info('desligando servidor')
self._set_is_running(False)
else:
self.close_connection(conn)
except ConnectionResetError:
self.close_connection(conn)
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 _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 salvar_servidores(self, servidores):
resposta = False
path = config_path() + 'json_modelos/servidores.json'
try:
arquivo = open(path, 'w')
arquivo.write(servidores)
arquivo.close()
resposta = True
Log.info('escrita no arquivo servidores.json')
except FileNotFoundError:
Log.error(
'erro ao escrever no arquivo servidores.json, FileNotFoundError'
)
resposta = False
return resposta
def executa_thread_download(self):
print("executa_thread_download")
print('len download_em_espera: {}'.format(len(
self._download_em_espera)))
print('len download_em_andamento: {}'.format(
len(self._download_em_andamento)))
loop = (len(self._download_em_espera) > 0)
while loop:
time.sleep(30)
if len(self._download_em_andamento) == 0:
thread = self._download_em_espera.pop()
self._download_em_andamento.append(thread)
thread.start()
Log.info('iniciando thread {}'.format(thread.name))
loop = (len(self._download_em_espera) > 0)
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 _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 _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 desligar_servidor(self):
self._servidor_ftp.desligar_servidor()
self._is_desligado = True
Log.info('desligando thread ftp: {}'.format(self._nome))