#!/usr/bin/php -q
<?php
// *************************************************************************
// *                  Comentário atualiza_central                          *
// *                  Data de criação: 19/03/2019                          *
// *                      Autor: Lucas Awade.                              *
// *                    Equipe: Desenvolvimento.                           *
// *                          Versão: 2.0                                  *
// * ***********************************************************************
// * Este script tem a finalidade de realizar as atualizações de acordo com a
// * central de atualizações composta no banco de dados cadastrado. O script deve
// * ficar em um servidor visivel para que possa ser baixado na central e executado.
// * Todas as informações geradas são transmitidas para a central de atualizações
// * para que tenha o controle de cada status.
// * 
// * Ele deve estar junto com o arquivo atualizacao.sh em uma pasta atualiza
// * compactado em formato tar.gz
// * 
// *************************************************************************

ini_set("memory_limit", "1024M");

// *************************************************************************
// *                       CHAMADAS DO SCRIPT                              *
// *************************************************************************
// *
// * MODO MANUAL -> /var/lib/asterisk/scripts/atualizacao/atualiza/atualiza_central.php DB RELOAD
// * OBS: Os argumentos podem estar em letras minúsculas ou maiúsculas.
// *
// *************************************************************************
// * 
// * MODO AUTOMATICO -> /home/simples/atualiza/atualiza_central.php $1 STEPX &
// * OBS: Esse modo é feito pela atualiza automatica com o atualizacao.sh.
// *
// *************************************************************************
/*
 * Define o tamanho que o disco deve possuir para a instalação da aplicação.
 */
$sizeDisc = 2048; // --> 2 GB

/*
 * HABILITA O SISTEMA DE LOG -> /var/log/asterisk/atualiza_central.log
 */
$gravarLog = 1;

/*
 * ARQUIVO DO INSTALADOR PARA SER BAIXADO NO SERVIDOR REMOTO 
 */
$downInstalador = "http://192.168.115.12/downloads/instalador_simplesip/atualizacao_automatica";

/*
 * ARQUIVO DA BASE PARA SER BAIXADO NO SERVIDOR REMOTO 
 */
$downBase = "http://192.168.115.12/downloads/banco/";

/*
 * DIRETORIO DE LOG's GERADOS
 */
$pathLog = "/home/simples/atualiza_central.log";

/*
 * DIRETORIO DO ARQUIVO PARA INSTALACAO
 */
$pathInstall = "/home/simples/aplicativo-simplesip/";

/*
 * DIRETORIO DO ARQUIVO DE INSTALADOR
 */
$pathAtualiza = "/home/simples/atualiza/";

/*
 * DIRETORIO DE BACKUP
 */
$pathBackup = "/hdaux/backup/";

/*
 * ARQUIVO SQL
 */
$nomeSQL = null;

/*
 * VERSAO PHP DE INSTALACAO
 */
$versaoPHP = '5.6';

/*
 * $argv[1] -> IP DA VPN
 * $argv[2] -> PARTE DA ATUALIZACAO
 */
try {
    /*
     * VERIFICA OS ARQUIVOS DE INCLUDE DO PROJETO
     */
    ___Includes();

    /*
     * ATUALIZAÇÃO DA BASE DE DADOS 
     * $versao[0] -> Versão que vai ser atualizada a aplicação
     * $versao[1] -> Arquitetura do sistema operacional 32 ou 64 bits
     * $versao[2] -> Versão atual da aplicação
     * $versao[3] -> Tamanho do disco
     */
    if (strtoupper($argv[1]) != "DB") {
        if (!$argv[1]) {
            GravarLog('ERRO[8] IP/VPN', 'ERROR');
            throw new Exception('ERRO[8] IP/VPN');
        }

        $connect = ___GetConectPG();
        $versao = GetLastVersao($argv[1]);
        chdir('/home/simples/');
    }

    switch (strtoupper($argv[2])) {
        case 'STEP1':
            GravarLog('Executando STEP 1', 'DEBUG');
            ___Process('stop');
            ___AnalisaDisco($sizeDisc);
            ___GetAtualizaBase(GetVersao(), $versao[0]);
            ___GetDownload("aplicativo-simplesip_v{$versao[0]}.tar.gz");
            break;
        case 'STEP2':
            GravarLog('Executando STEP 2', 'DEBUG');
            ___AnalizaArquivos($pathInstall, $pathBackup, $versao[0]);
            break;
        case 'STEP3':
            GravarLog('Executando STEP 3', 'DEBUG');
            $localcon = ___GetConnectLocal();
            ___Process('start');
            ___GetMontaTabelas($localcon);
            ___Process('restart');
            ___SetAtualizacao($argv[1], 'ATUALIZADA', $versao[0]);
            GravarLog('Fim da instalacao com sucesso!', 'DEBUG', 1);
            break;
        case 'RELOAD':
            GravarLog('Executando RELOAD', 'DEBUG');
            $localcon = ___GetConnectLocal();
            ___GetMontaTabelas($localcon, true, true, true);
            GravarLog("Logs gerados em $pathLog", 'INFO');
            GravarLog('Fim da instalacao.', 'DEBUG', 1);
            break;
        default:
            GravarLog("Problemas nos STEPS", 'ERRO');
    }
    exit();
} catch (Exception $ex) {
    $msg = $ex->getMessage();
    ___SetAtualizacao($argv[1], $msg, null);
    GravarLog('Fim da instalacao com erro!', 'CRITICAL');
    MataProcesso();
}

// *************************************************************************
// *                                                                       *
// *                FUNCOES NECESSARIAS DA ATUALIZACAO                     *
// *                                                                       *
// *************************************************************************

/*
 * VERIFICA SE A VERSÃO ESTÁ ATUALIZADA
 */

function GetLastVersao($ip) {
    global $connect;

    $query = "SELECT sistema_central, versao_central, disco_central,atualizar_versao_central AS versao_atualizacao FROM central_atualizacao WHERE ip_central = '$ip'";
    $result = pg_query($connect, $query);
    $versaoCli = pg_fetch_assoc($result);

    GravarLog('Verificando a versao do sistema para ser instalada.', 'DEBUG');

    if ($versaoCli['versao_central'] == $versaoCli['versao_atualizacao']) {
        GravarLog('A versao do sistema ja possui as configuracao atualizadas.', 'DEBUG');
        throw new Exception('[9] ATUALIZADA');
    }

    $string = explode("|", $versaoCli['sistema_central']);
    $arquitetura = $string[1];

    return array($versaoCli['versao_atualizacao'], $arquitetura, $versaoCli['versao_central'], $versaoCli['disco_central']);
}

function ___AnalisaDisco($sizeDisc) {

    GravarLog('Analizando espaco em disco.', 'DEBUG');

    $disco = exec("df -m / | egrep '/$|/hd2$' | egrep -o '.+G|.+%|.+T|.+M' | sed -e 's/^\/dev.*sda[0-9]//g' | sed -e 's/.*root//g' | awk {'print $3'}");

    /*
     * VERIFICA O ESPACO EM DISCO
     */
    if ($disco <= $sizeDisc) {
        GravarLog("O disco tem menos que $sizeDisc MB.", 'CRITICAL');
        throw new Exception("[2] DISCO CHEIO (MENOR $sizeDisc GB)");
    }

    GravarLog('Leitura do disco', 'OK');
}

/*
 * REALIZA A MANUTENÇÃO DO BANCO DE DADOS REFERENTES AS VESÕES TRATADAS!
 */

function ___GetAtualizaBase($versaoAtual, $versaoNova) {
    global $downBase, $nomeSQL;

    if (!$versaoAtual && !$versaoNova) {
        throw new Exception('[13]Não foi possível identificar versões!');
    }

    $conhost = ___GetConnectLocal();
    $search = array();

    $nomeSQL = "pbx-upd-{$versaoAtual}-{$versaoNova}.sql";
    GravarLog('Iniciando atualizacao da base de dados ', 'DEBUG');

    exec("wget --spider --quiet http://192.168.115.12/downloads/banco/$nomeSQL && echo 'OK' || echo 'FAIL'", $search);
    GravarLog("Status do arquivo SQL no servidor", $search[0]);

    /*
     * VERIFICA SE O ARQUIVO JÁ EXISTE
     */
    if ($search[0] == "OK") {
        /*
         * ESPERA O DOWNLOAD DO ARQUIVO
         */
        while (!file_exists($nomeSQL)) {
            GravarLog('Efetuando Download do arquivo ', 'DEBUG');
            exec("wget " . $downBase . $nomeSQL);
            sleep(2);
        }

        $handle = fopen($nomeSQL, 'rb');
        $contents = fread($handle, filesize($nomeSQL));
        fclose($handle);

        GravarLog('Executando instrucao SQL DIFF da base de dados', 'DEBUG');
        @pg_query($conhost, "BEGIN;");
        @pg_query($conhost, $contents);

        $errorbase = pg_last_error();
        if ($errorbase) {
            pg_query($conhost, "ROLLBACK;");
            GravarLog('[6] ATUALIZAR BASE ' . $errorbase, 'CRITICAL');
            throw new Exception("[6] ATUALIZAR BASE " . $errorbase);
        }

        pg_query($conhost, "COMMIT;");
        GravarLog('SQL DIFF', 'OK');
        unlink($nomeSQL);
        GravarLog('Removendo arquivo SQL DIFF.', 'DEBUG');
    } else {
        GravarLog('Não foi possível encontrar a instrucao SQL DIFF.', 'ERROR');
        throw new Exception('[10] Não foi possível encontrar a instrucao SQL DIFF');
    }
}

function ___GetDownload($arquivo) {
    global $downInstalador;

    if (file_exists($arquivo)) {
        GravarLog('Arquivo ja localizado!', 'DEBUG');
    } else {
        GravarLog('Iniciando download do arquivo...', 'DEBUG');

        /*
         * ESPERA O DOWNLOAD DO ARQUIVO
         */
        while (!file_exists($arquivo)) {
            exec("wget $downInstalador/$arquivo");
            sleep(3);
        }

        GravarLog('Executando o download do arquivo!', 'DEBUG');
    }

    GravarLog('Procurando arquivo de instalacao.', 'DEBUG');

    exec("tar -xzf $arquivo");

    exec("/bin/rm -Rf $arquivo");
}

function ___AnalizaArquivos($pathInstall, $pathBackup, $versao) {

    $dirBackup = $pathBackup . "backup_" . date("Y-m-d") . "_" . rand(0, 99);
    $dirHtml = "/var/www/html/";
    GravarLog('O backup dos arquivos antigos: ' . $dirBackup, 'INFO');

    /*
     * Cria um novo diretorio de backup
     */
    if (!is_dir($pathBackup)) {
        mkdir($pathBackup);
    }

    mkdir($dirBackup);

    /*
     * Diretorios de substituicao
     */
    $diretorios = array(
        "asterisk" => array(
            '/var_lib_asterisk/',
            '/etc_asterisk/',
            '/hdaux_utilitarios_scripts/'
        ),
        "agenda" => array(),
        "aplicativo" => array(),
        "include" => array()
    );

    foreach ($diretorios as $key => $patch) {
        /*
         * Verifica se é um diretorio e se existe
         */
        if (is_dir($pathInstall . $key) && count($patch)) {
            /*
             * Percorre as outras estruturas composta do arquivo 
             */
            foreach ($patch as $subDir) {

                if (is_dir($pathInstall . $key . $subDir)) {
                    /*
                     * Renomeia os arquivos com _ para /
                     */
                    $patchSub = str_replace("_", "/", $subDir);

                    /*
                     * Realiza o backup da pasta do arquivo.
                     */
                    exec("/bin/cp -Rap $patchSub $dirBackup");
                    exec("/bin/rm -Rf $patchSub");
                    mkdir($patchSub);

                    /*
                     * Copia os novos arquivos.
                     */
                    exec("/bin/cp -Rap " . $pathInstall . $key . $subDir . "* $patchSub");
                    sleep(2);
                }
            }
        } else if (is_dir($pathInstall . $key)) {
            /*
             * Realiza o backup da pasta do arquivo.
             */
            exec("/bin/cp -Rap " . $dirHtml . $key . " $dirBackup");
            exec("/bin/rm -Rf " . $dirHtml . $key);

            /*
             * Copia os novos arquivos.
             */
            exec("/bin/cp -Rap " . $pathInstall . $key . " " . $dirHtml);
            sleep(3);
        }
    }
    /*
     * COPIA O BACKUP astdb.sqlite3 
     */
    exec(sprintf("/bin/cp -Rfap %s %s", $dirBackup . "/asterisk/astdb.sqlite3", "/var/lib/asterisk/"));

    /*
     * VERIFICACAO DE ARQUIVOS CRIPTOGRAFADOS
     */
    if ($versao >= '1.7.3') {
        global $versaoPHP;
        $search = array();

        if (!file_exists('/etc/ioncube_loader.so')) {
            //COPIANDO NOVO PHP.INI
            exec(sprintf("/bin/cp -Rfap %s %s", $pathInstall . "include" . "/scriptdb/install/php/php.ini", "/etc/php.ini"));

            //ARQUITETURA DO SERVIDOR
            exec('uname -m', $search);

            $arquitetura = $search[0] == "x86_64" ? "x64" : "x32";

            //COPIANDO ioncube - 
            $patchIoncube = $pathInstall . "include/scriptdb/install/php/encoder/$arquitetura/ioncube_loader_lin_$versaoPHP.so";
            exec(sprintf('/bin/cp -Rap %s %s', $patchIoncube, "/etc/"));

            //renomeando o ioncube.so
            rename("/etc/ioncube_loader_lin_$versaoPHP.so", "/etc/ioncube_loader.so");
            GravarLog('Instalacao do Ioncube', 'OK');
        }
    }

    GravarLog('A copia dos arquivos foram efetuadas', 'DEBUG');
    exec("/bin/rm -Rf $pathInstall");
}

// *************************************************************************
// *                                                                       *
// *                        CONEXOES E SCRIPTS SQL                         *
// *                                                                       *
// *************************************************************************

/*
 * ESCREVE NO BANCO AS INFORMAÇÕES GERADAS PELA ATUALIZAÇÃO
 */

function ___SetAtualizacao($ip, $status, $atualizado = '') {
    global $connect;
    if ($atualizado == GetVersao()) {
        $atualizado = sprintf(", versao_central = '$atualizado', atualizar_versao_central = '', data_atualizacao = '%s'", date('Y-m-d'));
    }

    $query = "UPDATE central_atualizacao SET atualizar_central = 0, status_central = '$status' $atualizado WHERE ip_central = '$ip'";

    pg_query($connect, $query);

    if (pg_last_error()) {
        GravarLog('[12] SQL - ' . pg_last_error(), 'CRITICAL');
        throw new Exception("[12] SQL - " . pg_last_error());
    }
}

/*
 * CONEXÃO COM O BANCO DE DADOS DA CENTRAIS DE ATUALIZAÇÃO
 */

function ___GetConectPG() {
    $dbhost = '192.168.115.12';
    $port = '5432';
    $db = 'atualizacoes';
    $user = 'contacte';
    $passwd = 'ctepgSQL';

    GravarLog("Conectando com o servidor $dbhost.", 'DEBUG');

    $connect = pg_connect("host=$dbhost port=$port dbname=$db user=$user password=$passwd");

    if (pg_last_error()) {
        GravarLog('[5] CONEXÃO ' . pg_last_error(), 'CRITICAL');
        throw new Exception("[5] CONEXÃO C/$dbhost");
    }

    GravarLog("Conexao com o servidor $dbhost", 'OK');

    return $connect;
}

/*
 * CONEXÃO COM O BANCO DE DADOS DA CENTRAIS DE ATUALIZAÇÃO
 */

function ___GetConnectLocal() {

    $localhost = "127.0.0.1";
    GravarLog("Conectando com o servidor $localhost", 'DEBUG');

    //$conlocal = pg_connect("host=$localhost port=5432 dbname=pbx user=contacte password=ctepgSQL");
    $conlocal = pg_connect(GetDefStrDb());

    if (pg_last_error()) {
        GravarLog('[5] CONEXÃO DB - ' . pg_last_error(), 'CRITICAL');
        throw new Exception("[5] CONEXÃO C/$localhost");
    }

    GravarLog("Conexao com o servidor $localhost", 'OK');

    return $conlocal;
}

// *************************************************************************
// *                                                                       *
// *                      GERACAO DE ERROS E LOGS                          *
// *                                                                       *
// *************************************************************************

/*
 * FUNÇÃO PARA GERAR LOGS NA OPERAÇÃO
 */

function GravarLog($log, $type = 'ERROR', $lastLog = null) {
    global $gravarLog, $pathLog;

    if ($gravarLog) {
        $logs = date('d/m/Y H:i:s') . str_pad(" [ $type ]", 15) . $log . "\n";
        file_put_contents($pathLog, $logs, FILE_APPEND);

        if ($lastLog) {
            exec("/bin/mv $pathLog /home/simples/atualiza_central_" . date('Y-m-d_H-i-s') . ".log");
        }
    }
}

/*
 * FUNÇÃO PARA VALIDAR DADOS 
 */

function MataProcesso() {
    global $nomeSQL;

    GravarLog('Executando MataProcesso!', 'DEBUG');
    if (file_exists($nomeSQL)) {
        unlink($nomeSQL);
    }

    ___Process('start');

    $pid = exec("ps aux|grep atualizacao.sh | awk {'print $2'} | head -n1");

    shell_exec("kill -9 $pid");
    GravarLog('Executado MataProcesso!', 'INFO', 1);
}

function ___GetMontaTabelas($conexao, $reload = true, $reloadUra = true, $hdaux = false) {

    GeraKhomp($conexao, 1);
    IncluiAgenteFile($conexao);

    $tabelas = array(
        //   ARQUIVO  RELOAD  DIALPLAN
        array('AGENTS_GENERAL', 'N', 'N'),
        array('ANUNCIOS', 'Y', 'N'),
        array('CALLBACK', 'N', 'N'),
        array('CALLBACK', 'Y', 'N'),
        array('CONTEXTOS', 'N', 'N'),
        array('CONTEXTOS', 'Y', 'N'),
        array('CONFERENCIA', 'Y', 'N'),
        array('DISA', 'Y', 'N'),
        array('DGV', 'Y', 'N'),
        array('FACILIDADES', 'Y', 'N'),
        array('FEATURES_APPLICATION', 'N', 'N'),
        array('FEATURE_FEATUREMAP', 'Y', 'N'),
        array('FEATURE_GENERAL', 'Y', 'N'),
        array('HORARIOS', 'N', 'N'),
        array('HORARIOS', 'Y', 'N'),
        array('IAX_PBX', 'Y', 'N'),
        array('IAX_GENERAL', 'Y', 'N'),
        array('DISA', 'Y', 'N'),
        array('MUSICHOLD_GRUPOS', 'Y', 'N'),
        array('PBX', 'Y', 'N'),
        array('QUEUES_GRUPOS', 'Y', 'N'),
        array('ROTA_ENTRADA', 'Y', 'N'),
        array('ROTAS_SAIDA', 'N', 'N'),
        array('SIP_RAMAIS', 'Y', 'N'),
        array('SIP_GENERAL', 'Y', 'N'),
        array('TESTES', 'Y', 'N'),
        array('URA', 'N', 'N'),
        array('VOICEMAIL', 'Y', 'N'),
        array('URA', 'Y', 'Y')
    );

    foreach ($tabelas as $dados) {
        GravarLog('INICIANDO ' . str_pad($dados[0], 20, ' '), 'DEBUG');

        $idxGeraArq = $dados[0];
        $reload = $dados[1] === 'Y' ? $reload : false;
        $dialPlan = $dados[2] === 'Y' ? $reloadUra : false;

        $modoReload = $dados[1] === 'Y' || $dados[2] === 'Y' ? 'RELOAD ' : 'GERADO ';

        gera_arquivos($conexao, $idxGeraArq, $reload, $dialPlan);
        GravarLog($modoReload . str_pad($dados[0], 20, ' '), 'OK');

        sleep(2);
    }

    if ($hdaux) {
        exec("/hdaux/utilitarios/scripts/permissoes_atualizacao.sh");
    }
    GravarLog('Atualizando permissoes ' . str_pad($dados[0], 20, ' '), 'OK');
    GravarLog('Ajusta_tabelas Finalizado.', 'DEBUG');
}

function ___Process($type) {

    $local = "/etc/init.d/";

    $processos = array(
        "httpd",
        "rc.pbx",
        "supervisor",
        "crond",
        "abrt",
        "cnvrtd"
    );

    foreach ($processos as $processo) {
        // Executa Processo no limbo
        if (file_exists($local . $processo)) {
            exec(sprintf("%s %s >> %s &", $local . $processo, strtolower($type), "/dev/null"));
            GravarLog("service $processo $type", 'DEBUG');
            sleep(3);
        }
    }
}

function ___Includes() {

    $includes = array(
        "/var/www/html/include/util/funcoesAmi.php",
        "/var/www/html/include/util/funcoesApl.php",
        "/var/www/html/aplicativo/admin/funcoes.php",
        "/var/www/html/aplicativo/contacteFunc.php",
        "/var/www/html/include/util/util.php",
        "/var/www/html/include/util/constantes.php"
    );

    foreach ($includes as $inclue) {
        if (file_exists($inclue)) {
            include($inclue);
        } else {
            GravarLog("Não foi encontrado o arquivo para incluir $inclue", 'CRITICAL');
            throw new Exception('Não foi possível incluir ' . $inclue);
        }
    }
}