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")
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")
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()
__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()
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:
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()