pabx-app/asterisk/var_lib_asterisk/scripts/ami/amid.php

#!/usr/bin/php -q
<?php
/* * *****************************************************************************************
 * Data: 17/04/2019.
 * Autor: Amarildo Pereira
 * Descrição: Monitoramento dos eventos gerados na central.
 * Objetivo: Prover dados para para monitoramento em tempo real, para aplicações como supervi-
 * sor, agente, diacador etc.
 * Funcoes:
 * -sGravaLog  -> Grava log de erros gerados pelo serviço.
 * ***************************************************************************************** */
error_reporting(E_ALL);
ini_set('display_errors', 1);
ini_set("memory_limit", "512M");
//define("TEMPO_CICLO", 10000000);
define("TEMPO_CICLO", 30000000);

/*
 * Inclui funçoes genéricas.
 */
include("util/constantes.php");
include("util/util.php");
include("util/funcoesAmi.php");

/*
 * Registra o numero de erros em uma operacao.
 */
$numErros = 0;

/*
 * Para rodar como um processo normal é preciso passar "N" como primeiro parametro.
 */
$notDaemon = true; // isset($argv[1]) && ( strtoupper($argv[1]) === 'N');

/*
 * Mostra o help quando passodo --help no primeiro argumento.
 */
GetSupervisorHelp();


/*
 * Inicializa o daemom quando N não for informado.
 */
GetDaemon($notDaemon);

/*
 *  Handler de conexão com o servidor manager.
 */
$socket = null;

$paramAmi = ['host' => '192.168.115.2', 'username' => 'monitor', 'secret' => '@monitorSip9102#'];
//$paramAmi = [];

try {
    declare(ticks = 1);
    $statusSignal = 0;
    pcntl_signal(SIGTERM, "sig_handler");
    pcntl_signal(SIGHUP, "sig_handler");
    pcntl_signal(SIGUSR1, "sig_handler");
    pcntl_signal(SIGINT, "sig_handler");

    sGravaLog(sprintf("Server Start: %s [ok]\n", date("Y-m-d H:i:s")));
    /*
     * Inicia uma conexao com o manager.
     */
    if (AmiConnect($paramAmi)) {
        AmiIniciaMonitor();
    }


    $start = 0;
    while (true) {
        try {
            /*
             * Monitora se houve desconexao, e reconecta-se se necessario.
             */
            AmiReConnect($paramAmi);

            /*
             * Analisa o fluxo de mensagens do manager.
             */
            AmiAnalise();
        } catch (Exception $ex) {
            $numErros++;
            socket_close($socket);
            $socket = null;

            sGravaLog($ex->getMessage());
        }
        /*
         * Verifica se o processo deve ser encerrado
         */
        if (sig_status())
            break;
        /*
         * Tempo do ciclo de atualizações.
         */
        usleep(TEMPO_CICLO);
        $start++;
    }


    sGravaLog(sprintf("Server Stop: %s [ok]\n", date("Y-m-d H:i:s")));
} catch (Exception $ex) {
    sGravaLog($ex->getMessage());
}

function AmiProcessaBloco($bloco) {

    print_r($bloco);
}

function AmiConnect($amiParams = []) {
    global $socket;
    $prc = array('host' => '127.0.0.1', 'port' => '5038', 'username' => 'manager', 'secret' => 'manager007', 'events' => 1);

    /*
     * Sobrescreve os parametros default pelos recebidos no array $amiParams, ex.: ['port' => '5039'] ira substituir
     * a porta padrao.
     */
    foreach ($amiParams as $key => $value) {
        $prc[$key] = $value;
    }

    if (!$socket = socket_create(AF_INET, SOCK_STREAM, 0)) {
        RaiseExcept("Não foi possível criar  um objeto de conexão!");
    }

    if (!socket_connect($socket, $prc['host'], $prc['port'])) {
        RaiseExcept("Nao foi possivel conectar-se ao servidor!", false);
    }

    AmiExec($socket, AmiLoginAgt($prc['username'], $prc['secret'], $prc['events']));
    do {
        $buffer = socket_read($socket, 1024, PHP_NORMAL_READ);
        if (stristr($buffer, "Authentication accepted")) {
            return true;
        } else if (stristr($buffer, "Authentication failed")) {
            RaiseExcept("Nao foi possivel autenticar-se ao servidor manager!", false);
        } else if (stristr($buffer, "Response: error")) {
            RaiseExcept("Erro na autenticação do usuario!", false);
        }
    } while (true);
}

function AmiExec($socket, $cmd) {

    if (!array_key_iexists('ActionID', $cmd)) {
        $cmd['ActionID'] = rand(000000000, 9999999999);
    }
    foreach ($cmd as $key => $value) {
        $message = sprintf("%s: %s\n", $key, $value);
        if (!socket_write($socket, $message, strlen($message))) {
            RaiseExcept("Erro de comunicação com o servidor!", true);
        }
    }

    $message = "\n\n";
    if (!socket_write($socket, $message, strlen($message))) {
        RaiseExcept("Erro de comunicação com o servidor!", true);
    }
}

function AmiReConnect($amiParams = []) {
    global $socket;
    if (!$socket) {
        AmiConnect($amiParams);
    }
}

function AmiAnalise() {
    global $socket;
    $numErros = 0;
    /*
     * Indica que o blocos comecaram a ser lidos.
     */
    $start = false;

    /*
     * Armazena os blocos de codigo retornados pelo mananger.
     */
    $bloco = array();

    do {
        $buffer = socket_read($socket, 1024, PHP_NORMAL_READ);

        if (trim($buffer) !== '') {
            list($key, $value) = explode(":", $buffer);
            $bloco[$key] = $value;
            $start = true;
        }
        //echo sprintf("Ciclo: %s Cmd: [%s]  Chr: %s - %s \n", ++$i, trim(str_replace(array("\n", "\r"), '', $buffer)), ord($buffer[0]), ord($buffer[1]));
        $ch = ord($buffer);
        if (($ch == 13) && $start) {
            AmiProcessaBloco($bloco);
            $bloco = array();
            if (sig_status()) {
                break;
            }
        }

        if (stristr($buffer, "Response: error")) {
            if (++$numErros > 3) {
                RaiseExcept("Erro ao ler socket!", false);
            }
        }
    } while (true);
}

function AmiLoginAgt($username, $secret, $events) {
    return array("action" => "login", "username" => $username, "secret" => $secret, "events" => ($events ? "on" : "off"));
}

function sGravaLog($log) {

    /*
     * Log do sistema
     */
    $patLog = "/var/log/asterisk/amid.log";

    /*
     * Registra no arquivo de log do sistema.
     */
    WriteLog(trim($log) . "\n", $patLog);
}

function GetDaemon($notDaemon) {
    /*
     * Se o script não for chamado com daemon sai sem executar nada.
     */
    if ($notDaemon) {
        return 0;
    }

    $pid = pcntl_fork();
    if ($pid) {
        exit(0); //success
    }

    //  posix_setsid();
}

function GetSupervisorHelp() {
    global $argc, $argv;

    $arg = isset($argv[1]) ? $argv[1] : '';

    if ($argc && ((stripos($arg, '--h') !== false) || (stripos($arg, '-h') !== false) || (stripos($arg, '/h') !== false))) {
        return displayUsage();
    }
}

function AmiIniciaMonitor() {
    CarregaRamais();
    CarregaTroncos();
    CarregaFilas();
}

function displayUsage() {
    echo "-------------------------------------------------------------------------------------------------------\n";
    echo "-                         Servico de sincronizacao de dados em tempo real!                        -\n";
    echo "-------------------------------------------------------------------------------------------------------\n";
    echo "- Para rodar como um processo normal passe \"N\" como primeiro argumento:\"./amid.php N\"!         -\n";
    echo "- Para rodar como Daemon nao passe nenhum argumemento argumento:\"./amid.php \"!                 -\n";
    echo "-------------------------------------------------------------------------------------------------------\n";
    echo "\n";
    exit(0);
}

function sig_handler($signo) {
    global $statusSignal;
    $statusSignal = 1;
}

function sig_status() {
    global $statusSignal;
    pcntl_signal_dispatch();
    return $statusSignal;
}
?>