PHP eZCLI::error方法代码示例

 /**
  * Displays a message on the appropriate output (cli or eZDebug)
  *
  * @param string $msg
  * @param string $logType
  */
 public static function writeMessage($msg, $logType = self::NOTICELOG)
 {
     self::$cli = eZCLI::instance();
     $isWebOutput = self::$cli->isWebOutput();
     switch ($logType) {
         case self::ERRORLOG:
             if (!$isWebOutput) {
                 self::$cli->error($msg);
             } else {
                 eZDebug::writeError($msg, 'SQLIImport');
             }
             break;
         case self::WARNINGLOG:
             if (!$isWebOutput) {
                 self::$cli->warning($msg);
             } else {
                 eZDebug::writeWarning($msg, 'SQLIImport');
             }
             break;
         case self::NOTICELOG:
         default:
             if (!$isWebOutput) {
                 self::$cli->notice($msg);
             } else {
                 eZDebug::writeNotice($msg, 'SQLIImport');
             }
             break;
     }
 }

    /**
     * @param string$question
     * @param array $possibleReplies
     * @param string $callback
     * @param bool $emptyReply
     * @return bool|string
     */
    function askQuestion ( $question, $possibleReplies = array(), $callback = "validateReply", $emptyReply = false )
    {
        $response = false;
        $first = true;

        $this->cli->error( "$question ?" );

        if ($callback != 'validateReplyRegex') 
        {
            $this->showReplies ( $possibleReplies );
        }

        while ( $response === false )
        {
            if ( !$first )
            {
                $this->cli->error( "Incorrect Reply, please retry" );
            }
            else
            {
                $first = false;
            }

            $response = trim(fgets(STDIN));

            if ( $response == '' && $emptyReply )
            {
                $this->cli->notice( "No given reply" );
                return false;
            }

            $response = call_user_func( array ( $this, $callback ), $response, $possibleReplies );
        }

        if ( count($possibleReplies) > 0 && $callback != 'validateReplyRegex' )
        {
            $reply = $possibleReplies[$response];
        }
        else
        {
            $reply = $response;
        }

        $this->cli->notice( "Given reply :  $reply" );

        return $response;
    }

 /**
  * Executes the purge operation
  *
  * @param int|null $iterationLimit Number of trashed objects to treat per iteration, use null to use a default value.
  * @param int|null $sleep Number of seconds to sleep between two iterations, use null to use a default value.
  *
  * @return bool True if the operation succeeded.
  */
 public function run($iterationLimit = 100, $sleep = 1)
 {
     if ($iterationLimit === null) {
         $iterationLimit = 100;
     }
     if ($sleep === null) {
         $sleep = 1;
     }
     if ($this->memoryMonitoring) {
         eZLog::rotateLog($this->logFile);
         $this->cli->output("Logging memory usage to {$this->logFile}");
     }
     $this->cli->output("Purging trash items:");
     $this->monitor("start");
     $db = eZDB::instance();
     // Get user's ID who can remove subtrees. (Admin by default with userID = 14)
     $userCreatorID = eZINI::instance()->variable("UserSettings", "UserCreatorID");
     $user = eZUser::fetch($userCreatorID);
     if (!$user) {
         $this->cli->error("Cannot get user object with userID = '{$userCreatorID}'.\n(See site.ini[UserSettings].UserCreatorID)");
         return false;
     }
     eZUser::setCurrentlyLoggedInUser($user, $userCreatorID);
     $trashCount = eZContentObjectTrashNode::trashListCount(false);
     if (!$this->quiet) {
         $this->cli->output("Found {$trashCount} object(s) in trash.");
     }
     if ($trashCount == 0) {
         return true;
     }
     if ($this->script !== null) {
         $this->script->resetIteration($trashCount);
     }
     while ($trashCount > 0) {
         $this->monitor("iteration start");
         $trashList = eZContentObjectTrashNode::trashList(array('Limit' => $iterationLimit), false);
         $db->begin();
         foreach ($trashList as $trashNode) {
             $object = $trashNode->attribute('object');
             $this->monitor("purge");
             $object->purge();
             if ($this->script !== null) {
                 $this->script->iterate($this->cli, true);
             }
         }
         if (!$db->commit()) {
             $this->cli->output();
             $this->cli->error('Trash has not been emptied, impossible to commit the whole transaction');
             return false;
         }
         $trashCount = eZContentObjectTrashNode::trashListCount(false);
         if ($trashCount > 0) {
             eZContentObject::clearCache();
             if ($sleep > 0) {
                 sleep($sleep);
             }
         }
         $this->monitor("iteration end");
     }
     if (!$this->quiet) {
         $this->cli->output('Trash successfully emptied');
     }
     $this->monitor("end");
     return true;
 }

 private function internalClear($purge, $cacheEntries, $name, $purgeSleep = null, $purgeMax = null, $purgeExpiry = null)
 {
     $this->cli->output(($purge ? 'Purging ' : 'Clearing ') . $this->cli->stylize('emphasize', $name ? $name : 'All cache') . ': ');
     $warnPaths = array();
     foreach ($cacheEntries as $cacheEntry) {
         $absPath = realpath(eZSys::cacheDirectory() . DIRECTORY_SEPARATOR . $cacheEntry['path']);
         $absPathElementCount = count(explode(DIRECTORY_SEPARATOR, rtrim($absPath, DIRECTORY_SEPARATOR)));
         // Refuse to delete root directory ('/' or 'C:\')
         // 2 => since one path element ('/foo') produces two exploded elements
         if ($absPath && $absPathElementCount < 2) {
             $this->cli->error('Refusing to delete root directory! Please check your cache settings. Path: ' . $absPath);
             $this->script->shutdown(1);
             exit;
         }
         // Warn if the cache entry is not function based, and the path is outside ezp root, and the path has less than 2 elements
         if ($absPath && (!$purge || !isset($cacheEntry['purge-function'])) && !isset($cacheEntry['function']) && $absPathElementCount < 3 && strpos(dirname($absPath) . DIRECTORY_SEPARATOR, realpath(eZSys::rootDir()) . DIRECTORY_SEPARATOR) === false) {
             $warnPaths[] = $absPath;
         }
     }
     if (!empty($warnPaths)) {
         $this->cli->warning('The following cache paths are outside of the eZ Publish root directory, and have less than 2 path elements. ' . 'Are you sure you want to ' . ($purge ? 'purge' : 'clear') . ' them?');
         foreach ($warnPaths as $warnPath) {
             $this->cli->output($warnPath);
         }
         if (function_exists("getUserInput")) {
             $input = getUserInput(($purge ? 'Purge' : 'Clear') . '? yes/no:', array('yes', 'no'));
         } else {
             $validInput = false;
             $readlineExists = function_exists("readline");
             while (!$validInput) {
                 if ($readlineExists) {
                     $input = readline($query);
                 } else {
                     echo $prompt . ' ';
                     $input = trim(fgets(STDIN));
                 }
                 if ($acceptValues === false || in_array($input, $acceptValues)) {
                     $validInput = true;
                 }
             }
         }
         if ($input === 'no') {
             $this->script->shutdown();
             exit;
         }
     }
     $firstItem = true;
     foreach ($cacheEntries as $cacheEntry) {
         if ($firstItem) {
             $firstItem = false;
         } else {
             $this->cli->output(', ', false);
         }
         $this->cli->output($this->cli->stylize('emphasize', $cacheEntry['name']), false);
         if ($purge) {
             eZCache::clearItem($cacheEntry, true, array($this, 'reportProgress'), $purgeSleep, $purgeMax, $purgeExpiry);
         } else {
             eZCache::clearItem($cacheEntry);
         }
     }
     $this->cli->output();
 }

/**
 * Fetches and returns a eZContentObjectTreeNode
 *
 * If the node id does not exists an error message is outputted and the script
 * is halted.
 *
 * @param int $topNodeId
 * @param eZCLI $cli
 * @param eZScript $script
 * @return eZContentObjectTreeNode
 **/
function fetchTopNode( $topNodeId, $cli, $script )
{
    $topNode = eZContentObjectTreeNode::fetch( $topNodeId );
    if ( !$topNode )
    {
        $cli->error( "The specified top-node-id ({$topNodeId}) was not valid\n" );
        $script->shutdown( 1 );
    }
    else
    {
        $cli->output( "Will export from node `{$topNode->Name}` ({$topNodeId})\n" );
    }

    return $topNode;
}

/**
 * @param eZCLI $cli
 * @param eZDBInterface $db
 * @param string $cronPart
 * @param int $maxRetries
 * @return int offset to use or -1 if an error occures
 */
function computeOffsetByFork ( $cli, $db, $cronPart, $maxRetries )
{
    // Normal case
    if (!preg_match('#^[a-zA-Z_]+(\d)#', $cronPart, $match))
    {
        return 0;
    }

    $ezfindIni   = eZINI::instance('ezfind.ini');
    $maxForks    = $ezfindIni->variable('IndexOptions', 'MaxPendingForkCount');
    $matchOffset = $match[1] - 1;

    if ( $matchOffset > $maxForks )
    {
        $cli->output( "Ini setting states you can't run more than $maxForks forks, you try to run fork #" . ($matchOffset + 1) );
        return -1;
    }


    $countQuery  = "SELECT count(id) as nb_pending FROM ezpending_actions WHERE action = 'index_object' AND ( param_int IS NULL OR param_int <= $maxRetries )";

    $result = $db->arrayQuery($countQuery);
    if ( !$result || !isset($result[0]['nb_pending']))
    {
        $cli->error("Mysql unexpected error. Script will be stopped.");
        return -1;
    }

    $forkInterval = $ezfindIni->variable('IndexOptions', 'MinPendingForkInterval');
    $pendingCount = $result[0]['nb_pending'];
    $forkMinCount = $matchOffset * $forkInterval;

    if ($pendingCount < $forkMinCount)
    {
        $cli->warning( "Trying to run pending fork #$matchOffset but we have less than $forkMinCount pending objects. Script will be stopped.");

        return -1;
    }

    $offset = max($forkMinCount, round($pendingCount/$maxForks) * $matchOffset);

    $cli->output( "Fork #" . ($matchOffset + 1) . " starting at offset #$offset");

    return $offset;
}