xNightR00T File Manager

<?php

namespace Logs\Controller;

use Zend\Http\Headers;
use ZendServer\Edition;
use ZendServer\FS\FS;
use Logs\LogReader,
    WebAPI\Exception,
    Audit\Db\ProgressMapper,
    Audit\Db\Mapper,
    Application\Module,
    ZendServer\Mvc\Controller\WebAPIActionController,
    ZendServer\Set,
    Zend\Mvc\Controller\ActionController,
    Zend\Json\Json,
    ZendServer\Log\Log;
use Zend\Http\Response\Stream;

class WebAPIController extends WebAPIActionController
{

    /**
     *  Retrieve the entire log file from the server or a remove cluster member
     *
     * @api
     * @method GET
     * @section Configuration and Management
     * @param integer serverId - default 0
     * @param integer linesToRead - default 200
     * @param string filter - default ''
     * @param string logName - default ''
     * @response "responseData": {
     * 'logContent'
      }
     */
    public function logsGetLogfileAction()
    {
        try {
            $this->isMethodGet();
            $params   = $this->getParameters(array('serverId' => 0, 'linesToRead' => Module::config('logReader',
                    'defaultLineChunk'), 'filter' => ''));
            $this->validateMandatoryParameters($params, array('logName'));
            $logName  = $this->validateStringNonEmpty($params['logName'], 'logName');
            $serverId = $this->validateInteger($params['serverId'], 'serverId');
        } catch (\Exception $e) {
            $this->handleException($e, 'Input validation failed');
        }

        $guiTemp = FS::getGuiTempDir();
        $edition = new Edition();
        if ($this->isRemoteServer($serverId)) {
            $paramsToRemote = $params->toArray();
            unset($paramsToRemote['serverId']);
            try {
                $response = $this->execWebAPIRequestOnClusterMember($serverId, $this->getCmdName(), true,
                    $paramsToRemote);
            } catch (\Exception $e) {
                Log::err("Log Reading Failed from Remote serverId '$serverId': ".$e->getMessage());
                Log::debug($e);
                throw new Exception(_t('Log Reading Failed from Remote serverId %s: %s',
                    array($serverId, $e->getMessage())), Exception::INTERNAL_SERVER_ERROR, $e);
            }

            $contentDisposition = $response->getHeaders()->get('Content-Disposition'); /* @var $contentDisposition \Zend\Http\Header\ContentDisposition */
            if (0 < preg_match('#;\s*filename\s*=\s*"?(?P<filename>[^"]+)"?$#', $contentDisposition->getFieldValue(),
                    $matches)) {
                $zipPath = FS::createPath($guiTemp, $matches['filename'].'-'.uniqid().'.zip');
            } else {
                $zipPath = FS::createPath($guiTemp, 'log-'.uniqid().'.zip');
            }
            $zipFile     = FS::getFileObject($zipPath, 'w');
            $zipFile->fwrite($response->getBody());
            $logFilename = basename($zipPath);
        } else {
            try {
                $logReader = $this->getLocator('Logs\LogReader'); /* @var $logReader \Logs\LogReader */
                $logFile   = $logReader->getFileObj($logName);
            } catch (\Exception $e) {
                Log::err("Log Reading Failed: ".$e->getMessage());
                throw new Exception(_t('Log Reading Failed: %s', array($e->getMessage())),
                Exception::LOG_FILE_NOT_READABLE);
            }

            $logRealFilename = $logFile->getFilename();
            $logFilename     = $logRealFilename.'-'.uniqid().'.zip';
            $zip             = new \ZipArchive();
            $zipPath         = FS::createPath($guiTemp, $logFilename);
            $zip->open($zipPath, \ZipArchive::CREATE);
            $zip->addFile($logFile->getPathname(), $logRealFilename);
            $zip->close();
        }


        $package = FS::getFileObject($zipPath);

        $response       = new Stream();
        $response->setStream(fopen($package->getPathname(), 'r'));
        $response->setStreamName($logFilename);
        $response->setStatusCode(200);
        $response->setContentLength($package->getSize());
        $this->response = $response;

        $this->getEvent()->setParam('do-not-compress', true);

        $headers = new Headers();
        $headers->addHeaderLine('Content-Disposition', "attachment; filename=\"{$logFilename}\"");
        $headers->addHeaderLine('Content-type', "application/zip");
        $headers->addHeaderLine('Content-Length', $package->getSize());
        $response->setHeaders($headers);
        return $response;
    }

    /**
     * Read a certain number of log lines from the end of the file log. If
     * serverId is passed, then the request will be performed against that
     * cluster member, otherwise it is performed locally.
     *
     * @param String logName Required. One of the following values: codetracing, datacache, deployment,
     *    dserver, jobqueue, jqd, monitor, monitor_node, monitor_ui, pagecache,
     *    php, sc, scd, statistics, utils, zdd, zem, zsd, php
     * @param Integer serverId Optional. If passed, the log contents will be fetched from that cluster member,
     *    otherwise performed locally.
     * @param Integer linesToRead Optional. How many lines to read. defaults to a certain system-wide
     *    configurable setting. Limited by another such setting.
     * @param String filter Optional. Apply a certain case-insensitive string filter to the log lines.
     * @response {
     * "logFileMetaData": {
     * "lineNumber": 189022,
     * "fileSize": 18972947,
     * "lastModified": "2018-06-07T14:25:19+03:00",
     * "lastModifiedTimestamp": 1528370719
     * },
     * "logLines": "...line1...\n....line2...."
     * }
     *
     * @return \WebAPI\View\WebApiResponseContainer|\Zend\View\Model\ViewModel|array
     * @throws Exception
     * @api
     * @method GET
     * @version 1.3
     * @section Server and Cluster Management
     * @name logsReadLines
     * @url https://docs.roguewave.com/en/zend/Zend-Server/content/the_logsreadlines_method.htm
     * @permissions Read-Only
     * @editions Zend Server
     */
    public function logsReadLinesAction()
    {
        /* @var \Logs\LogReader $logReader */
        $logReader = $this->getLocator('Logs\LogReader');

        try {
            $this->isMethodGet();
            $params      = $this->getParameters(array('serverId' => 0, 'linesToRead' => Module::config('logReader',
                    'defaultLineChunk'), 'filter' => ''));
            $this->validateMandatoryParameters($params, array('logName'));
            $logMapper   = $this->getLocator('Logs\Db\Mapper'); /* @var $logReader \Logs\Db\Mapper */
            $logName     = $this->validateAllowedValues($params['logName'], 'logName',
                array_keys($logMapper->findAllEnabledLogFiles()));
            $serverId    = $this->validateInteger($params['serverId'], 'serverId');
            $linesToRead = $this->validatePositiveInteger($params['linesToRead'], 'linesToRead');
            $filter      = $this->validateString($params['filter'], 'filter');
            $this->validateMaxInteger($linesToRead, Module::config('logReader', 'maxLineChunk'), 'linesToRead');
        } catch (\Exception $e) {
            $this->handleException($e, 'Input validation failed');
        }

        if ($this->isRemoteServer($serverId)) {
            $paramsToRemote = $params->toArray();
            unset($paramsToRemote['serverId']);
            try {
                $response        = $this->execWebAPIRequestOnClusterMember($serverId, $this->getCmdName(), true,
                    $paramsToRemote);
                $responseDecoded = Json::decode($response->getBody(), Json::TYPE_ARRAY);
                $responseData    = $responseDecoded['responseData'];
            } catch (\Exception $e) {
                Log::err("Log Reading Failed from Remote serverId '$serverId': ".$e->getMessage());
                throw new Exception(_t('Log Reading Failed from Remote serverId %s: %s',
                    array($serverId, $e->getMessage())), Exception::INTERNAL_SERVER_ERROR);
            }

            $result = [
                'logLines' => $responseData['logLines'],
                'lineNumber' => $responseData['logFileMetaData']['lineNumber'],
                'fileSize' => $responseData['logFileMetaData']['fileSize'],
                'lastModified' => strtotime($responseData['logFileMetaData']['lastModified']),
            ];
        }
        else {
            try {
                $result = [
                    'logLines' => $logReader->readLog($logName, $linesToRead, $filter),
                    'lineNumber' => $logReader->getLineNumber(),
                    'fileSize' => $logReader->getFileSize(),
                    'lastModified' => $logReader->getLastModified(),
                ];
            } catch (\Exception $e) {
                Log::err("Log Reading Failed: ({$e->getCode()}) {$e->getMessage()}");
                if (strstr($e->getMessage(), 'No such file or directory')) {
                    $logLines = "Reading $logName.log failed: file not found";
                } else {
                    $logLines = "Reading $logName.log failed: please verify your log file permissions";
                }
                $result = [
                    'logLines' => $logLines,
                    'lineNumber' => 0,
                    'fileSize' => 0,
                    'lastModified' => time(),
                ];
            }
        }

        return $result;
    }

    /**
     *  Get list of log files on the server
     *
     * @api
     * @method GET
     * @section Configuration and Management
     * @response "responseData": {
      "logFiles": [
      "access",
      "codetracing",
      "datacache",
      "deployment",
      "error",
      "jobqueue",
      "jqd",
      "monitor",
      "monitor_node",
      "monitor_ui",
      "pagecache",
      "php",
      "sc",
      "scd",
      "statistics",
      "statsd",
      "url_insight",
      "url_insight_daemon",
      "utils",
      "zdd",
      "zem",
      "zend_server_ui",
      "zray",
      "zs-error",
      "zs_create_databases",
      "zs_maintenance",
      "zsd"
      ]
      }
     */
    public function getLogFilesAction()
    {
        $this->isMethodGet();
        $logMapper = $this->getLocator('Logs\Db\Mapper'); /* @var $logReader \Logs\Db\Mapper */
        $logFiles  = $logMapper->findAllEnabledLogFiles();
        return array('logFiles' => $logFiles);
    }


    public function jsLogsAction()
    {
        $this->isMethodPost();
        $parameters = $this->getRequest()->getPost()->toArray();
        if (isset($parameters['report']['stack']) && !empty($parameters['report']['stack'])) {
            $stack = [];
            foreach ($parameters['report']['stack'] as $key => $error) {
                if($key > 1){
                    continue;
                }else{
                    if(isset($error['context'])){
                        unset($error['context']);
                    }
                    $stack[] = $error;
                }
            }
            $parameters['report']['stack'] = $stack;
        }

        Log::jsNotice(print_r($parameters,true));
        return new \WebAPI\View\WebApiResponseContainer(['result' => true]);
    }

    protected function isRemoteServer($serverId)
    {
        if (!$serverId) return false;

        $edition = new Edition();
        return $serverId != $edition->getServerId();
    }
}