def verifica_se_existe_analise_em_progresso_ou_pendente(self):
url_consulta = self.URL_SONAR_ATIVIDADE_STATUS + self.nome_projeto_sonar
response = requests.get(url_consulta)
data = json.loads(response.text)
try:
status_analise = data['current']['status']
Log.imprime("VALOR DO STATUS DA ANALISE: " + status_analise)
contador = 0
while ((status_analise == "IN_PROGRESS") or
(status_analise == "PENDING")) and contador < 5:
Log.imprime("VALOR DO STATUS DA ANALISE: " + status_analise +
". VALOR DO CONTADOR: " + str(contador))
contador = contador + 1
sleep(90)
response = requests.get(url_consulta)
data = json.loads(response.text)
status_analise = data['current']['status']
except:
Log.imprime("NAO FOI POSSIVEL VERIFICAR O STATUS DA ANALISE.")
return False
if (status_analise == "IN_PROGRESS") or (status_analise == "PENDING"):
Log.imprime(
"O STATUS DA ANALISE CONTINUA COMO NAO TERMINADA APESAR DO TEMPO DE ESPERA"
)
return False
else:
Log.imprime("O STATUS DA ANALISE INDICA QUE FOI ENCERRADA")
return True
def remover_snapshot(self):
nome_snapshot = self.NOME_BANCO + "_SNAPSHOT"
with open("comandoRemoverSnapshot.sql", "w") as arq:
arq.write("DROP DATABASE " + nome_snapshot + ";")
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA + " -U " + self.USUARIO_BANCO +
" -P " + self.SENHA_BANCO +
" -i comandoRemoverSnapshot.sql -o log_comandoRemoverSnapshot.txt")
try:
pymssql.connect(host=self.SERVIDOR_PORTA,
user=self.USUARIO_BANCO,
password=self.SENHA_BANCO,
database=nome_snapshot)
with open("log_comandoRemoverSnapshot.txt", "r") as arq:
Log.imprime("FALHA - NA REMOCAO DO SNAPSHOT\n" + arq.read(),
"FALHA - NA REMOCAO DO SNAPSHOT",
classe=BancoDados)
exit(1)
except:
mensagem_sucesso = "SUCESSO -- REMOVIDO -- " + nome_snapshot
Log.imprime(mensagem_sucesso, mensagem_sucesso, classe=BancoDados)
email = Email()
email.enviar_email(mensagem_sucesso, DESTINATARIOS_EMAIL,
mensagem_sucesso)
def fechar_artefato(self):
comando = self.__caminho_msbuild + " build.xml"
Log.imprime("INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO",
"INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO.")
LinhaDeComando.executar(comando)
Log.imprime("ARTEFATO GERADO COM SUCESSO.",
"ARTEFATO GERADO COM SUCESSO.")
def habiltar_usuario_aplicacao_acesso_banco_dados(self):
with open("comandoHabiltarUsuarioAplicacaoAcessoBancoDados.sql",
"w") as arq:
arq.write("alter login " + self.USUARIO_APLICAO_ACESSO_BANCO[0] +
" enable;")
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA + " -U " + self.USUARIO_BANCO +
" -P " + self.SENHA_BANCO +
" -i comandoHabiltarUsuarioAplicacaoAcessoBancoDados.sql "
"-o log_comandoHabiltarUsuarioAplicacaoAcessoBancoDados.txt")
tamanho_arquivo_log = stat(
"log_comandoHabiltarUsuarioAplicacaoAcessoBancoDados.txt").st_size
if tamanho_arquivo_log == 0:
Log.imprime(
"SUCESSO - AO HABILITAR USUARIO DA APLICACAO COM ACESSO COM O BANCO DE DADOS",
"SUCESSO - AO HABILITAR USUARIO DA APLICACAO COM ACESSO COM O BANCO DE DADOS"
)
else:
with open(
"log_comandoHabiltarUsuarioAplicacaoAcessoBancoDados.txt",
"r") as arq:
Log.imprime(
"FALHA - AO HABILITAR USUARIO DA APLICACAO COM ACESSO COM O BANCO DE DADOS\n"
+ arq.read(),
"FALHA - AO HABILITAR USUARIO DA APLICACAO COM ACESSO COM O BANCO DE DADOS",
classe=BancoDados)
exit(1)
def fechar_artefato(self):
# Metodo que fecha um novo artefato construido com o Gradle
Log.imprime("INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO",
"INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO")
LinhaDeComando.executar("gradle build")
Log.imprime("ARTEFATO GERADO COM SUCESSO",
"ARTEFATO GERADO COM SUCESSO")
def executar_com_output(comando):
retorno = subprocess.Popen(comando, stdout=subprocess.PIPE, shell=True, stderr=subprocess.STDOUT)
Log.imprime("EXECUTANDO COMANDO: " + comando)
output_tupla = retorno.communicate()
output_string = output_tupla[0].decode()
Log.imprime("RETORNO DO COMANDO: " + output_string)
return output_string
def implantar_artefato(self):
# Metodo para implantacao do artefato no ambiente
zp = ZIP()
zp.descompactar(path.join(WORKING_DIRECTORY, NOME_PROJETO + ".zip"),
self.diretorio_descompactacao)
# Descompacta o zip no local desejado
Log.imprime("CAMINHO DE COMPARTILHAMENTO DA IMPLANTACAO: " +
str(self.caminho_compartilhamento))
Log.imprime("NOME DO ARQUIVO DE CONFIGURACAO DO AMBIENTE: " +
str(self.nome_arquivo_configuracao_ambiente))
Log.imprime("HOST FTP: " + str(self.host_ftp))
Log.imprime("SERVIDOR SSH: " + str(self.servidor_ssh))
# Checa se existe um arquivo de configuracao para o ambiente em questao com o metodo responsavel
if self.nome_arquivo_configuracao_ambiente:
self.__verificar_existencia_arquivo_ambiente()
# Reconhece o meio pelo qual o zip deve ser implantado e chama o metodo responsavel
if self.caminho_compartilhamento is not None:
self.__implantar_caminho_compartilhamento()
elif self.host_ftp is not None:
self.__implantar_via_ftp()
elif self.servidor_ssh is not None:
self.__implantar_via_ssh()
else:
Log.imprime("MEIO DE IMPLANTACAO NAO FOI INFORMADO.",
"ERRO DURANTE A IMPLANTACAO DO ZIP.",
classe=ImplantadorZIP)
exit(1)
def get_repository(self):
repository = self.diretorio_grails_plugin.obter_valor_chave(
self.__REPOSITORY)
split = repository.split("repositories/")
repository = split[1].split("/")
Log.imprime("REPOSITORY: " + str(repository[0]))
return str(repository[0])
def tearDown(self):
arquivos_css = {"arquivo.css", "arquivo2.css", "arquivo3.css"}
for css in arquivos_css:
Log.imprime("EXCLUINDO O ARQUIVO CSS DE TESTE " + css,
"EXCLUINDO O ARQUIVO CSS DE TESTE " + css)
arq = Arquivo(css)
arq.excluir()
def fechar_artefato(self):
arquivos_js = LinhaDeComando.executar_com_output(
'find . -name "*.js"').split(".js\n")
arquivos_js.pop()
for js in arquivos_js:
comando_js = "java -jar %s --js %s.js --js_output_file %s_min.js" % (
self.__CAMINHO_CLOSURE_COMPILER, js, js)
Log.imprime(
"INICIANDO O PROCESSO DE MINIFICACAO DO ARQUIVO " + js + ".js",
"INICIANDO O PROCESSO DE MINIFICACAO DO ARQUIVO " + js +
".js.")
Log.imprime("EXECUTANDO O COMANDO: " + comando_js)
LinhaDeComando.executar(comando_js)
Log.imprime("COMANDO EXECUTADO COM SUCESSO.",
"ARQUIVO " + js + ".js MINIFICADO COM SUCESSO.")
arquivo_antigo = Arquivo(js + ".js")
Log.imprime("EXCLUINDO O ARQUIVO ORIGINAL",
"EXCLUINDO O ARQUIVO ORIGINAL.")
arquivo_antigo.excluir()
arquivo_novo = Arquivo(js + "_min.js")
Log.imprime("RENOMEANDO O ARQUIVO MINIFICADO",
"RENOMEADO O ARQUIVO MINIFICADO")
arquivo_novo.renomear(js + ".js")
def baixar_arquivo(self, nome_arquivo_download, caminho_diretorio_download, diretorio_ftp):
arquivo = open(path.join(caminho_diretorio_download, nome_arquivo_download), "wb")
Log.imprime("BAIXANDO ARQUIVO " + str(nome_arquivo_download) + " DE " + str(diretorio_ftp),
" BAIXANDO ARQUIVO." + str(nome_arquivo_download))
self.ftp.retrbinary("RETR " + path.join("/", diretorio_ftp, nome_arquivo_download), arquivo.write)
arquivo.close()
def buscar_json(colecao, string_busca_json):
if not isinstance(colecao, Collection):
Log.imprime(
"VARIAVEL colecao NAO E DO TIPO COLLECTION.\nVALOR OBTIDO: " +
str(type(colecao)),
"ERRO DE OPERACAO NO MONGODB.",
classe=Operacoes)
exit(1)
if not string_busca_json:
Log.imprime("VARIAVEL DA STRING DE BUSCA VAZIA.",
"ERRO DE OPERACAO NO MONGODB.",
classe=Operacoes)
exit(2)
if string_busca_json == "{}":
Log.imprime("BUSCA VAZIA.",
"ERRO DE OPERACAO NO MONGODB.",
classe=Operacoes)
exit(3)
try:
documento_busca_json = json.loads(string_busca_json)
documentos_encontrados = colecao.find(documento_busca_json)
return documentos_encontrados
except ValueError:
Log.imprime(
"STRING DE BUSCA NAO ESTA NO FORMATO JSON.\nVALOR OBTIDO: " +
str(string_busca_json) + "\n" + format_exc(),
"ERRO DE OPERACAO NO MONGODB.",
classe=Operacoes)
exit(4)
except TypeError:
Log.imprime("OCORREU UM ERRO DURANTE A BUSCA\n" + format_exc(),
"ERRO DE OPERACAO NO MONGODB.",
classe=Operacoes)
exit(5)
def fechar_artefato(self):
arquivos_css = LinhaDeComando.executar_com_output(
'find . -name "*.css"').split(".css\n")
arquivos_css.pop()
for css in arquivos_css:
comando_css = "csso %s.css --output %s_min.css" % (css, css)
Log.imprime(
"INICIANDO O PROCESSO DE MINIFICACAO DO ARQUIVO " + css +
".css", "INICIANDO O PROCESSO DE MINIFICACAO DO ARQUIVO " +
css + ".css.")
Log.imprime("EXECUTANDO O COMANDO: " + comando_css)
LinhaDeComando.executar(comando_css)
Log.imprime("COMANDO EXECUTADO COM SUCESSO.",
"ARQUIVO " + css + ".css MINIFICADO COM SUCESSO.")
arquivo_antigo = Arquivo(css + ".css")
Log.imprime("EXCLUINDO O ARQUIVO ORIGINAL",
"EXCLUINDO O ARQUIVO ORIGINAL.")
arquivo_antigo.excluir()
arquivo_novo = Arquivo(css + "_min.css")
Log.imprime("RENOMEANDO O ARQUIVO MINIFICADO",
"RENOMEADO O ARQUIVO MINIFICADO")
arquivo_novo.renomear(css + ".css")
def criar_backup(self, prd=False):
if prd:
conteudo_arquivo = "BACKUP DATABASE " + self.NOME_BANCO + " TO DISK = '" + self.CAMINHO_ARQUIVO_BACKUP + \
self.NOME_BANCO + "-devops.bak' with format, compression ;"
comando = "sqlcmd -S " + self.SERVIDOR_PORTA + " -U " + self.USUARIO_BANCO + \
" -P " + self.SENHA_BANCO + " -i comandoCriarBackup.sql -o log_comandoCriarBackup.txt"
else:
conteudo_arquivo = "BACKUP DATABASE " + self.NOME_BANCO_STG + " TO DISK = '" + self.CAMINHO_ARQUIVO_BACKUP \
+ self.NOME_BANCO_STG + "-devops.bak' with format, compression ;"
comando = "sqlcmd -S " + self.SERVIDOR_PORTA_STG + " -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i " \
"comandoCriarBackup.sql -o log_comandoCriarBackup.txt"
with open("comandoCriarBackup.sql", "w") as arq:
arq.write(conteudo_arquivo)
LinhaDeComando.executar(comando)
with open("log_comandoCriarBackup.txt", "r") as arq:
if "successfully" in arq.read():
Log.imprime("SUCESSO - CRIACAO DO BACKUP",
"SUCESSO - CRIACAO DO BACKUP")
else:
Log.imprime("FALHA - CRIACAO DO BACKUP.\n" + arq.read(),
"FALHA - CRIACAO DO BACKUP",
classe=BancoDados)
exit(1)
def criar_snapshot(self):
self.__matar_todas_conexoes_no_banco_dados()
caminho_snapshot = getenv(
"CAMINHO_GRAVAR_SNAPSHOT") + self.NOME_BANCO + "_snapshot.ss"
comando = "CREATE DATABASE " + self.NOME_BANCO + "_SNAPSHOT ON ( NAME = '" + self.NOME_BANCO + \
"_DATA', FILENAME ='" + caminho_snapshot + "') AS SNAPSHOT OF " + \
self.NOME_BANCO + " ;"
with open("comandoCriarSnapshot.sql", "w") as arq:
arq.write(comando)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA + " -U " + self.USUARIO_BANCO +
" -P " + self.SENHA_BANCO +
" -i comandoCriarSnapshot.sql -o log_comandoCriarSnapshot.txt")
if not self.__snapshot_foi_criado_com_sucesso():
self.habiltar_usuario_aplicacao_acesso_banco_dados()
Log.imprime(
"FALHA - JA EXISTE UM SNAPSHOT CRIADO PARA ESSE BANCO\n",
"FALHA - JA EXISTE UM SNAPSHOT CRIADO PARA ESSE BANCO\n"
"PRIMEIRO DEVE SER EXECUTADO O PASSO DE VALIDACAO DEPLOY",
classe=BancoDados)
exit(1)
def tearDown(self):
arquivos_js = {"arquivo.js", "arquivo2.js", "arquivo3.js"}
for js in arquivos_js:
Log.imprime("EXCLUINDO O ARQUIVO JS DE TESTE " + js,
"EXCLUINDO O ARQUIVO JS DE TESTE " + js)
arq = Arquivo(js)
arq.excluir()
def teste_gerar_arquivo_log_logstash(self):
valor_esperado = "2016-01-01T00:00:00-03:00 [Cadin]:BANCO_DADOS-Deploy_Producao"
Log.gerar_arquivo_log_logstash()
self.assertTrue(path.isfile(self.arquivo_log_logstash))
with open(self.arquivo_log_logstash, "r") as arq_log:
valor_obtido = arq_log.read().splitlines()[-1]
self.assertEqual(valor_obtido, valor_esperado)
def limpar_pasta_compartilhada(self):
# Metodo responsavel por limpar o caminho de compartilhamento
Log.imprime("INICIANDO LIMPEZA DO CAMINHO DE COMPARTILHAMENTO " +
self.caminho_compartilhamento)
# Copia um arquivo .bat para o caminho de compartilhamento
LinhaDeComando.executar("copy " + path.dirname(__file__) +
"\\..\\..\\batch\\apagarConteudo.bat" + " " +
self.caminho_compartilhamento)
# Usa o comando net use para executar o .bat no caminho de compartilhamento
LinhaDeComando.executar("net use i: " + self.caminho_compartilhamento)
LinhaDeComando.executar("i: && call apagarConteudo.bat " +
self.pastas_nao_apagar + " && c:")
LinhaDeComando.executar("net use i: /delete /yes")
# Apaga o proprio arquivo .bat para nao deixar resquicios do processo de limpeza no servidor
LinhaDeComando.executar(
"del " +
path.join(self.caminho_compartilhamento, "apagarConteudo.bat"))
Log.imprime(
"LIMPEZA DO CAMINHO DE COMPARTILHAMENTO REALIZADA COM SUCESSO")
def setUp(self):
arquivos_css = {"arquivo.css", "arquivo2.css", "arquivo3.css"}
for css in arquivos_css:
Log.imprime("CRIANDO ARQUIVO CSS DE TESTE " + css,
"CRIANDO ARQUIVO CSS DE TESTE " + css)
with open(css, "w") as arq:
arq.write("body{background-color: red;}")
arq.close()
def get_repository(self):
# Metodo responsavel por pegar o repositorio
repository = self.pom_xml.obter_valor_xpath(
self.__XPATH_TAG_REPOSITORY, self._LISTA_XPATH_TAGS_FILHAS)
split = repository.split("repositories/")
repository = split[1].split("/")
Log.imprime("REPOSITORY: " + str(repository))
return str(repository[0])
def fechar_artefato(self):
# Metodo responsavel por fechar um novo artefato
comando_build = "mvn clean package"
Log.imprime("INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO",
"INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO.")
LinhaDeComando.executar(comando_build)
Log.imprime("ARTEFATO GERADO COM SUCESSO.",
"ARTEFATO GERADO COM SUCESSO.")
def executar(command, retornar_exit_code=None):
retorno = subprocess.call(command, shell=True, stderr=subprocess.STDOUT)
Log.imprime("EXECUTANDO COMANDO: " + command)
if not retornar_exit_code:
if not (retorno == 0):
Log.imprime("ERRO NA EXECUCAO DO COMANDO.\nRETORNO: " + str(retorno),
"ERRO NA EXECUCAO DO COMANDO", classe=LinhaDeComando)
exit(retorno)
return retorno
def executa_scanner_sonar(self):
comando = "mvn clean org.jacoco:jacoco-maven-plugin:prepare-agent install -Pcoverage-per-test"
Log.imprime("GERANDO RELATORIO DE COBERTURA",
"GERANDO RELATORIO DE COBERTURA")
LinhaDeComando.executar(comando)
comando = "mvn sonar:sonar"
LinhaDeComando.executar(comando)
Log.imprime("SUCESSO NA EXECUCAO DO SONAR",
"SUCESSO NA EXECUCAO DO SONAR")
def setUp(self):
environ[
"CAMINHO_CLOSURE_COMPILER"] = "/opt/closure-compiler/latest/closure-compiler.jar"
arquivos_js = {"arquivo.js", "arquivo2.js", "arquivo3.js"}
for js in arquivos_js:
Log.imprime("CRIANDO ARQUIVO JS DE TESTE " + js,
"CRIANDO ARQUIVO JS DE TESTE " + js)
with open(js, "w") as arq:
arq.write(
"function hello(longName){alert('Hello, ' + longName);}hello('New User');"
)
arq.close()
def fechar_conexao(self):
if not self.__conexao:
Log.imprime(
"CONEXAO PARECE NAO TER SIDO INICIADA DA MANEIRA CORRETA.\nVALOR RECEBIDO: "
+ str(self.__conexao),
"ERRO NA CONEXAO COM O MONGO.",
classe=Conexao)
return False
else:
self.__conexao.close()
Log.imprime("CONEXAO ENCERRADA COM SUCESSO")
return True
def __busca_projeto(self):
string_busca = '{"projeto":"' + self.nome_projeto + '"}'
documentos_encontrados = Operacoes.buscar_json(self.colecao, string_busca)
if documentos_encontrados.count() == 0:
Log.imprime("A BUSCA NAO RETORNOU NENHUM DOCUMENTO REFERENTE AO PROJETO.\nNOME DE PROJETO INFORMADO: " +
self.nome_projeto + "INSERINDO PROJETO NO MONGO", classe=InformacoesArtefatos)
Operacoes.inserir_json(self.colecao, string_busca)
self.__conexao.fechar_conexao()
return documentos_encontrados[0]
def descompactar(arquivo_zip, destino_arquivos):
Log.imprime(
"DESCOMPACTANDO ARQUIVO " + arquivo_zip + " PARA " +
destino_arquivos, "DESCOMPACTANDO ARQUIVO " + arquivo_zip)
try:
with ZipFile(arquivo_zip, "r") as zp:
zp.extractall(destino_arquivos)
except:
Log.imprime("ERRO NA DESCOMPACTACAO DO ARQUIVO " + arquivo_zip +
format_exc(),
"ERRO NA DESCOMPACTACAO DO ARQUIVO",
classe=ZIP)
def compactar_diretorio(zp, pasta):
relroot = path.abspath(pasta)
Log.imprime("COMPACTANDO DIRETORIO " + relroot,
"COMPACTANDO DIRETORIO " + relroot)
for root, dirs, files in walk(pasta):
# add directory (needed for empty dirs)
zp.write(root, path.relpath(root, relroot))
for file in files:
filename = path.join(root, file)
if path.isfile(filename): # regular files only
arcname = path.join(path.relpath(root, relroot), file)
zp.write(filename, arcname)
def alterar(self, revision_deploy_stg=None, revision_deploy_prd=None, data_deploy_stg=None, data_deploy_prd=None,
cobertura_testes_unitarios=None, dependencias=list(), load_balance_backend=None,
quantidade_issues_total=None, numero_mudanca=None,
quantidade_testes_unitarios=None, quantidade_smoke_tests=None, quantidade_testes_regressivos=None,
status_deploy_prd=None):
string_busca = '{"projeto":"' + self.nome_projeto + '"}'
# Montagem da string de alteracao
string_alteracao = '{'
if revision_deploy_stg:
string_alteracao += '"revision_deploy_stg":"' + revision_deploy_stg + '",'
if revision_deploy_prd:
string_alteracao += '"revision_deploy_prd":"' + revision_deploy_prd + '",'
if data_deploy_stg:
string_alteracao += '"data_deploy_stg":"' + data_deploy_stg + '",'
if data_deploy_prd:
string_alteracao += '"data_deploy_prd":"' + data_deploy_prd + '",'
if status_deploy_prd:
string_alteracao += '"status_deploy_prd":"' + status_deploy_prd + '",'
if cobertura_testes_unitarios:
string_alteracao += '"cobertura_testes_unitarios":"' + str(cobertura_testes_unitarios) + '",'
if dependencias:
string_alteracao += '"quantidade_issues_findbugs":['
for dependencia in dependencias:
dados_dependencia = dependencia.split(":")
dependencia_nome = dados_dependencia[0]
quantidade_issues_dependencia = dados_dependencia[1]
string_alteracao += '{"dependencia":"' + dependencia_nome + '",'
string_alteracao += '"quantidade_issues":"' + str(quantidade_issues_dependencia) + '"},'
string_alteracao += '],'
if quantidade_issues_total:
string_alteracao += '"quantidade_issues_total_aplicacao":"' + str(quantidade_issues_total) + '",'
if numero_mudanca:
string_alteracao += '"numero_mudanca":"' + numero_mudanca + '",'
if quantidade_testes_unitarios:
string_alteracao += '"quantidade_testes_unitarios":"' + str(quantidade_testes_unitarios) + '",'
if load_balance_backend:
string_alteracao += '"load_balance_backend":"' + load_balance_backend + '",'
if quantidade_smoke_tests:
string_alteracao += '"quantidade_smoke_tests":"' + str(quantidade_smoke_tests) + '",'
if quantidade_testes_regressivos:
string_alteracao += '"quantidade_testes_regressivos":"' + str(quantidade_testes_regressivos) + '",'
string_alteracao += '}'
string_alteracao = string_alteracao.replace(',}', '}').replace(',]', ']')
if string_alteracao == '{}':
Log.imprime("NENHUMA ALTERACAO FOI FEITA.", classe=InformacoesArtefatos)
else:
self.__conexao = Conexao(USUARIO_GO_API, SENHA_GO_API, "qa_informacoes_entrega_continua", self.equipe)
Operacoes.alterar_json(self.colecao, string_busca, string_alteracao)
self.__conexao.fechar_conexao()
def __init__(self, servidor_ftp, usuario_ftp, senha_ftp, seguranca):
self.servidor_ftp = servidor_ftp
self.usuario_ftp = usuario_ftp
self.senha_ftp = senha_ftp
self.seguranca = seguranca
if not seguranca:
self.ftp = ftplib.FTP(self.servidor_ftp, self.usuario_ftp, self.senha_ftp)
Log.imprime("INICIANDO CONEXAO SEM SSL.")
else:
self.ftp = ftplib.FTP_TLS(self.servidor_ftp, self.usuario_ftp, self.senha_ftp)
self.ftp.prot_p()
Log.imprime("INICIANDO CONEXAO COM SSL.")
self.diretorio_raiz = self.ftp.pwd()
