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 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 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 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):
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 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 colocar_banco_dados_offline(self):
comando_set_offline = "alter database " + self.NOME_BANCO_STG + " set offline with rollback immediate"
with open("comandoSetOffLine.sql", "w") as arq:
arq.write(comando_set_offline)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoSetOffLine.sql "
"-o log_comandoSetOffLine.txt")
sleep(2)
tamanho_arquivo_log = stat("log_comandoSetOffLine.txt").st_size
with open("log_comandoSetOffLine.txt", "r") as arq:
if "Estimated rollback completion: 100%." in arq.read():
Log.imprime("SUCESSO - COLOCAR O BANCO DE STG OFFLINE",
"SUCESSO - COLOCAR O BANCO DE STG OFFLINE")
elif tamanho_arquivo_log == 0:
Log.imprime("SUCESSO - COLOCAR O BANCO DE STG OFFLINE",
"SUCESSO - COLOCAR O BANCO DE STG OFFLINE")
else:
Log.imprime("FALHA - COLOCAR O BANCO DE STG OFFLINE\n" +
arq.read(),
"FALHA - COLOCAR O BANCO DE STG OFFLINE",
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 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 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 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 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 executa_testes(self, out=sys.stdout):
comando = "%s/bin/grails -Dgrails.work.dir=target test-app -coverage --non-interactive --plain-output " \
"--stacktrace" % self.GRAILS_HOME
Log.imprime("INICIANDO TESTES DO GRAILS", "INICIANDO TESTES DO GRAILS")
LinhaDeComando.executar(comando)
Log.imprime("TESTES ENCERRADOS COM SUCESSO.",
"TESTES ENCERRADOS COM SUCESSO")
comando = "%s/bin/grails compile --non-interactive --plain-output" % self.GRAILS_HOME
Log.imprime("COMPILANDO CLASSES PARA O SONAR",
"COMPILANDO CLASSES PARA O SONAR")
LinhaDeComando.executar(comando)
def fechar_artefato(self, out=sys.stdout):
comando_clean = "%s/bin/grails clean" % self.GRAILS_HOME
Log.imprime("INICIANDO PROCESSO DE CLEAN",
"INICIANDO PROCESSO DE FECHAMENTO DO ARTEFATO.")
LinhaDeComando.executar(comando_clean)
Log.imprime("PROCESSO DE CLEAN ENCERRADO COM SUCESSO")
comando_deploy = "%s/bin/grails war --verbose" % self.GRAILS_HOME
Log.imprime("INICIANDO PROCESSO DE FECHAMENTO DO WAR")
LinhaDeComando.executar(comando_deploy)
Log.imprime("ARTEFATO GERADO COM SUCESSO",
"ARTEFATO GERADO COM SUCESSO.")
def executa_testes(self):
comando_dos = 'C: && cd C:\\tibco\\designer\\5.8\\bin && validateproject.exe -a "%s" -project "%s\\%s" > "%s"' \
% (self.__ALIAS_PROPERTIES, WORKING_DIRECTORY, NOME_PROJETO, self.__LOG_VALIDACAO)
Log.imprime("INICIANDO OS TESTES DO TIBCO", "INICIANDO OS TESTES DO TIBCO.")
LinhaDeComando.executar(comando_dos)
Log.imprime("TESTES ENCERRADOS.", "TESTES ENCERRADOS")
comando_dos = 'findstr /n /c:"%s" "%s"' % (self.__TEXTO_VERICAR_FALHA_VALIDACAO, self.__LOG_VALIDACAO)
dos_return_code = LinhaDeComando.executar(comando_dos, True)
if not dos_return_code == 0:
LinhaDeComando.lancar_erro("O servico nao passou na validacao")
Log.imprime("SERVICO NAO PASSOU NA VALIDACAO.", "SERVICO NAO PASSOU NA VALIDACAO.", classe=Tibco)
Log.imprime("TESTES ENCERRADOS COM SUCESSO.", "TESTES ENCERRADOS COM SUCESSO.")
def fechar_artefato(self):
archive_utilizado = "/eAI/Deploy/%s.archive" % NOME_PROJETO
diretorio_build_ear = '%s\\%s.ear' % (WORKING_DIRECTORY, NOME_PROJETO)
mensagem = "##### INICIANDO O BUILD DO SERVICO (TRA - BUILDER) #####\n" \
"##### ARCHIVE: %s #####\n" \
"##### DIR. BUILD EAR: %s #####\n" \
"##### DIR. APLICACAO: %s\\%s #####\n" \
"##### DIR. alias.properties: %s #####" % \
(archive_utilizado, diretorio_build_ear, WORKING_DIRECTORY, NOME_PROJETO, self.__ALIAS_PROPERTIES)
Log.imprime(mensagem, mensagem)
comando_dos = 'buildear -o "%s" -p "%s\\%s" -a "%s" -ear "%s" -x' % (
diretorio_build_ear, WORKING_DIRECTORY, NOME_PROJETO, self.__ALIAS_PROPERTIES, archive_utilizado)
Log.imprime("EXECUTANDO O COMANDO: " + str(comando_dos))
LinhaDeComando.executar(comando_dos)
Log.imprime("ARTEFATO GERADO COM SUCESSO.", "ARTEFATO GERADO COM SUCESSO.")
def criar_tabelas_necessarias_para_flyway(self):
if self.eh_um_banco_de_dados_novo():
nome_banco_de_dados = "jtds:sqlserver://" + self.SERVIDOR_PORTA + "/" + self.NOME_BANCO
comando = "-user="******" -password="******" -url=jdbc:" + \
nome_banco_de_dados + " -table="
LinhaDeComando.executar("flyway baseline " + comando +
"schema_migrate")
Log.imprime(
"TABELA MIGRATE CRIADA COM SUCESSO -" + self.NOME_BANCO,
"TABELA MIGRATE CRIADA COM SUCESSO -" + self.NOME_BANCO)
if self.AMBIENTE_SVN != "PRD_TRUNK":
LinhaDeComando.executar("flyway baseline " + comando +
"schema_branch")
Log.imprime("TABELA BRANCH CRIADA COM SUCESSO",
"TABELA BRANCH CRIADA COM SUCESSO")
return True
def executa_scanner_sonar(self):
arq_prop = ArquivoProperties("sonar-msbuild.properties")
project_key = arq_prop.obter_valor_chave("project_key")
project_name = arq_prop.obter_valor_chave("project_name")
project_version = arq_prop.obter_valor_chave("project_version")
project_branch = arq_prop.obter_valor_chave("project_branch")
if project_branch:
comando = "%s begin /k:\"%s\" /n:\"%s\" /v:\"%s\" /d:sonar.branch=%s" % (
self.__scanner, project_key, project_name, project_version,
project_branch)
else:
comando = "%s begin /k:\"%s\" /n:\"%s\" /v:\"%s\"" % (
self.__scanner, project_key, project_name, project_version)
Log.imprime("PREPARANDO SCANNER MSBUILD DO SONAR",
"PREPARANDO SCANNER MSBUILD DO SONAR")
LinhaDeComando.executar(comando)
comando = "\"%s\" build.xml" % self.__caminho_msbuild
Log.imprime("REALIZANDO REBUILD DA APLICACAO PARA O SONAR",
"REALIZANDO REBUILD DA APLICACAO PARA O SONAR")
LinhaDeComando.executar(comando)
comando = "%s end" % self.__scanner
Log.imprime("FINALIZANDO SCANNER MSBUILD DO SONAR",
"FINALIZANDO SCANNER MSBUILD DO SONAR")
LinhaDeComando.executar(comando)
def realizar_failback_no_banco_dados(self):
self.__matar_todas_conexoes_no_banco_dados()
comando = "RESTORE DATABASE " + self.NOME_BANCO + " FROM DATABASE_SNAPSHOT = '" + self.NOME_BANCO + \
"_SNAPSHOT';"
with open("comandoFailBack.sql", "w") as arq:
arq.write(comando)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA + " -U " + self.USUARIO_BANCO +
" -P " + self.SENHA_BANCO +
" -i comandoFailBack.sql -o log_comandoFailBack.txt")
with open("log_comandoFailBack.txt", "r") as arq:
Log.imprime("REALIZANDO O FAILBACK\n" + arq.read(),
"REALIZANDO O FAILBACK")
self.habiltar_usuario_aplicacao_acesso_banco_dados()
"""info_banco_dados = InformacoesBancoDados(NOME_BANCO)
versao_failback = info_banco_dados.obter_revision_deploy_prd_failback()
ultima_versao_producao = obter_versao("INFOSQL:1433","INFG_Jenkins", NOME_BANCO ,"ANavpzv2CcfEMtcagaIY")
if versao_failback == ultima_versao_producao:
print("#################################################")
print("## DEPLOY REALIZADO COM SUCESSO ##")
print("## VERSAO PRD FAILBACK...: " + versao_failback + " ##")
print("## VERSAO PRD ATUAL .....: " + ultima_versao_producao + " ##")
print("#################################################")
else:
print("#################################################")
print("## FALHA NO DEPLOY ##")
print("## VERSAO PRD FAILBACK...: " + versao_failback + " ##")
print("## VERSAO PRD ATUAL .....: " + ultima_versao_producao + " ##")
print("#################################################")
exit(1)"""
self.remover_snapshot()
def __matar_todas_conexoes_no_banco_dados(self):
with open(
path.dirname(__file__) +
"\\..\\..\\sql\\comandoMatarTodasConexoesTemplate.sql",
"r") as arq:
arquivo_alterado = arq.read()
arquivo_alterado = arquivo_alterado.replace(
"<LOGIN>", self.USUARIO_APLICAO_ACESSO_BANCO[0])
arquivo_alterado = arquivo_alterado.replace("<BASE DE DADOS>",
self.NOME_BANCO)
with open("comandoMatarTodasConexoes.sql", "w") as arq:
arq.write(arquivo_alterado)
LinhaDeComando.executar("sqlcmd -S " + self.SERVIDOR_PORTA + " -U " +
self.USUARIO_BANCO + " -P " +
self.SENHA_BANCO +
" -i comandoMatarTodasConexoes.sql "
"-o log_comandoMatarTodasConexoes.txt")
tamanho_arquivo_log = stat("log_comandoMatarTodasConexoes.txt").st_size
if tamanho_arquivo_log == 0:
Log.imprime(
"SUCESSO - FORAM CANCELADAS TODAS CONEXOES COM O BANCO DE DADOS",
"SUCESSO - FORAM CANCELADAS TODAS CONEXOES COM O BANCO DE DADOS"
)
else:
with open("log_comandoMatarTodasConexoes.txt", "r") as arq:
Log.imprime(
"FALHA - AO CANCELAR AS CONEXOES DE ACESSO COM O BANCO DE DADOS\n"
+ arq.read(),
"FALHA - AO CANCELAR AS CONEXOES DE ACESSO COM O BANCO DE DADOS",
classe=BancoDados)
exit(1)
def executar_script_sql_no_banco_dados(self):
self.criar_tabelas_necessarias_para_flyway()
schema = "schema_migrate"
if self.AMBIENTE_SVN == "STG_BRANCH":
schema = "schema_branch"
numero_scripts_sql = len(listdir(self.PASTA_SCRIPT_SQL))
if numero_scripts_sql > 1:
nome_banco_de_dados = "jtds:sqlserver://" + self.SERVIDOR_PORTA + "/" + self.NOME_BANCO
caminho_sql = "filesystem:" + WORKING_DIRECTORY + "/" + self.PASTA_SCRIPT_SQL
comando = "-user="******" -password="******" -url=jdbc:" + \
nome_banco_de_dados + " -locations=" + caminho_sql + " -table=" + schema
LinhaDeComando.executar("flyway migrate " + comando)
sleep(2)
Log.imprime("COMANDO EXECUATDO FLYWAY..:" + comando)
LinhaDeComando.executar("flyway validate " + comando)
else:
Log.imprime(
"NAO FOI ENCONTRADO NENHUM SCRIPT SQL PARA SER EXECUTADO",
"NAO FOI ENCONTRADO NENHUM SCRIPT SQL PARA SER EXECUTADO")
return "NENJUM_SQL_NA_PASTA"
def restaurar_banco_dados_com_ultima_versao_stg(self):
nome_banco_logico = getenv("NOME_BANCO_LOGICO")
caminho_mdf_ldf = getenv("CAMINHO_MDF_LDF") + "{0}'"
if not self.possui_backup():
self.criar_backup()
self.colocar_banco_dados_offline()
comando_restaurar_backup = "restore database " + self.NOME_BANCO_STG + " from disk ='" + \
self.CAMINHO_ARQUIVO_BACKUP + self.NOME_BANCO_STG + \
"-devops.bak' with replace,stats, move '" + nome_banco_logico + "_data' to '" + \
caminho_mdf_ldf.format(self.NOME_BANCO_STG + ".mdf") + ", move '" + \
nome_banco_logico + "_log' to '" + caminho_mdf_ldf.format(self.NOME_BANCO_STG +
"_log.ldf")
with open("comandoRestaurarBackup.sql", "w") as arq:
arq.write(comando_restaurar_backup)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoRestaurarBackup.sql "
"-o log_comandoRestaurarBackup.txt")
falha_processo_restaurar_backup = False
with open("log_comandoRestaurarBackup.txt", "r") as arq:
if "processed" in arq.read():
Log.imprime(
"SUCESSO - BACKUP RESTAURADO -" + self.NOME_BANCO_STG,
"SUCESSO - BACKUP RESTAURADO - " + self.NOME_BANCO_STG)
else:
falha_processo_restaurar_backup = True
Log.imprime("FALHA - NO RESTORE DO BACKUP\n" + arq.read(),
"FALHA - NO RESTORE DO BACKUP",
classe=BancoDados)
sleep(5)
comando_set_online = "alter database " + self.NOME_BANCO_STG + " set online"
with open("comandoSetOnLine.sql", "w") as arq:
arq.write(comando_set_online)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoSetOnLine.sql "
"-o log_comandoSetOnLine.txt")
tamanho_arquivo_log = stat("log_comandoSetOnLine.txt").st_size
if tamanho_arquivo_log == 0:
Log.imprime("SUCESSO - VOLTAR O BANCO DE STG ONLINE",
"SUCESSO - VOLTAR O BANCO DE STG ONLINE")
else:
with open("log_comandoSetOnLine.txt", "r") as arq:
Log.imprime("FALHA - VOLTAR O BANCO DE STG ONLINE\n" +
arq.read(),
"FALHA - VOLTAR O BANCO DE STG ONLINE",
classe=BancoDados)
falha_processo_restaurar_backup = True
if falha_processo_restaurar_backup:
exit(1)
def restaurar_banco_dados_stg_com_ultima_versao_prd(self):
nome_banco_logico = getenv("NOME_BANCO_LOGICO")
caminho_mdf_ldf = getenv("CAMINHO_MDF_LDF") + self.NOME_BANCO_STG
self.criar_backup(prd=True)
self.colocar_banco_dados_offline()
falha_processo_restaurar_backup = False
comando_restaurar_backup = "restore database " + self.NOME_BANCO_STG + " from disk ='" + \
self.CAMINHO_ARQUIVO_BACKUP + self.NOME_BANCO + \
"-devops.bak' with replace,stats, move '" + nome_banco_logico + "_data' to '" + \
caminho_mdf_ldf + ".mdf', move '" + nome_banco_logico + "_log' to '" + \
caminho_mdf_ldf + "_log.ldf'"
with open("comandoRestaurarBackup.sql", "w") as arq:
arq.write(comando_restaurar_backup)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoRestaurarBackup.sql "
"-o log_comandoRestaurarBackup.txt")
with open("log_comandoRestaurarBackup.txt", "r") as arq:
if "processed" in arq.read():
Log.imprime("SUCESSO - BACKUP RESTAURADO - " + self.NOME_BANCO,
"SUCESSO - BACKUP RESTAURADO - " + self.NOME_BANCO)
else:
falha_processo_restaurar_backup = True
Log.imprime("FALHA - NO RESTORE DO BACKUP\n" + arq.read(),
"FALHA - NO RESTORE DO BACKUP",
classe=BancoDados)
sleep(5)
comando_set_online = "alter database " + self.NOME_BANCO_STG + " set online"
with open("comandoSetOnLine.sql", "w") as arq:
arq.write(comando_set_online)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoSetOnLine.sql "
"-o log_comandoSetOnLine.txt")
tamanho_arquivo_log = stat("log_comandoSetOnLine.txt").st_size
if tamanho_arquivo_log == 0:
Log.imprime("SUCESSO - VOLTAR O BANCO DE STG ONLINE",
"SUCESSO - VOLTAR O BANCO DE STG ONLINE")
else:
with open("log_comandoSetOnLine.txt", "r") as arq:
Log.imprime("FALHA - VOLTAR O BANCO DE STG ONLINE\n" +
arq.read(),
"FALHA - VOLTAR O BANCO DE STG ONLINE",
classe=BancoDados)
falha_processo_restaurar_backup = True
comando_renomear_logical_names = "ALTER DATABASE " + self.NOME_BANCO_STG + " MODIFY FILE (NAME=N'" + \
self.NOME_BANCO + "_data', NEWNAME=N'" + self.NOME_BANCO_STG + \
"_data')\nGO\nALTER DATABASE " + self.NOME_BANCO_STG + \
" MODIFY FILE (NAME=N'" + self.NOME_BANCO + "_log', NEWNAME=N'" + \
self.NOME_BANCO_STG + "_log')\nGO\nALTER DATABASE " + self.NOME_BANCO_STG + \
" set recovery simple;\nGO"
with open("comandoRenomearLogicalNames.sql", "w") as arq:
arq.write(comando_renomear_logical_names)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoRenomearLogicalNames.sql "
"-o log_comandoRenomearLogicalNames.txt")
with open("log_comandoRenomearLogicalNames.txt", "r") as arq:
if "has been set" in arq.read():
Log.imprime(
"SUCESSO - LOGICAL NAMES RENOMEAROS - " + self.NOME_BANCO,
"SUCESSO - LOGICAL NAMES RENOMEAROS - " + self.NOME_BANCO)
else:
falha_processo_restaurar_backup = True
Log.imprime("FALHA - AO RENOMEAR LOGICAL NAMES\n" + arq.read(),
"FALHA - AO RENOMEAR LOGICAL NAMES",
classe=BancoDados)
comando_trocar_usuarios = "USE " + self.NOME_BANCO_STG + "\nGO\n"
for usuario in self.USUARIO_APLICAO_ACESSO_BANCO:
comando_trocar_usuarios += "exec sp_dropuser " + usuario + " ;\n"
comando_trocar_usuarios += "exec sp_grantdbaccess DEV_" + self.USUARIO_APLICAO_ACESSO_BANCO[0] + \
";\nexec sp_grantdbaccess DEV_INFG_Jenkins;\n" \
"exec sp_addrolemember 'db_owner', 'DEV_" + self.USUARIO_APLICAO_ACESSO_BANCO[0]\
+ "';\nexec sp_addrolemember 'db_owner', 'DEV_INFG_Jenkins';\n" \
"exec sp_changedbowner 'sa';\nalter login DEV_" +\
self.USUARIO_APLICAO_ACESSO_BANCO[0] + " enable;\nalter login DEV_" + \
self.USUARIO_APLICAO_ACESSO_BANCO[0] + " with default_database = " + \
self.NOME_BANCO_STG + ";"
with open("comandoTrocarUsuarioPrdParaStg.sql", "w") as arq:
arq.write(comando_trocar_usuarios)
LinhaDeComando.executar(
"sqlcmd -S " + self.SERVIDOR_PORTA_STG +
" -U DEV_INFG_Jenkins -P 95QlyafTZ2s8 -i comandoTrocarUsuarioPrdParaStg.sql "
"-o log_comandoTrocarUsuarioPrdParaStg.txt")
with open("log_comandoTrocarUsuarioPrdParaStg.txt", "r") as arq:
if "Changed database context to '" + self.NOME_BANCO_STG + "'." in arq.read(
):
Log.imprime(
"SUCESSO - USUARIOS TROCADOS DE PRD PARA STG - " +
self.NOME_BANCO,
"SUCESSO - USUARIOS TROCADOS DE PRD PARA STG - " +
self.NOME_BANCO)
else:
falha_processo_restaurar_backup = True
Log.imprime("FALHA - AO TROCAR OS USUARIOS PRD PARA STG\n" +
arq.read(),
"FALHA - AO TROCAR OS USUARIOS PRD PARA STG",
classe=BancoDados)
if falha_processo_restaurar_backup:
exit(1)
self.criar_backup(prd=False)
remove(self.CAMINHO_ARQUIVO_BACKUP + self.NOME_BANCO + ".bak")
def executa_scanner_sonar(self):
LinhaDeComando.executar(SONNAR_SCANNER)
Log.imprime("SUCESSO NA EXECUCAO DO SONAR",
"SUCESSO NA EXECUCAO DO SONAR")
def faz_deploy_nexus(self):
comando = "%s/bin/grails maven-deploy" % self.GRAILS_HOME
Log.imprime("INICIANDO DEPLOY NO NEXUS", "INICIANDO DEPLOY NO NEXUS")
LinhaDeComando.executar(comando)
Log.imprime("DEPLOY NO NEXUS EXECUTADO COM SUCESSO",
"DEPLOY NO NEXUS EXECUTADO COM SUCESSO.")
def teste_executar_comando_sem_exit_code_com_sucesso(self):
comando = "echo Teste passou"
valor_esperado = 0
valor_obtido = LinhaDeComando.executar(comando)
self.assertEqual(valor_obtido, valor_esperado)
# coding=utf-8
from os import getenv
from time import sleep
from python.assistentes.linha_de_comando import LinhaDeComando
from python.assistentes.log import Log
ACAO = getenv("ACAO")
SERVIDOR = getenv("SERVIDOR")
SERVICO = getenv("SERVICO")
comando = "sc \\\\%s start %s" % (SERVIDOR, SERVICO)
if ACAO == "STOP":
comando = "sc \\\\%s stop %s" % (SERVIDOR, SERVICO)
retorno = LinhaDeComando.executar(comando, retornar_exit_code=True)
if retorno == 0:
sleep(10)
retorno = LinhaDeComando.executar(comando, retornar_exit_code=True)
# 1062 -> retorno ao tentar parar um servico parado
# 1056 -> retorno ao tentar iniciar um servico iniciado
if retorno == 1062 or retorno == 1056:
Log.imprime("Acao %s executada com sucesso" % ACAO, "Acao %s executada com sucesso" % ACAO)
else:
Log.imprime("Nao foi possivel executar a acao %s" % ACAO, "Nao foi possivel executar a acao %s" % ACAO,
script="start_stop_service.py", mensagem_de_erro=True)
exit(1)
WORKING_DIRECTORY = getenv("WORKING_DIRECTORY")
DIRETORIO_SOAPUI = getenv("DIR_SOAPUI")
mensagem = "XML DE TESTES: %s" % XML_PROJETO + \
"\nTEST SUIT: %s" % TEST_SUIT + \
"\nENDPOINT TESTES: %s" % ENDPOINT_TESTES
Log.imprime(mensagem, mensagem)
diretorio_xml_testes = XML_PROJETO.split("/")[0]
mensagem = "REALIZANDO UPDATE PARA A ULTIMA VERSAO DO XML DE TESTES DO SVN..." \
"\nDIRETORIO XML TESTES: %s" % diretorio_xml_testes
Log.imprime(mensagem, mensagem)
comando_update = "cd %s && svn up && cd .." % diretorio_xml_testes
LinhaDeComando.executar(comando_update)
flag_endpoint = ""
if ENDPOINT_TESTES:
flag_endpoint = "-e %s" % ENDPOINT_TESTES
comando = "/bin/bash %s/testrunner.sh %s -s \"%s\" -j -f %s -r %s" % (
DIRETORIO_SOAPUI, XML_PROJETO, TEST_SUIT, WORKING_DIRECTORY, flag_endpoint)
if LinhaDeComando.executar(comando, retornar_exit_code=True) is not 0:
mensagem = "ERRO NA EXECUCAO DO TESTE" \
"\nTestSuit = %s" % TEST_SUIT + \
"\nENDPOINT = %s" % ENDPOINT_TESTES
Log.imprime(
mensagem,
mensagem +
def faz_deploy_nexus():
# Metodo responsavel por fazer deploy no Nexus
Log.imprime("INICIANDO DEPLOY NO NEXUS", "INICIANDO DEPLOY NO NEXUS")
LinhaDeComando.executar("mvn deploy")
Log.imprime("DEPLOY NO NEXUS EXECUTADO COM SUCESSO.",
"DEPLOY NO NEXUS EXECUTADO COM SUCESSO.")
def executa_testes(self):
# Metodo responsavel por executar os testes do Maven
Log.imprime("INICIANDO TESTES DO MAVEN", "INICIANDO TESTES DO MAVEN")
LinhaDeComando.executar("mvn test")
Log.imprime("TESTES ENCERRADOS COM SUCESSO.",
"TESTES ENCERRADOS COM SUCESSO.")