src/Service/JavaService/Server.php line 130

Open in your IDE?
  1. <?php
  3. namespace App\Service\JavaService;
  5. class Server
  6. {
  7.     protected $extension_query    = 'query';
  8.     protected $extension_result   = 'result';
  9.     protected $socket_port  = 0;
  10.     protected $host = null;
  11.     protected $path  = null;
  12.     protected $local_path_files = null;
  13.     protected $remote_path_files = null;
  14.     protected $path_local_query = null;
  15.     protected $path_local_result = null;
  16.     protected $path_remote_query = null;
  17.     protected $path_remote_result = null;
  18.     protected $log = '';
  20.     public function __construct($port, $host, $path, $local_path, $remote_path)
  21.     {
  22.         $this->socket_port        = $port;
  23.         $this->host               = $host;
  24.         $this->path               = $path;
  25.         $this->local_path_files   = $local_path;
  26.         $this->path_local_query   = $local_path.'/files/'.$this->extension_query  .'/';
  27.         $this->path_local_result  = $local_path.'/files/'.$this->extension_result .'/';
  28.         $this->remote_path_files  = $remote_path;
  29.         $this->path_remote_query  = $remote_path.'/files/'.$this->extension_query  .'/';
  30.         $this->path_remote_result = $remote_path.'/files/'.$this->extension_result .'/';
  31.     }
  33.     public function isOnline()
  34.     {
  35.         try {
  36.             $timeout = 5;
  37.             $socket = fsockopen($this->host,$this->socket_port,$errnum,$errstr,$timeout) ;
  38.             
  39.             if(!is_resource($socket)) {
  40.                 return false;
  41.             }
  42.             else {
  43.                 fclose($socket);
  44.                 return true;
  45.             }
  46.         }
  47.         catch(\Exception $e) {
  48.             return false;
  49.         }
  50.     }
  52.     public function getStatus() {
  53.         if ($this->status())
  54.             return 'Online';
  55.         else
  56.             return 'Offline';
  57.     }
  59.     public function status() {
  60.         $command = 'ps -p '.$this->getPID();
  61.         exec($command,$op);
  62.         if (!isset($op[1]))
  63.             return false;
  64.         else
  65.             return true;
  66.     }
  68.     public function getPID() {
  69.         $command = 'cat '.$this->path.'/run/server.pid';
  70.         exec($command,$op);
  71.         if (!isset($op[0]))
  72.             return 0;
  73.         else
  74.             return (int)$op[0];
  75.     }
  77.     public function start() {
  78.         if (!$this->isOnline()) {
  79.             $command = $this->path.'/bin/startup.sh';
  80.             exec($command);
  81.             $this->addLog('Servicio ha iniciado');
  82.             return true;
  83.         } else {
  84.             $this->addLog('Servicio ya iniciado');
  85.             return true;
  86.         }
  87.     }
  89.     public function stop(){
  90.         if($this->getPID() == 0) {
  91.             $this->addLog('Servicio ya esta detenido');
  92.             return false;
  93.         } else {
  94.             $command = $this->path.'/bin/shutdown.sh';
  95.             exec($command);
  96.             if ($this->status() == false) {
  97.                 $this->addLog('Se ha detenido el servicio');
  98.                 return true;
  99.             } else {
  100.                 $this->addLog('ERROR: {Stop} fail! ');
  101.                 return false;
  102.             }
  103.         }
  104.     }
  106.     public function getTailLogFile($lineas = 100)
  107.     {
  108.         try {
  109.             $archivo = $this->path. '/log/server.log';
  110.             $command = 'tail -n '.$lineas.' '.$archivo;
  111.             exec($command,$op);
  112.             return $op;
  113.         }
  114.         catch(\Exception $e) {
  115.             return array('log files esta con errores.', $e->getMessage());
  116.         }
  117.     }
  121.     /**
  122.      * Run and Return file
  123.      *
  124.      * @param string $program
  125.      * @param string $flag
  126.      * @param unknown_type $data
  127.      * @return file
  128.      */
  130.     public function runAndReturnFile($program, $flag = 'flag', $srcData)
  131.     {
  132.         return $this->run($program, $flag, $srcData);
  133.     }
  135.     /**
  136.      * Run and Return Data
  137.      *
  138.      * @param string $program
  139.      * @param string $flag
  140.      * @param unknown_type $data
  141.      * @return string data
  142.      */
  144.     public function runAndReturnData($program, $flag = 'flag', $srcData)
  145.     {
  146.         $file = $this->run($program, $flag, $srcData);
  147.         $data_file = file_get_contents($file);
  149.         return $data_file;
  150.     }
  152.     private function generateIdForFile()
  153.     {
  154.         return  date('dmy_His') . "_" . rand(100,999);
  155.     }
  157.     private function generateLocalFile($data, $flag, $send_file)
  158.     {
  159.         $id      = $this->generateIdForFile();
  160.         $id_file = $id.'_'.$flag;
  162.         $name_file = $id_file.'.'.$this->extension_query;
  164.         if($send_file == true) {
  165.             $file = fopen($this->path_local_query . $name_file,'w');
  166.             $data = mb_convert_encoding($data, "ISO-8859-15", "UTF-8");
  167.             fwrite($file,$data);
  168.             fclose($file);
  169.         }
  170.         return $id_file;
  171.     }
  173.     private function getCommandForSendFile($id_file)
  174.     {
  175.         $cmd  = "copy::send::";
  176.         $cmd .= $this->path_local_query  . $id_file . '.' . $this->extension_query;
  177.         $cmd .= "::";
  178.         $cmd .= $this->path_remote_query . $id_file . '.' . $this->extension_query;
  179.         $cmd .= "\n";
  180.         return $cmd;
  181.     }
  183.     private function getCommandForGetFile($id_file)
  184.     {
  185.         $cmd  = "copy::get::";
  186.         $cmd .= $this->path_remote_result . $id_file . '.' . $this->extension_result;
  187.         $cmd .= "::";
  188.         $cmd .= $this->path_local_result  . $id_file . '.' . $this->extension_result;
  189.         $cmd .= "\n";
  190.         return $cmd;
  191.     }
  193.     private function getCommandForExec($exec)
  194.     {
  195.         $cmd  = "exec::";
  196.         $cmd .= $exec;
  197.         $cmd .= "\n";
  198.         return $cmd;
  199.     }
  201.     private function getCommandForRemoteDelete($id_file)
  202.     {
  203.         $cmd  = "dlte::";
  204.         $cmd .= $id_file;
  205.         $cmd .= "\n";
  206.         return $cmd;
  207.     }
  209.     private function run($program = null, $flag, $srcData = null, $send_file = true, $more_data = null)
  210.     {
  211.         if($program == null) {
  212.             throw new Exception("Server::run() -> Program is null");
  213.         }
  215.         $log = "";
  217.         $id_file = $this->generateLocalFile($srcData, $flag, $send_file);
  219.         $comando1 = $this->getCommandForSendFile($id_file);
  220.         $comando2 = null;
  222.         if($more_data != null) {
  223.             $comando2 = $this->getCommandForExec($this->remote_path_files."/apps/".$program." ".$id_file.",".$more_data . "\n");
  224.         }
  225.         else {
  226.             $comando2 = $this->getCommandForExec($this->remote_path_files."/apps/".$program." ".$id_file."\n");
  227.         }
  229.         $comando3 = $this->getCommandForGetFile($id_file);
  230.         $comando4 = $this->getCommandForRemoteDelete($id_file);
  232.         $timeout = 5;
  234.         $socket = fsockopen($this->host,$this->socket_port,$errnum,$errstr,$timeout) ;
  236.         if(!is_resource($socket)) {
  237.             exit("Connection socket fail:: ".$errnum." ".$errstr) ;
  238.         }
  239.         else {
  240.             if($send_file) {
  241.                 fputs($socket, $comando1) ;
  242.                 while(!feof($socket)) {
  243.                     $linea = fgets($socket, 1024);
  244.                     $log .= $linea;
  245.                     if(trim($linea) == "copy::send::ok") {
  246.                         break;
  247.                     }
  249.                     if(trim($linea) == "msg::fin_socket") {
  250.                         break;
  251.                     }
  252.                 }
  253.             }
  255.             fputs($socket, $comando2);
  256.             while(!feof($socket)){
  257.                 $linea = fgets($socket, 1024);
  258.                 $log .= $linea;
  259.                 if(trim($linea) == "exec::ok") {
  260.                     break;
  261.                 }
  262.                 if(trim($linea) == "msg::fin_socket") {
  263.                     break;
  264.                 }
  265.             }
  267.             fputs($socket, $comando3);
  268.             while(!feof($socket)) {
  269.                 $linea = fgets($socket, 1024);
  270.                 $log .= $linea;
  271.                 if(trim($linea) == "copy::get::ok")
  272.                 {
  273.                     break;
  274.                 }
  275.                 if(trim($linea) == "msg::fin_socket")
  276.                 {
  277.                     break;
  278.                 }
  279.             }
  281.             // fputs($socket, $comando4);
  282.             // while(!feof($socket))
  283.             // {
  284.             //     $linea = fgets($socket, 1024);
  285.             //     $log .= $linea;
  286.             //     if(trim($linea) == "delete::ok")
  287.             //     {
  288.             //         break;
  289.             //     }
  290.             //     if(trim($linea) == "msg::fin_socket")
  291.             //     {
  292.             //         break;
  293.             //     }
  294.             // }
  295.         }
  297.         fclose($socket);
  299.         $this->setLog($log);
  301.         return $this->path_local_result . $id_file. '.' . $this->extension_result;
  302.     }
  304.     public function getLog()
  305.     {
  306.         return $this->log;
  307.     }
  309.     private function setLog($msg)
  310.     {
  311.         global $log;
  312.         $log .= $msg . "\n";
  313.     }
  315.     private function addLog($msg)
  316.     {
  317.         $this->log .= $msg . "\n";
  318.     }
  319. }