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"
Example #3
0
 def executa_scanner_sonar(self):
     LinhaDeComando.executar(SONNAR_SCANNER)
     Log.imprime("SUCESSO NA EXECUCAO DO SONAR",
                 "SUCESSO NA EXECUCAO DO SONAR")
Example #4
0
 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.")
Example #5
0
 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.")
Example #6
0
 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.")
Example #7
0
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 +
# 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)
    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 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)
Example #11
0
 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)
Example #12
0
 def teste_executar_comando_com_exit_code_com_erro(self):
     comando = "ech"
     valor_obtido = LinhaDeComando.executar(comando, retornar_exit_code=True)
     self.assertNotEqual(valor_obtido, 0)
Example #13
0
 def teste_executar_comando_sem_exit_code_com_erro(self):
     comando = "ech"
     with self.assertRaises(SystemExit) as ex:
         LinhaDeComando.executar(comando)
     self.assertNotEqual(ex.exception.code, 0)
 def executa_testes(self):
     # Metodo que roda os testes do Gradle
     Log.imprime("INICIANDO TESTES DO GRADLE", "INICIANDO TESTES DO GRADLE")
     LinhaDeComando.executar("gradle testClasses")
     Log.imprime("TESTES ENCERRADOS COM SUCESSO",
                 "TESTES ENCERRADOS COM SUCESSO")