def fechar_artefato(self):
ssh = SSH(self.SERVIDOR, self.USUARIO)
ssh.senha(self.SENHA)
comando_ssh = ""
ssh.abrir_conexao()
ssh.executar_comando(comando_ssh)
ssh.fechar_conexao()
def implantar_artefato(self):
Log.imprime(
"IMPLANTANDO " + self.arquivo_envio + " NO DIRETORIO " +
self.diretorio_ssh + " NO SERVIDOR " + self.servidor_ssh,
"INICIANDO DEPLOY VIA SSH")
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " +
self.usuario_ssh + " NO SERVIDOR " + self.servidor_ssh)
ssh = SSH(self.servidor_ssh, self.usuario_ssh)
if self.senha_ssh:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.senha_ssh)
elif self.arquivo_chave_ssh:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.arquivo_chave_ssh
ssh.chave_acesso(chave)
Log.imprime("ABRINDO CONEXAO")
ssh.abrir_conexao()
Log.imprime("ENVIANDO ARQUIVO " +
path.join(WORKING_DIRECTORY, self.arquivo_envio) +
" PARA " + self.diretorio_ssh)
ssh.enviar_arquivo(path.join(WORKING_DIRECTORY, self.arquivo_envio),
self.diretorio_ssh)
Log.imprime("DEPLOY ENCERRADO", "DEPLOY ENCERRADO COM SUCESSO")
__USUARIO_SSH = getenv("UsuarioSSH")
__SENHA_SSH = getenv("SenhaSSH")
__ARQUIVO_CHAVE_SSH = getenv("ArquivoChaveSSH")
__SERVIDOR_SSH = getenv("ServidorSSH")
if not __ARQUIVO_CHAVE_SSH and not __SENHA_SSH:
Log.imprime("Arquivo chave para SSH ou a senha para SSH nao foi informado",
"ERRO NA VALIDACAO DO NAGIOS",
script="nagios_validar_configuracao.py",
mensagem_de_erro=True)
exit(1)
if not __USUARIO_SSH:
__USUARIO_SSH = "tfsservice"
ssh = SSH(__SERVIDOR_SSH, __USUARIO_SSH)
if __SENHA_SSH:
ssh.senha(__SENHA_SSH)
elif __ARQUIVO_CHAVE_SSH:
chave = DIRETORIO_CHAVES_SERVIDORES + __ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.executar_comando("sleep 30")
ssh.executar_comando(
"/usr/local/nagios/libexec/webinject.pl -c conf/classif567_cfg.xml")
ssh.executar_comando(
"/usr/local/nagios/libexec/webinject.pl -c conf/classif568_cfg.xml")
ssh.fechar_conexao()
def __implantar_via_ssh(self):
# Metodo responsavel pela implantacao do zip via conexao SSH
arquivo_zip = NOME_PROJETO + ".zip"
Log.imprime(
"IMPLANTANDO " + arquivo_zip + " NO SERVIDOR " +
self.servidor_ssh + " NO DIRETORIO " + self.diretorio_ssh +
" VIA SSH", "INICIANDO DEPLOY DO ZIP")
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " +
self.usuario_ssh + " NO SERVIDOR " + self.servidor_ssh)
# Prepara para abrir conexao SSH com o servidor
ssh = SSH(self.servidor_ssh, self.usuario_ssh)
# Verifica se a autenticacao sera feita via senha ou via arquivo de chaves
if self.senha_ssh:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.senha_ssh)
elif self.arquivo_chave_ssh:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.arquivo_chave_ssh
ssh.chave_acesso(chave)
# Abre a conexao
ssh.abrir_conexao()
# Envia o arquivo zip para o servidor no diretorio desejado
ssh.enviar_arquivo(path.join(WORKING_DIRECTORY, arquivo_zip),
self.diretorio_ssh)
# Executa o comando para descompactar o arquivo no servidor
Log.imprime("INICIANDO PROCESSO DE DESCOMPACTACAO DO ZIP NO DESTINO")
comando_unzip = "unzip -l " + self.diretorio_ssh + "/" + arquivo_zip + " -d " + self.diretorio_ssh
ssh.executar_comando(comando_unzip)
comando_unzip = "unzip -o " + self.diretorio_ssh + "/" + arquivo_zip + " -d " + self.diretorio_ssh
ssh.executar_comando(comando_unzip)
Log.imprime("PROCESSO DE DESCOMPACTACAO ENCERRADO COM SUCESSO")
ssh.executar_comando("rm " + self.diretorio_ssh + "/" + arquivo_zip)
# Fecha a conexao
ssh.fechar_conexao()
Log.imprime("DEPLOY ENCERRADO COM SUCESSO",
"DEPLOY ENCERRADO COM SUCESSO")
from python.assistentes.SSH import SSH
aplicacao = "dashboard_crawler"
artefato_zip = "web-crawler-app.zip"
artefato_jar = "web-crawler-app.jar"
destino = "/opt/dashboard/crawlerGCOM"
caminho_completo_zip = destino + "/" + artefato_zip
caminho_completo__jar = destino + "/" + artefato_jar
servidor = getenv("SERVIDOR")
usuario = getenv("USUARIO")
senha = getenv("SENHA")
ssh = SSH(servidor, usuario)
ssh.senha(senha)
ssh.abrir_conexao()
ssh.executar_comando("/etc/init.d/" + aplicacao + " stop")
ssh.executar_comando("rm -v " + caminho_completo_zip)
ssh.executar_comando("rm -v " + caminho_completo__jar)
ssh.executar_comando("rm -vfr " + destino + "/lib")
ssh.enviar_arquivo(artefato_zip, caminho_completo_zip)
# ssh.executar_comando("unzip -v " + caminho_completo)
ssh.executar_comando("cd " + destino + " && unzip " + caminho_completo_zip)
ssh.executar_comando("/etc/init.d/" + aplicacao + " start")
ssh.fechar_conexao()
Log.imprime("FALHA\n" + format_exc(),
"FALHA -- COMANDO NAO EXECUTADO",
script="implantar_tomcat.py",
mensagem_de_erro=True)
servidor = servidorPorta.split(":")[0]
porta = servidorPorta.split(":")[1]
mensagem = "CONECTANDO AO SERVIDOR DA APLICACAO"
mensagem += "Servidor: %s" % servidor
Log.imprime(mensagem, mensagem)
chave = DIRETORIO_CHAVES_SERVIDORES + arquivoChaveSSH
pathArquivoDeployTomcat = WORKING_DIRECTORY + "/scripts/shell/deploy_tomcat.sh"
ssh = SSH(servidor, "tfsservice")
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.enviar_arquivo(pathArquivoDeployTomcat, "/tmp/deploy_tomcat.sh")
ssh.enviar_arquivo(contextPath + ".war", "/tmp/" + contextPath + ".war")
ssh.executar_comando("chmod +x /tmp/deploy_tomcat.sh")
comando_deploy = '/tmp/deploy_tomcat.sh "%s" "%s" %s %s %s %s %s' % (
usuarioTomcat, SENHA_TOMCAT, dominio, porta, contextPath, aplicacaoParar,
tempoEsperar)
retorno_comando = ssh.executar_comando(comando_deploy)
ssh.executar_comando("rm -f /tmp/" + contextPath + ".war")
ssh.fechar_conexao()
data_hora_execucao = ManipuladorDataHora.obter_data_hora_atual()
data_hora_deploy = ArquivoProperties("data-hora-deploy.properties")
data_hora_deploy.alterar_valor_chave("Data_Hora_Inicio_Analise",
data_hora_execucao)
def implantar_artefato(self):
if PIPELINE_NAME.__contains__("adapter") and PIPELINE_NAME.split("_")[-1] == "integracao":
Log.imprime("INICIANDO DEPLOY DO ADAPTER NO AMBIENTE DE INTEGRACAO",
"INICIANDO DEPLOY DO ADAPTER NO AMBIENTE DE INTEGRACAO.")
comando_touch = "touch /var/log/tibco/DEV_INFG_TIBCO/" + NOME_PROJETO + "/" + NOME_PROJETO + "SAP.log"
comentario_deploy = "EAR: %s - XML: Revision-%s" % (PIPELINE_LABEL, self.__REVISION_XML)
comando_deploy = "cd /opt/tibco/deploy/scripts; ./Deploy.sh ../artefatos/%s ../artefatos/%s %s \"%s\"" % (
self.__ARQUIVO_XML, self.__ARTEFATO, ESTRUTURA_PASTA_TIBCO, comentario_deploy)
comando_validate = "cd /opt/tibco/deploy/scripts; ./ValidaDeployAdapterSAP.sh " + NOME_PROJETO
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
self.__servidor_master)
ssh = SSH(self.__servidor_master, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO", classe=ImplantadorTibco)
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO", classe=ImplantadorTibco)
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
Log.imprime("ABRINDO CONEXAO", classe=ImplantadorTibco)
ssh.abrir_conexao()
Log.imprime("ENVIANDO ARQUIVO " + self.__CAMINHO_ARQUIVO_XML + " PARA /opt/tibco/deploy/artefatos")
ssh.enviar_arquivo(self.__CAMINHO_ARQUIVO_XML, "/opt/tibco/deploy/artefatos")
Log.imprime("ENVIANDO ARTEFATO " + self.__CAMINHO_ARTEFATO + " PARA /opt/tibco/deploy/artefatos")
ssh.enviar_arquivo(self.__CAMINHO_ARTEFATO, "/opt/tibco/deploy/artefatos")
ssh.executar_comando(comando_touch)
saida = ssh.executar_comando(comando_deploy)
ssh.executar_comando(comando_validate)
ssh.fechar_conexao()
elif PIPELINE_NAME.__contains__("adapter") and PIPELINE_NAME.split("_")[-1] == "staging":
Log.imprime("INICIANDO DEPLOY DO ADAPTER NO AMBIENTE DE STAGING",
"INICIANDO DEPLOY DO ADAPTER NO AMBIENTE DE STAGING.")
if SERVIDOR_DEPLOY.__contains__("2"):
comando_touch = "touch /var/log/tibco/DEV_INFG_TIBCO_QLT/" + NOME_PROJETO + "-qlt2/" + \
NOME_PROJETO + "-qlt2SAP.log"
comando_validate = "cd /opt/tibco/deploy/scripts; ./ValidaDeployAdapterSAP.sh " + NOME_PROJETO + "-qlt2"
else:
comando_touch = "touch /var/log/tibco/DEV_INFG_TIBCO_QLT/" + NOME_PROJETO + "/" + \
NOME_PROJETO + "SAP.log"
comando_validate = "cd /opt/tibco/deploy/scripts; ./ValidaDeployAdapterSAP.sh " + NOME_PROJETO
comentario_deploy = "EAR: %s - XML: Revision-%s" % (PIPELINE_LABEL, self.__REVISION_XML)
comando_deploy = "cd /opt/tibco/deploy/scripts; ./Deploy.sh ../arquivos/%s ../arquivos/%s %s \"%s\"" % (
self.__ARQUIVO_XML, self.__ARTEFATO, ESTRUTURA_PASTA_TIBCO, comentario_deploy)
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
SERVIDOR_DEPLOY)
ssh = SSH(SERVIDOR_DEPLOY, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.executar_comando(comando_touch)
ssh.fechar_conexao()
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
self.__servidor_master)
ssh = SSH(self.__servidor_master, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
Log.imprime("ENVIANDO ARQUIVO " + self.__CAMINHO_ARQUIVO_XML + " PARA /opt/tibco/deploy/arquivos")
ssh.enviar_arquivo(self.__CAMINHO_ARQUIVO_XML, "/opt/tibco/deploy/arquivos")
Log.imprime("ENVIANDO ARTEFATO " + self.__CAMINHO_ARTEFATO + " PARA /opt/tibco/deploy/arquivos")
ssh.enviar_arquivo(self.__CAMINHO_ARTEFATO, "/opt/tibco/deploy/arquivos")
saida = ssh.executar_comando(comando_deploy)
ssh.fechar_conexao()
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
SERVIDOR_DEPLOY)
ssh = SSH(SERVIDOR_DEPLOY, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.executar_comando(comando_validate)
ssh.fechar_conexao()
elif PIPELINE_NAME.__contains__("adapter") and PIPELINE_NAME.split("_")[-1] == "producao":
Log.imprime("INICIANDO DEPLOY DO ADAPTER NO AMBIENTE DE PRODUCAO",
"INICIANDO DEPLOY DO ADAPTER NO AMBIENTE DE PRODUCAO.")
if SERVIDOR_DEPLOY.__contains__("1"):
comando_touch = "touch /var/log/tibco/TIBCO/" + NOME_PROJETO + "_tbc1/" + NOME_PROJETO + "_tbc1SAP.log"
comando_validate = "cd /opt/tibco/deploy/scripts; ./ValidaDeployAdapterSAP.sh " + NOME_PROJETO + "_tbc1"
else:
comando_touch = "touch /var/log/tibco/TIBCO/" + NOME_PROJETO + "_tbc2/" + NOME_PROJETO + "_tbc2SAP.log"
comando_validate = "cd /opt/tibco/deploy/scripts; ./ValidaDeployAdapterSAP.sh " + NOME_PROJETO + "_tbc2"
comentario_deploy = "EAR: %s - XML: Revision-%s - Mudança: %s" % (PIPELINE_LABEL,
self.__REVISION_XML, self.__MUDANCA)
comando_deploy = "cd /opt/tibco/deploy/scripts; ./Deploy.sh ../arquivos/%s ../arquivos/%s %s_%s \"%s\"" % (
self.__ARQUIVO_XML, self.__ARTEFATO, ESTRUTURA_PASTA_TIBCO, SERVIDOR_DEPLOY, comentario_deploy)
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
SERVIDOR_DEPLOY)
ssh = SSH(SERVIDOR_DEPLOY, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.executar_comando(comando_touch)
ssh.fechar_conexao()
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
self.__servidor_master)
ssh = SSH(self.__servidor_master, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
Log.imprime("ENVIANDO ARQUIVO " + self.__CAMINHO_ARQUIVO_XML + " PARA /opt/tibco/deploy/arquivos")
ssh.enviar_arquivo(self.__CAMINHO_ARQUIVO_XML, "/opt/tibco/deploy/arquivos")
Log.imprime("ENVIANDO ARTEFATO " + self.__CAMINHO_ARTEFATO + " PARA /opt/tibco/deploy/arquivos")
ssh.enviar_arquivo(self.__CAMINHO_ARTEFATO, "/opt/tibco/deploy/arquivos")
saida = ssh.executar_comando(comando_deploy)
ssh.fechar_conexao()
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
SERVIDOR_DEPLOY)
ssh = SSH(SERVIDOR_DEPLOY, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.executar_comando(comando_validate)
ssh.fechar_conexao()
elif PIPELINE_NAME.split("_")[-1] == "producao":
Log.imprime("INICIANDO DEPLOY DO SERVICO NO AMBIENTE DE PRODUCAO",
"INICIANDO DEPLOY DO SERVICO NO AMBIENTE DE PRODUCAO.")
comentario_deploy = "EAR: %s - XML: Revision-%s - Mudança: %s" % (PIPELINE_LABEL, self.__REVISION_XML,
self.__MUDANCA)
comando_deploy = "cd /opt/tibco/deploy/scripts; ./Deploy.sh ../arquivos/%s ../arquivos/%s %s_%s \"%s\"" % (
self.__ARQUIVO_XML, self.__ARTEFATO, ESTRUTURA_PASTA_TIBCO, SERVIDOR_DEPLOY, comentario_deploy)
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR infotbc1")
ssh = SSH(self.__servidor_master, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
Log.imprime("ENVIANDO ARQUIVO " + self.__CAMINHO_ARQUIVO_XML + " PARA /opt/tibco/deploy/artefatos")
ssh.enviar_arquivo(self.__CAMINHO_ARQUIVO_XML, "/opt/tibco/deploy/arquivos")
Log.imprime("ENVIANDO ARTEFATO " + self.__CAMINHO_ARTEFATO + " PARA /opt/tibco/deploy/artefatos")
ssh.enviar_arquivo(self.__CAMINHO_ARTEFATO, "/opt/tibco/deploy/arquivos")
saida = ssh.executar_comando(comando_deploy)
ssh.fechar_conexao()
elif PIPELINE_NAME.split("_")[-1] == "integracao" or PIPELINE_NAME.split("_")[-1] == "staging":
Log.imprime("INICIANDO DEPLOY DO SERVICO", "INICIANDO DEPLOY DO SERVICO")
comentario_deploy = "EAR: %s - XML: Revision-%s" % (PIPELINE_LABEL, self.__REVISION_XML)
comando_deploy = "cd /opt/tibco/deploy/scripts; ./Deploy.sh ../artefatos/%s ../artefatos/%s %s \"%s\""\
% (self.__ARQUIVO_XML, self.__ARTEFATO, ESTRUTURA_PASTA_TIBCO, comentario_deploy)
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " + self.__USUARIO_SSH + " NO SERVIDOR " +
self.__servidor_master)
ssh = SSH(self.__servidor_master, self.__USUARIO_SSH)
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
Log.imprime("ENVIANDO ARQUIVO " + self.__CAMINHO_ARQUIVO_XML + " PARA /opt/tibco/deploy/artefatos")
ssh.enviar_arquivo(self.__CAMINHO_ARQUIVO_XML, "/opt/tibco/deploy/artefatos")
Log.imprime("ENVIANDO ARTEFATO " + self.__CAMINHO_ARTEFATO + " PARA /opt/tibco/deploy/artefatos")
ssh.enviar_arquivo(self.__CAMINHO_ARTEFATO, "/opt/tibco/deploy/artefatos")
saida = ssh.executar_comando(comando_deploy)
ssh.fechar_conexao()
else:
Log.imprime("CHAVE DE AMBIENTE DE DEPLOY DESCONHECIDO: " + PIPELINE_NAME.split("_")[-1],
"CHAVE DE AMBIENTE DE DEPLOY DESCONHECIDO.", classe=ImplantadorTibco)
saida = ""
exit(1)
if "Finished successfully" not in str(saida):
Log.imprime("ERRO NO DEPLOY DO TIBCO\n" + saida, "ERRO NO DEPLOY DO TIBCO.", classe=ImplantadorTibco)
exit(1)
Log.imprime("DEPLOY ENCERRADO", "DEPLOY ENCERRADO COM SUCESSO")
if "-arquivoCsv" in parametro:
arquivoCsv = parametro.replace("-arquivoCsv=", "")
if "-arquivoLimites" in parametro:
arquivoLimites = parametro.replace("-arquivoLimites=", "")
if "-senhaJmeter" in parametro:
senhaJmeter = parametro.replace("-senhaJmeter=", "")
JAR_VALIDADOR_TESTE_PERFORMANCE = "/opt/validador-teste-performance-1.1.jar"
chave = DIRETORIO_CHAVES_SERVIDORES + arquivoChaveSSH
try:
Log.imprime("CONECTANDO AO SERVIDOR DE TESTES\nServidor: %s" % servidor)
# Usando usuario jmeter temporariamente
# ssh = SSH(servidor, "tfsservice")
# ssh.chave_acesso(chave)
ssh = SSH(servidor, "jmeter")
ssh.senha(senhaJmeter)
ssh.abrir_conexao()
ssh.executar_comando("/home/jmeter/autojmeter " + jmeterTeste)
ssh.obter_arquivo("/home/jmeter/reports/" + arquivoCsv, ".")
ssh.fechar_conexao()
Log.imprime("EXECUTANDO A VALIDACAO", "EXECUTANDO A VALIDACAO")
arquivoLimites = "scripts/assistentes_performance/" + arquivoLimites
comando = 'java -cp %s leitor.jmeter.validacao.deploy.Processar %s %s | tee output.txt' % \
(JAR_VALIDADOR_TESTE_PERFORMANCE, arquivoCsv, arquivoLimites)
check_call([comando], shell=True)
Log.imprime("SUCESSO -- VALIDACAO EXECUTADA",
"SUCESSO -- VALIDACAO EXECUTADA")
except:
def atualizar_conf_apache(self):
novo_servidor_backend = getenv("NOVO_SERVIDOR_BACKEND")
if novo_servidor_backend:
self.editar_conf_apache(novo_servidor_backend)
chave = DIRETORIO_CHAVES_SERVIDORES + self.ARQUIVO_CHAVE_SSH
for servidor in self.SERVIDORES_APACHE.split(","):
pasta_servidor = self.PASTA_CONF_APACHE + "/" + servidor
ssh = SSH(servidor, self.USUARIO_SSH)
ssh.chave_acesso(chave)
ssh.abrir_conexao()
for arquivo_conf in listdir(pasta_servidor):
if arquivo_conf.endswith(".conf"):
ssh.enviar_arquivo(pasta_servidor + "/" + arquivo_conf, self.CAMINHO_CONF_APACHE)
comando_reload_apache = "{} {}".format(self.script_reload_apache, arquivo_conf)
ssh.executar_comando(comando_reload_apache)
ssh.fechar_conexao()
Log.imprime("url_check: " + url_check)
Log.imprime("resposta.text: " + resposta.text)
if resposta.status_code != 200:
mensagem = "ERRO ao verificar healthcheck pela url na etapa" + etapa
mensagem += "Status code: " + resposta.status_code
Log.imprime(mensagem,
mensagem,
script="manipular_load_balance.py",
mensagem_de_erro=True)
exit(1)
if etapa.lower() == "pre_deploy":
comando_ssh = "rm " + CAMINHO_HEALTHCHECK + " || echo 'Arquivo " + CAMINHO_HEALTHCHECK + " nao encontrado'"
else:
comando_ssh = "echo HEALTHCHECK > " + CAMINHO_HEALTHCHECK + " || echo 'Nao foi possivel criar o arquivo" \
+ CAMINHO_HEALTHCHECK + "'"
ssh = SSH(servidor, USUARIO_SSH)
if SENHA_SSH:
ssh.senha(SENHA_SSH)
elif ARQUIVO_CHAVE_SSH:
chave = DIRETORIO_CHAVES_SERVIDORES + ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
ssh.executar_comando(comando_ssh)
ssh.fechar_conexao()
Log.imprime("Esperando por 2 minutos", "Esperando por 2 minutos")
sleep(120)
def implantar_artefato(self):
# Metodo responsavel por implantar o artefato
Log.imprime(
"RENOMEANDO ARTEFATO COM O CONTEXT PATH QUE SERA IMPLANTADO",
"INICIANDO DEPLOY NO TOMCAT")
# Comando para mover o .war para o local correto
comando = 'if [ ! -f %s.war ]; then mv %s/*.war %s.war; fi' % (
self.__CONTEXT_PATH, WORKING_DIRECTORY, self.__CONTEXT_PATH)
Log.imprime("EXECUTANDO COMANDO " + comando)
check_call([comando], shell=True)
# Faz uma manipulacao de strings para obter o servidor e a porta separadamente
servidor = self.__SERVIDOR_PORTA_TOMCAT.split(":")[0]
porta = self.__SERVIDOR_PORTA_TOMCAT.split(":")[1]
path_arquivo_deploy_tomcat = path.dirname(
__file__) + "/../../shell/deploy_tomcat.sh"
Log.imprime("PREPARANDO PARA ABRIR CONEXAO COM O USUARIO " +
str(self.__USUARIO_SSH) + " NO SERVIDOR " + servidor)
# Preparando a conexao via SSH
ssh = SSH(servidor, self.__USUARIO_SSH)
# Verifica se sera utilizada senha para autenticacao
if self.__SENHA_SSH:
Log.imprime("UTILIZANDO SENHA PARA AUTENTICACAO")
ssh.senha(self.__SENHA_SSH)
elif self.__ARQUIVO_CHAVE_SSH:
# Caso nao seja autenticacao via senha, e considerado que sera autenticacao via arquivos de chaves
Log.imprime("UTILIZANDO ARQUIVO DE CHAVES PARA AUTENTICACAO")
chave = DIRETORIO_CHAVES_SERVIDORES + self.__ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
# Abre a conexao SSH
ssh.abrir_conexao()
# Envia o arquivo auxiliar de deploy no tomcat para o servidor
Log.imprime("ENVIANDO ARQUIVO " + path_arquivo_deploy_tomcat)
ssh.enviar_arquivo(path_arquivo_deploy_tomcat, "/tmp/deploy_tomcat.sh")
# Envia o arquivo .war para o servidor
Log.imprime("ENVIANDO ARTEFATO " + self.__CONTEXT_PATH + ".war")
ssh.enviar_arquivo(self.__CONTEXT_PATH + ".war",
"/tmp/" + self.__CONTEXT_PATH + ".war")
# Monta o comando que altera a permissao do arquivo auxilixar para que possa ser executado no servidor
comando_permissao = "chmod +x /tmp/deploy_tomcat.sh"
Log.imprime("EXECUTANDO COMANDO DE ALTERACAO DE PERMISSAO " +
comando_permissao)
# Executa o comando que altera a permissao do arquivo auxiliar
ssh.executar_comando(comando_permissao)
comando_deploy = '/tmp/deploy_tomcat.sh "%s" "%s" %s %s %s %s %s' % (
self.__USUARIO_TOMCAT, self.__SENHA_TOMCAT, self.__DOMINIO_TOMCAT,
porta, self.__CONTEXT_PATH, self.__APLICACAO_PARAR,
self.__TEMPO_ESPERAR)
# Executa o comando de deploy no servidor
retorno_comando = ssh.executar_comando(comando_deploy)
Log.imprime("REMOVENDO ARTEFATO QUE ESTAVA NA PASTA TEMPORARIA")
# Remove o arquivo .war que ja nao sera mais utilizado
ssh.executar_comando("rm -f /tmp/" + self.__CONTEXT_PATH + ".war")
# Fecha a conexao
ssh.fechar_conexao()
# Verifica se ouve falha na execucao do comando e caso haja retorna uma mensagem de erro e quebra
if "FAIL" in str(retorno_comando):
Log.imprime("ERRO AO EXECUTAR deploy_tomcat.sh - " +
retorno_comando,
"ERRO NO DEPLOY NO TOMCAT.",
classe=ImplantadorTomcat)
exit(1)
Log.imprime("DEPLOY ENCERRADO", "DEPLOY ENCERRADO COM SUCESSO")
from sys import argv
etapa = None
for parametro in argv:
if "-etapa" in parametro:
etapa = str(parametro).replace("-etapa=", "")
SERVIDOR_LOADBALANCE = getenv("SERVIDOR_LOADBALANCE")
USUARIO_LOADBALANCE = "tfsservice"
SENHA_LOADBALANCE = getenv("SENHA_LOADBALANCE")
ARQUIVO_CHAVE_SSH = "teste.ppk"
BACKEND = getenv("BACKEND")
SERVIDOR_BACKEND = getenv("SERVIDOR_BACKEND")
ssh = SSH(SERVIDOR_LOADBALANCE, USUARIO_LOADBALANCE)
if SENHA_LOADBALANCE:
ssh.senha(SENHA_LOADBALANCE)
elif ARQUIVO_CHAVE_SSH:
chave = DIRETORIO_CHAVES_SERVIDORES + ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
for BKE in BACKEND.split(","):
if etapa.lower() == "pre_deploy":
comando_ssh = "echo disable server " + BKE + "/" + SERVIDOR_BACKEND \
+ " | sudo nc -U /var/lib/haproxy/stats"
else:
comando_ssh = "echo enable server " + BKE + "/" + SERVIDOR_BACKEND \
+ " | sudo nc -U /var/lib/haproxy/stats"
from python.assistentes.SSH import SSH
from python.settings import getenv, DIRETORIO_CHAVES_SERVIDORES
SERVIDOR = getenv("SERVIDOR")
CAMINHO = getenv("CAMINHO")
COMANDO = getenv("COMANDO")
PARAMETROS = getenv("PARAMETROS")
USUARIO_SSH = getenv("USUARIO_SSH")
SENHA_SSH = getenv("SENHA_SSH")
ARQUIVO_CHAVE_SSH = getenv("ARQUIVO_CHAVE_SSH")
ssh = SSH(SERVIDOR, USUARIO_SSH)
if SENHA_SSH:
ssh.senha(SENHA_SSH)
elif ARQUIVO_CHAVE_SSH:
chave = DIRETORIO_CHAVES_SERVIDORES + ARQUIVO_CHAVE_SSH
ssh.chave_acesso(chave)
ssh.abrir_conexao()
comando_executar = None
if PARAMETROS:
comando_executar = "cd %s; ./%s %s" % (CAMINHO, COMANDO, PARAMETROS)
else:
comando_executar = "cd %s; ./%s" % (CAMINHO, COMANDO)
ssh.executar_comando(comando_executar)
ssh.fechar_conexao()