<?php
/**
 * SeekQuarry/Yioop --
 * Open Source Pure PHP Search Engine, Crawler, and Indexer
 *
 * Copyright (C) 2009 - 2026  Chris Pollett chris@pollett.org
 *
 * LICENSE:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * END LICENSE
 *
 * @author Chris Pollett chris@pollett.org
 * @license https://www.gnu.org/licenses/ GPL3
 * @link https://www.seekquarry.com/
 * @copyright 2009 - 2026
 * @filesource
 */
namespace seekquarry\yioop\models;

use seekquarry\yioop\controllers\SearchController;
use seekquarry\yioop\configs as C;
use seekquarry\yioop\library as L;
use seekquarry\yioop\library\CrawlConstants;
use seekquarry\yioop\library\CrawlDaemon;
use seekquarry\yioop\library\FetchUrl;
use seekquarry\yioop\library\IndexArchiveBundle;
use seekquarry\yioop\library\IndexDocumentBundle;
use seekquarry\yioop\library\IndexManager;
use seekquarry\yioop\library\MessagesBundle;
use seekquarry\yioop\library\UrlParser;

/** used to prevent cache page requests from being logged*/
if (!C\nsdefined("POST_PROCESSING") && !empty($_SERVER["NO_LOGGING"])) {
    $_SERVER["NO_LOGGING"] = true;
}
/**
 * This is class is used to handle getting/setting crawl parameters, CRUD
 * operations on current crawls, start, stop, status of crawls,
 * getting cache files out of crawls, determining
 * what is the default index to be used, marshalling/unmarshalling crawl mixes,
 * and handling data from suggest-a-url forms
 *
 * @author Chris Pollett
 */
class CrawlModel extends ParallelModel
{
    /**
     * Used to map between search crawl mix form variables and database columns
     * @var array
     */
    public $search_table_column_map = ["name"=>"NAME", "owner_id"=>"OWNER_ID"];
    /**
     * File to be used to store suggest-a-url form data
     * @var string
     */
    public $suggest_url_file;
    /**
     * {@inheritDoc}
     *
     * @param string $db_name the name of the database for the search engine
     * @param bool $connect whether to connect to the database by default
     *     after making the datasource class
     */
    public function __construct($db_name = C\DB_NAME, $connect = true)
    {
        $this->suggest_url_file = C\DATA_DIR . "/suggest_url.txt";
        parent::__construct($db_name, $connect);
    }
    /**
     * {@inheritDoc}
     *
     * @param mixed $args any additional arguments which should be used to
     *     determine these tables (in this case none)
     * @return string a comma separated list of tables suitable for a SQL
     *     query
     */
    public function fromCallback($args = null)
    {
        return "CRAWL_MIXES";
    }
    /**
     * {@inheritDoc}
     *
     * @param array $row row as retrieved from database query
     * @param mixed $args additional arguments that might be used by this
     *      callback. In this case, should be a boolean flag that says whether
     *      or not to add information about the components of the crawl mix
     * @return array $row after callback manipulation
     */
    public function rowCallback($row, $args)
    {
        if ($args) {
            $mix = $this->getCrawlMix($row['TIMESTAMP'], true);
            $row['FRAGMENTS'] = $mix['FRAGMENTS'];
        }
        return $row;
    }
    /**
     * Gets the name (aka timestamp) of the current index archive to be used to
     * handle search queries
     *
     * @return string the timestamp of the archive
     */
    public function getCurrentIndexDatabaseName()
    {
        $db = $this->db;
        $sql = "SELECT CRAWL_TIME FROM CURRENT_WEB_INDEX";
        $result = $db->execute($sql);
        $row =  $db->fetchArray($result);
        return $row['CRAWL_TIME'] ?? false;
    }
    /**
     * Sets the IndexArchive that will be used for search results
     *
     * @param $timestamp  the timestamp of the index archive. The timestamp is
     *      when the crawl was started. Currently, the timestamp appears as
     *      substring of the index archives directory name
     */
    public function setCurrentIndexDatabaseName($timestamp)
    {
        $db = $this->db;
        $db->execute("DELETE FROM CURRENT_WEB_INDEX");
        $sql = "INSERT INTO CURRENT_WEB_INDEX VALUES ( ? )";
        $db->execute($sql, [$timestamp]);
    }
    /**
     * Returns all the files in $dir or its subdirectories with modified times
     * more recent than timestamp. The file which have
     * in their path or name a string in the $excludes array will be exclude
     *
     * @param string $dir a directory to traverse
     * @param int $timestamp used to check modified times against
     * @param array $excludes an array of path substrings tot exclude
     * @return array of file structs consisting of name, modified time and
     *     size.
     */
    public function getDeltaFileInfo($dir, $timestamp, $excludes)
    {
        $dir_path_len = strlen($dir) + 1;
        $files = $this->db->fileInfoRecursive($dir, true);
        $names = [];
        $results = [];
        foreach ($files as $file) {
            $file["name"] = substr($file["name"], $dir_path_len);
            if ($file["modified"] > $timestamp && $file["name"] != "") {
                $flag = true;
                foreach ($excludes as $exclude) {
                    if (stristr($file["name"], $exclude)) {
                        $flag = false;
                        break;
                    }
                }
                if ($flag) {
                    $results[$file["name"]] = $file;
                }
            }
        }
        $results = array_values($results);
        return $results;
    }
    /**
     * Gets a list of all mixes of available crawls
     *
     * @param int $user_id user that we are getting a list of mixes for
     *      We have disabled mix sharing so for now this is all mixes
     * @param bool $with_components if false then don't load the factors
     *     that make up the crawl mix, just load the name of the mixes
     *     and their timestamps; otherwise, if true loads everything
     * @return array list of available crawls
     */
    public function getMixList($user_id, $with_components = false)
    {
        $sql = "SELECT TIMESTAMP, NAME FROM CRAWL_MIXES ";
        /* to add back user_id for mix handling use: WHERE OWNER_ID = ?
           then change the $result command to:
           $result = $this->db->execute($sql, [$user_id]);
        */
        if (intval($user_id) != $user_id) {
            return false; //keep postgres error log cleaner by doing check
        }
        $result = $this->db->execute($sql);
        $rows = [];
        while ($row = $this->db->fetchArray($result)) {
            if ($with_components) {
                $mix = $this->getCrawlMix($row['TIMESTAMP'], true);
                $row['FRAGMENTS'] = $mix['FRAGMENTS'];
            }
            $rows[] = $row;
        }
        return $rows;
    }
    /**
     * Retrieves the weighting component of the requested crawl mix
     *
     * @param string $timestamp of the requested crawl mix
     * @param bool $just_components says whether to find the mix name or
     *     just the components array.
     * @return array the crawls and their weights that make up the
     *     requested crawl mix.
     */
    public function getCrawlMix($timestamp, $just_components = false)
    {
        $db = $this->db;
        if (!$just_components) {
            $sql = "SELECT TIMESTAMP, NAME, OWNER_ID, PARENT FROM CRAWL_MIXES ".
                "WHERE TIMESTAMP = ?";
            $result = $db->execute($sql, [$timestamp]);
            $mix =  $db->fetchArray($result);
        }
        $mix = (empty($mix)) ? [] : $mix;
        $sql = "SELECT FRAGMENT_ID, RESULT_BOUND".
            " FROM MIX_FRAGMENTS WHERE ".
            " TIMESTAMP = ?";
        $result = $db->execute($sql, [$timestamp]);
        $mix['FRAGMENTS'] = [];
        while ($row = $db->fetchArray($result)) {
            $mix['FRAGMENTS'][$row['FRAGMENT_ID']]['RESULT_BOUND'] =
                $row['RESULT_BOUND'];
        }
        $sql = "SELECT CRAWL_TIMESTAMP, WEIGHT, DIRECTION, KEYWORDS ".
            " FROM MIX_COMPONENTS WHERE ".
            " TIMESTAMP=:timestamp AND FRAGMENT_ID=:fragment_id";
        $params = [":timestamp" => $timestamp];
        foreach ($mix['FRAGMENTS'] as $fragment_id => $data) {
            $params[":fragment_id"] = $fragment_id;
            $result = $db->execute($sql, $params);
            $mix['COMPONENTS'] = [];
            $count = 0;
            if ($result) {
                while ($row =  $db->fetchArray($result)) {
                    $mix['FRAGMENTS'][$fragment_id]['COMPONENTS'][$count] =$row;
                    $count++;
                }
            } else {
                break;
            }
        }
        return $mix;
    }
    /**
     * Returns the timestamp associated with a mix name;
     *
     * @param string $mix_name name to lookup
     * @return mixed timestamp associated with name if exists false otherwise
     */
    public function getCrawlMixTimestamp($mix_name)
    {
        $db = $this->db;
        $sql = "SELECT TIMESTAMP, NAME FROM CRAWL_MIXES WHERE ".
            " NAME= ?";
        $result = $db->execute($sql, [$mix_name]);
        $mix =  $db->fetchArray($result);
        if (isset($mix["TIMESTAMP"])) {
            return $mix["TIMESTAMP"];
        }
        return false;
    }
    /**
     * Returns whether the supplied timestamp corresponds to a crawl mix
     *
     * @param string $timestamp of the requested crawl mix
     *
     * @return bool true if it does; false otherwise
     */
    public function isCrawlMix($timestamp)
    {
        if (empty($timestamp)) {
            return false;
        }
        $db = $this->db;
        $sql = "SELECT TIMESTAMP, NAME FROM CRAWL_MIXES WHERE ".
            " TIMESTAMP = ?";
        $result = $db->execute($sql, [$timestamp]);
        if ($result) {
            if ($mix = $db->fetchArray($result)) {
                return true;
            } else {
                return false;
            }
        }
    }
    /**
     * Returns whether there is a mix with the given $timestamp that $user_id
     * owns. Currently mmix ownership is ignored and this is set to always
     * return true;
     *
     * @param string $timestamp to see if exists
     * @param string $user_id id of would be owner
     *
     * @return bool true if owner; false otherwise
     */
    public function isMixOwner($timestamp, $user_id)
    {
        return true;
        $db = $this->db;
        $sql = "SELECT TIMESTAMP, NAME FROM CRAWL_MIXES WHERE ".
            " TIMESTAMP = ? and OWNER_ID = ?";
        if (intval($user_id) != $user_id) {
            return false;
        }
        $result = $db->execute($sql, [$timestamp, $user_id]);
        if ($result) {
            if ($mix = $db->fetchArray($result)) {
                return true;
            } else {
                return false;
            }
        }
    }
    /**
     * Stores in DB the supplied crawl mix object
     *
     * @param array $mix an associative array representing the crawl mix object
     */
    public function setCrawlMix($mix)
    {
        $db = $this->db;
        //although maybe slower, we first get rid of any old data
        $timestamp = $mix['TIMESTAMP'];
        $this->deleteCrawlMix($timestamp);
        //next we store the new data
        $sql = "INSERT INTO CRAWL_MIXES VALUES (?, ?, ?, ?)";
        $db->execute($sql, [$timestamp, $mix['NAME'], $mix['OWNER_ID'],
            $mix['PARENT']]);
        $fid = 0;
        foreach ($mix['FRAGMENTS'] as $fragment_id => $fragment_data) {
            $sql = "INSERT INTO MIX_FRAGMENTS VALUES (?, ?, ?)";
            $db->execute($sql, [$timestamp, $fid,
                $fragment_data['RESULT_BOUND']]);
            foreach ($fragment_data['COMPONENTS'] as $component) {
                $sql = "INSERT INTO MIX_COMPONENTS(TIMESTAMP,
                    FRAGMENT_ID, CRAWL_TIMESTAMP, WEIGHT, DIRECTION, KEYWORDS)
                    VALUES (?, ?, ?, ?, ?, ?)";
                $db->execute($sql, [$timestamp, $fid,
                    $component['CRAWL_TIMESTAMP'], $component['WEIGHT'],
                    $component['DIRECTION'], $component['KEYWORDS']]);
            }
            $fid++;
        }
    }
    /**
     * Deletes from the DB the crawl mix ans its associated components and
     * fragments
     *
     * @param int $timestamp of the mix to delete
     */
    public function deleteCrawlMix($timestamp)
    {
        $sql = "DELETE FROM CRAWL_MIXES WHERE TIMESTAMP=?";
        $this->db->execute($sql, [$timestamp]);
        $sql = "DELETE FROM MIX_FRAGMENTS WHERE TIMESTAMP=?";
        $this->db->execute($sql, [$timestamp]);
        $sql = "DELETE FROM MIX_COMPONENTS WHERE TIMESTAMP=?";
        $this->db->execute($sql, [$timestamp]);
    }
    /**
     * Deletes the archive iterator and savepoint files created during the
     * process of iterating through a crawl mix.
     *
     * @param int $timestamp The timestamp of the crawl mix
     */
    public function deleteCrawlMixIteratorState($timestamp)
    {
        L\setLocaleObject(L\getLocaleTag());
        $search_controller = new SearchController();
        $search_controller->clearQuerySavepoint($timestamp);

        $archive_dir = C\SCHEDULES_DIR . "/".
            self::name_archive_iterator . $timestamp;
        if (file_exists($archive_dir)) {
            $this->db->unlinkRecursive($archive_dir);
        }
    }
    /**
     * Returns the initial sites that a new crawl will start with along with
     * crawl parameters such as crawl order, allowed and disallowed crawl sites
     * @param bool $use_default whether or not to use the Yioop! default
     *     crawl.ini file rather than the one created by the user.
     * @return array  the first sites to crawl during the next crawl
     *     restrict_by_url, allowed, disallowed_sites
     */
    public function getSeedInfo($use_default = false)
    {
        if (file_exists(C\WORK_DIRECTORY . "/crawl.ini") && !$use_default) {
            $info = L\parse_ini_with_fallback(C\WORK_DIRECTORY . "/crawl.ini");
        } else {
            $info = L\parse_ini_with_fallback(
                C\BASE_DIR . "/configs/default_crawl.ini");
        }
        return $info;
    }
    /**
     * Writes a crawl.ini file with the provided data to the user's
     * WORK_DIRECTORY
     *
     * @param array $info an array containing information about the crawl
     */
    public function setSeedInfo($info)
    {
        if (!isset($info['general']['crawl_index'])) {
            $info['general']['crawl_index']='12345678';
        }
        if (!isset($info['general']['channel'])) {
            $info['general']['channel']='0';
        }
        if (!isset($info["general"]["arc_dir"])) {
            $info["general"]["arc_dir"] = "";
        }
        if (!isset($info["general"]["arc_type"])) {
            $info["general"]["arc_type"] = "";
        }
        if (!isset($info["general"]["cache_pages"])) {
            $info["general"]["cache_pages"] = true;
        }
        if (!isset($info["general"]["summarizer_option"])) {
            $info["general"]["summarizer_option"] = "";
        }
        $n = [];
        $n[] = <<<EOT
; ***** BEGIN LICENSE BLOCK *****
;  SeekQuarry/Yioop Open Source Pure PHP Search Engine, Crawler, and Indexer
;  Copyright (C) 2009 - 2026  Chris Pollett chris@pollett.org
;
;  This program is free software: you can redistribute it and/or modify
;  it under the terms of the GNU General Public License as published by
;  the Free Software Foundation, either version 3 of the License, or
;  (at your option) any later version.
;
;  This program is distributed in the hope that it will be useful,
;  but WITHOUT ANY WARRANTY; without even the implied warranty of
;  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;  GNU General Public License for more details.
;
;  You should have received a copy of the GNU General Public License
;  along with this program.  If not, see <https://www.gnu.org/licenses/>.
;  ***** END LICENSE BLOCK *****
;
; crawl.ini
;
; Crawl configuration file
;
EOT;
        $info['general']['page_range_request'] ??= C\PAGE_RANGE_REQUEST;
        $info['general']['max_depth'] ??= -1;
        $info['general']['repeat_type'] ??= -1;
        $info['general']['sleep_start'] ??= "00:00";
        if (!isset($info['general']['sleep_duration'])) {
            $info['general']['sleep_start'] = -1;
        }
        $info['general']['robots_txt'] ??= C\ALWAYS_FOLLOW_ROBOTS;
        $info['general']['page_recrawl_frequency'] ??= C\PAGE_RECRAWL_FREQUENCY;
        $info['general']['max_description_len'] ??= C\MAX_DESCRIPTION_LEN;
        $info['general']['max_links_to_extract'] ??= C\MAX_LINKS_TO_EXTRACT;
        $n[] = '[general]';
        $n[] = "crawl_order = '" . $info['general']['crawl_order'] . "';";
        $n[] = "summarizer_option = '" .
            $info['general']['summarizer_option'] . "';";
        $n[] = "crawl_type = '" . $info['general']['crawl_type'] . "';";
        $n[] = "max_depth = '" . $info['general']['max_depth'] . "';";
        $n[] = "repeat_type = '" . $info['general']['repeat_type'] . "';";
        $n[] = "sleep_start = '" . $info['general']['sleep_start'] . "';";
        $n[] = "sleep_duration = '" . $info['general']['sleep_duration'] . "';";
        $n[] = "robots_txt = '" . $info['general']['robots_txt'] . "';";
        $n[] = "crawl_index = '" . $info['general']['crawl_index'] . "';";
        $n[] = "channel = '" . $info['general']['channel'] . "';";
        $n[] = 'arc_dir = "' . $info["general"]["arc_dir"] . '";';
        $n[] = 'arc_type = "' . $info["general"]["arc_type"] . '";';
        $n[] = "page_recrawl_frequency = '".
            $info['general']['page_recrawl_frequency']."';";
        $n[] = "page_range_request = '".
            $info['general']['page_range_request']."';";
        $n[] = "max_description_len = '".
            $info['general']['max_description_len']."';";
        $n[] = "max_links_to_extract = '".
            $info['general']['max_links_to_extract']."';";
        $bool_string =
            ($info['general']['cache_pages']) ? "true" : "false";
        $n[] = "cache_pages = $bool_string;";
        $bool_string =
            ($info['general']['restrict_sites_by_url']) ? "true" : "false";
        $n[] = "restrict_sites_by_url = $bool_string;";
        $n[] = "";

        $n[] = "[indexed_file_types]";
        if (isset($info["indexed_file_types"]['extensions'])) {
            foreach ($info["indexed_file_types"]['extensions'] as $extension) {
                $n[] = "extensions[] = '$extension';";
            }
        }
        $n[] = "";

        $n[] = "[active_classifiers]";
        if (isset($info['active_classifiers']['label'])) {
            foreach ($info['active_classifiers']['label'] as $label) {
                $n[] = "label[] = '$label';";
            }
        }
        $n[] = "";

        $n[] = "[active_rankers]";
        if (isset($info['active_rankers']['label'])) {
            foreach ($info['active_rankers']['label'] as $label) {
                $n[] = "label[] = '$label';";
            }
        }
        $n[] = "";

        $site_types =
            ['allowed_sites' => 'url', 'disallowed_sites' => 'url',
                'seed_sites' => 'url', 'page_rules'=>'rule'];
        foreach ($site_types as $type => $field) {
            $n[] = "[$type]";
            if (isset($info[$type][$field])) {
                foreach ($info[$type][$field] as $field_value) {
                    $n[] = $field . "[] = '$field_value';";
                }
            }
            $n[]="";
        }
        $n[] = "[indexing_plugins]";
        if (isset($info["indexing_plugins"]['plugins'])) {
            foreach ($info["indexing_plugins"]['plugins'] as $plugin) {
                if ($plugin == "") {
                    continue;
                }
                $n[] = "plugins[] = '$plugin';";
            }
        }
        $out = implode("\n", $n);
        $out .= "\n";
        file_put_contents(C\WORK_DIRECTORY . "/crawl.ini", $out);
    }
    /**
     * Returns the crawl parameters that were used during a given crawl
     *
     * @param string $timestamp timestamp of the crawl to load the crawl
     *     parameters of
     * @return array  the first sites to crawl during the next crawl
     *     restrict_by_url, allowed, disallowed_sites
     * @param array $machine_urls an array of urls of yioop queue servers
     *
     */
    public function getCrawlSeedInfo($timestamp,  $machine_urls = null)
    {
        if ($machine_urls != null &&
            !$this->isSingleLocalhost($machine_urls, $timestamp)) {
            /* seed info should be same amongst all queue servers that have it--
               only start schedule differs -- however, not all queue servers
               necessarily have the same crawls. Thus, we still query all
               machines in case only one has it.
             */
            $a_list = $this->execMachines("getCrawlSeedInfo",
                $machine_urls, serialize($timestamp));
            if (is_array($a_list)) {
                foreach ($a_list as $elt) {
                    $seed_info = unserialize(L\webdecode(
                        $elt[self::PAGE]));
                    // first crawl with timestamp gets to say what params are
                    if (isset($seed_info['general'])) {
                        break;
                    }
                }
            }
            return $seed_info;
        }
        $dir = C\CACHE_DIR . '/' . self::index_data_base_name .
            $timestamp;
        $is_double_index = file_exists($dir) ? false : true;
        if ($is_double_index) {
            $dir = C\CACHE_DIR . '/' . self::double_index_base_name .
                $timestamp;
        }
        $seed_info = null;
        $index_bundle_class = C\NS_LIB . ($is_double_index  ?
            "DoubleIndexBundle" : ((file_exists($dir .
            "/summaries")) ? "IndexArchiveBundle" : "IndexDocumentBundle"));
        if (file_exists($dir)) {
            $info = $index_bundle_class::getArchiveInfo($dir);
            if (!isset($info['DESCRIPTION']) ||
                $info['DESCRIPTION'] == null ||
                strstr($info['DESCRIPTION'], "Archive created")) {
                return $seed_info;
            }
            $index_info = unserialize($info['DESCRIPTION']);
            $general_params = ["restrict_sites_by_url" =>
                [self::RESTRICT_SITES_BY_URL, false],
                "crawl_type" => [self::CRAWL_TYPE, self::WEB_CRAWL],
                "channel" => [self::CHANNEL, 0],
                "crawl_index" => [self::CRAWL_INDEX, ''],
                "crawl_order" => [self::CRAWL_ORDER, self::HOST_BUDGETING],
                "max_depth" => [self::MAX_DEPTH, -1],
                "repeat_type" => [self::REPEAT_TYPE, -1],
                "sleep_start" => [self::SLEEP_START, -1],
                "sleep_duration" => [self::SLEEP_DURATION, "00:00"],
                "robots_txt" => [self::ROBOTS_TXT, C\ALWAYS_FOLLOW_ROBOTS],
                "summarizer_option" => [self::SUMMARIZER_OPTION,
                    self::BASIC_SUMMARIZER],
                "arc_dir" => [self::ARC_DIR, ''],
                "arc_type" => [self::ARC_TYPE, ''],
                "cache_pages" => [self::CACHE_PAGES, true],
                "page_recrawl_frequency" => [self::PAGE_RECRAWL_FREQUENCY, -1],
                "page_range_request" => [self::PAGE_RANGE_REQUEST,
                    C\PAGE_RANGE_REQUEST],
                "max_description_len" => [self::MAX_DESCRIPTION_LEN,
                    C\MAX_DESCRIPTION_LEN],
                "max_links_to_extract" => [self::MAX_LINKS_TO_EXTRACT,
                    C\MAX_LINKS_TO_EXTRACT],
            ];
            foreach ($general_params as $param => $info) {
                $seed_info['general'][$param] = (isset($index_info[$info[0]])) ?
                    $index_info[$info[0]] : $info[1];
            }
            $site_types = [
                "allowed_sites" => [self::ALLOWED_SITES, "url"],
                "disallowed_sites" => [self::DISALLOWED_SITES, "url"],
                "seed_sites" => [self::TO_CRAWL, "url"],
                "page_rules" => [self::PAGE_RULES, "rule"],
                "indexed_file_types" => [self::INDEXED_FILE_TYPES,
                    "extensions"],
            ];
            foreach ($site_types as $type => $info) {
                if (isset($index_info[$info[0]])) {
                    $tmp = & $index_info[$info[0]];
                } else {
                    $tmp = [];
                }
                $seed_info[$type][$info[1]] =  $tmp;
            }
            if (isset($index_info[self::INDEXING_PLUGINS])) {
                $seed_info['indexing_plugins']['plugins'] =
                    $index_info[self::INDEXING_PLUGINS];
            }
            if (isset($index_info[self::INDEXING_PLUGINS_DATA])) {
                $seed_info['indexing_plugins']['plugins_data'] =
                    $index_info[self::INDEXING_PLUGINS_DATA];
            }
        }
        return $seed_info;
    }
    /**
     * Changes the crawl parameters of an existing crawl (can be while crawling)
     * Not all fields are allowed to be updated
     *
     * @param string $timestamp timestamp of the crawl to change
     * @param array $new_info the new parameters
     * @param array $machine_urls an array of urls of yioop queue servers
     */
    public function setCrawlSeedInfo($timestamp, $new_info,
        $machine_urls = null)
    {
        if ($machine_urls != null &&
            !$this->isSingleLocalhost($machine_urls, $timestamp)) {
            $channel = $this->getChannel($timestamp);
            $params = [$timestamp, $new_info];
            $network_filename = C\SCHEDULES_DIR .
                "/{$channel}-" . self::network_status_file;
            if (file_exists($network_filename)) {
                $net_status = unserialize(file_get_contents($network_filename));
                $net_status[self::SLEEP_START] =
                    $new_info['general']["sleep_start"] ?? "00:00";
                $net_status[self::SLEEP_DURATION] =
                    $new_info['general']["sleep_duration"] ?? "-1";
                file_put_contents($network_filename, serialize($net_status));
            }
            $this->execMachines("setCrawlSeedInfo",
                $machine_urls, serialize($params));
            return;
        }
        $pre_dir = C\CACHE_DIR . '/' . self::index_data_base_name .
            $timestamp;
        $dir = (file_exists($pre_dir)) ? $pre_dir : C\CACHE_DIR . '/' .
            self::double_index_base_name . $timestamp;
        $class_name = ($dir == $pre_dir) ? ((file_exists($dir .
            "/summaries")) ? C\NS_LIB . "IndexArchiveBundle" :
            C\NS_LIB . "IndexDocumentBundle") : C\NS_LIB . "DoubleIndexBundle";
        if (file_exists($dir)) {
            $info = $class_name::getArchiveInfo($dir);
            $index_info = unserialize($info['DESCRIPTION']);
            if (isset($new_info['general']["restrict_sites_by_url"])) {
                $index_info[self::RESTRICT_SITES_BY_URL] =
                    $new_info['general']["restrict_sites_by_url"];
            }
            if (isset($new_info['general']["repeat_type"])) {
                $index_info[self::REPEAT_TYPE] =
                    $new_info['general']["repeat_type"];
            }
            if (isset($new_info['general']["sleep_start"])) {
                $index_info[self::SLEEP_START] =
                    $new_info['general']["sleep_start"];
            }
            if (isset($new_info['general']["sleep_duration"])) {
                $index_info[self::SLEEP_DURATION] =
                    $new_info['general']["sleep_duration"];
            }
            $updatable_site_info = [
                "allowed_sites" => [self::ALLOWED_SITES, 'url'],
                "disallowed_sites" => [self::DISALLOWED_SITES, 'url'],
                "seed_sites" => [self::TO_CRAWL, "url"],
                "page_rules" => [self::PAGE_RULES, 'rule'],
                "indexed_file_types" => [self::INDEXED_FILE_TYPES,
                    "extensions"],
                "active_classifiers" => [self::ACTIVE_CLASSIFIERS, 'label'],
                "active_rankers" => [self::ACTIVE_RANKERS, 'label'],
            ];
            foreach ($updatable_site_info as $type => $type_info) {
                if (isset($new_info[$type][$type_info[1]])) {
                    $index_info[$type_info[0]] =
                        $new_info[$type][$type_info[1]];
                }
            }
            if (isset($new_info['indexing_plugins']['plugins'])) {
                $index_info[self::INDEXING_PLUGINS] =
                    $new_info['indexing_plugins']['plugins'];
            }
            $info['DESCRIPTION'] = serialize($index_info);
            $class_name::setArchiveInfo($dir, $info);
        }
    }
    /**
     *  Gets the channel of the crawl with the given timestamp
     *
     * @param int $timestamp of crawl to get channel for
     * @return int $channel used by that crawl
     */
    public function getChannel($timestamp)
    {
        $seed_info = $this->getCrawlSeedInfo($timestamp);
        $channel = (empty($seed_info['channel'])) ? 0 : $seed_info['channel'];
        return $channel;
    }
    /**
     * Returns an array of urls which were stored via the suggest-a-url
     * form in suggest_view.php
     *
     * @return array urls that have been suggested
     */
    public function getSuggestSites()
    {
        $suggest_file = $this->suggest_url_file;
        if (file_exists($suggest_file)) {
            $urls = file($suggest_file);
        } else {
            $urls = [];
        }
        return $urls;
    }
    /**
     * Add new distinct urls to those already saved in the suggest_url_file
     * If the supplied url is not new or the file size
     * exceeds MAX_SUGGEST_URL_FILE_SIZE then it is not added.
     *
     * @param string $url to add
     * @return string true if the url was added or already existed
     *     in the file; false otherwise
     */
    public function appendSuggestSites($url)
    {
        $suggest_file = $this->suggest_url_file;
        $suggest_size = strlen($url);
        if (file_exists($suggest_file)) {
            $suggest_size += filesize($suggest_file);
        } else {
            $this->clearSuggestSites();
        }
        if ($suggest_size < C\MAX_SUGGEST_URL_FILE_SIZE) {
            $urls = file($suggest_file);
            $urls[] = $url;
            $urls = array_unique($urls);
            $out_string = "";
            $delim = "";
            foreach ($urls as $url) {
                $trim_url = trim($url);
                if (strlen($trim_url) > 0) {
                    $out_string .= $delim . $trim_url;
                    $delim = "\n";
                }
            }
            file_put_contents($suggest_file, $out_string, LOCK_EX);
            return true;
        }
        return false;
    }
    /**
     * Resets the suggest_url_file to be the empty file
     */
    public function clearSuggestSites()
    {
        file_put_contents($this->suggest_url_file, "", LOCK_EX);
    }
    /**
     * Get a description associated with a Web Crawl or Crawl Mix
     *
     * @param int $timestamp of crawl or mix in question
     * @param array $machine_urls an array of urls of yioop queue servers
     *
     * @return array associative array containing item DESCRIPTION
     */
    public function getInfoTimestamp($timestamp, $machine_urls = null)
    {
        $is_mix = $this->isCrawlMix($timestamp);
        $info = [];
        if ($is_mix) {
            $sql = "SELECT TIMESTAMP, NAME FROM CRAWL_MIXES WHERE ".
                " TIMESTAMP=?";
            $result = $this->db->execute($sql, [$timestamp]);
            $mix =  $this->db->fetchArray($result);
            $info['TIMESTAMP'] = $timestamp;
            $info['DESCRIPTION'] = $mix['NAME'];
            $info['IS_MIX'] = true;
        } else {
            if ($machine_urls != null && is_array($machine_urls) &&
                !$this->isSingleLocalhost($machine_urls, $timestamp)) {
                $cache_file = C\CACHE_DIR . "/" .
                    self::network_base_name . $timestamp . ".txt";
                if (file_exists($cache_file)) {
                    $old_info = unserialize(file_get_contents($cache_file));
                }
                if (isset($old_info) && filemtime($cache_file)
                    + 6 * C\ONE_MINUTE > time()) {
                    return $old_info;
                }
                $info = [];
                if (isset($old_info["MACHINE_URLS"])) {
                    $info["MACHINE_URLS"] = $old_info["MACHINE_URLS"];
                    $machine_urls = array_intersect(
                        $old_info["MACHINE_URLS"], $machine_urls);
                } else {
                    $info["MACHINE_URLS"] = $machine_urls;
                }
                $info_lists = $this->execMachines("getInfoTimestamp",
                    $machine_urls, serialize($timestamp));
                $info['DESCRIPTION'] = "";
                $info["COUNT"] = 0;
                $info['VISITED_URLS_COUNT'] = 0;
                set_error_handler(null);
                foreach ($info_lists as $info_list) {
                    $a_info = @unserialize(L\webdecode(
                        $info_list[self::PAGE]));
                    if (isset($a_info['DESCRIPTION'])) {
                        $info['DESCRIPTION'] = $a_info['DESCRIPTION'];
                    }
                    if (isset($a_info['VISITED_URLS_COUNT'])) {
                        $info['VISITED_URLS_COUNT'] +=
                            $a_info['VISITED_URLS_COUNT'];
                    }
                    if (isset($a_info['COUNT'])) {
                        $info['COUNT'] += $a_info['COUNT'];
                    }
                }
                restore_error_handler();
                file_put_contents($cache_file, serialize($info));
                return $info;
            }
            $pre_dir = C\CACHE_DIR . '/' . self::index_data_base_name .
                $timestamp;
            $old_index_summaries = $pre_dir . "/summaries";
            $dir = (file_exists($pre_dir)) ? $pre_dir : C\CACHE_DIR .
                '/' . self::double_index_base_name . $timestamp;
            $class_name = ($dir == $pre_dir) ?
                (file_exists($old_index_summaries) ?
                C\NS_LIB . "IndexArchiveBundle" :
                C\NS_LIB . "IndexDocumentBundle") :
                C\NS_LIB . "DoubleIndexBundle";
            if (file_exists($dir)) {
                $info = $class_name::getArchiveInfo($dir);
                if (isset($info['DESCRIPTION'])) {
                    $tmp = unserialize($info['DESCRIPTION'] ?? "");
                    $info['DESCRIPTION'] = $tmp['DESCRIPTION'] ?? "";
                }
                $info['COUNT'] = empty($info['QUERY_COUNT']) ?
                    ($info['COUNT'] ?? 0) : $info['QUERY_COUNT'];
                $info['VISITED_URLS_COUNT'] =
                    empty($info['QUERY_VISITED_URLS_COUNT']) ?
                    ($info['VISITED_URLS_COUNT'] ?? 0 ):
                    $info['QUERY_VISITED_URLS_COUNT'];
            }
        }
        return $info;
    }
    /**
     * Deletes the crawl with the supplied timestamp if it exists. Also
     * deletes any crawl mixes making use of this crawl
     *
     * @param string $timestamp a Unix timestamp
     * @param array $machine_urls an array of urls of yioop queue servers
     */
    public function deleteCrawl($timestamp, $machine_urls = null)
    {
        if ($machine_urls != null &&
            !$this->isSingleLocalhost($machine_urls, $timestamp)) {
            //get rid of cache info on Name machine
            $mask = C\CACHE_DIR . "/" . self::network_crawllist_base_name.
                "*.txt";
            array_map("unlink", glob($mask));
            $delete_files = [
                C\CACHE_DIR . "/" . self::network_base_name .
                    "$timestamp.txt",
                C\CACHE_DIR . "/" . self::statistics_base_name .
                    "$timestamp.txt"
            ];
            foreach ($delete_files as $delete_file) {
                if (file_exists($delete_file)) {
                    unlink($delete_file);
                }
            }
            if (!in_array(C\p('NAME_SERVER'), $machine_urls)) {
                array_unshift($machine_urls, C\p('NAME_SERVER'));
            }
            //now get rid of files on queue servers
            $this->execMachines("deleteCrawl",
                $machine_urls, serialize($timestamp));
            return;
        }
        $delete_dirs = [
            C\CACHE_DIR . "/" . self::double_index_base_name . $timestamp,
            C\CACHE_DIR . "/" . self::index_data_base_name . $timestamp,
            C\SCHEDULES_DIR . "/" . self::messages_data_base_name .
                $timestamp,
            C\SCHEDULES_DIR . "/" . self::name_archive_iterator .
                $timestamp,

        ];
        foreach ($delete_dirs as $delete_dir) {
            if (file_exists($delete_dir)) {
                $this->db->unlinkRecursive($delete_dir, true);
            }
        }
        $save_point_files = glob(C\SCHEDULES_DIR . "/" . self::save_point.
            $timestamp . "*.txt");
        foreach ($save_point_files as $save_point_file) {
            @unlink($save_point_file);
        }
        $sql = "SELECT DISTINCT TIMESTAMP FROM MIX_COMPONENTS WHERE ".
            " CRAWL_TIMESTAMP='$timestamp'";
        $result = $this->db->execute($sql);
        while ($row = $this->db->fetchArray($result)) {
            if (!empty($row['TIMESTAMP'])) {
                $this->deleteCrawlMix($row['TIMESTAMP']);
            }
        }
        $current_timestamp = $this->getCurrentIndexDatabaseName();
        if ($current_timestamp == $timestamp) {
            $this->db->execute("DELETE FROM CURRENT_WEB_INDEX");
        }
    }
    /**
     * Clears several memory and file caches related to crawls and
     * networking.
     */
    public function clearCrawlCaches()
    {
        $masks = [self::network_crawllist_base_name,
            self::network_base_name];
        foreach ($masks as $mask) {
            $mask = C\CACHE_DIR . "/" . $mask . "*.txt";
            array_map("unlink", glob($mask));
        }
        FetchUrl::$local_ip_cache = [];
        $local_ip_cache_file = C\TEMP_DIR . "/" .
            self::local_ip_cache_file;
        if (file_exists($local_ip_cache_file)) {
            unlink($local_ip_cache_file);
        }
    }
    /**
     * Used to send a message to the queue servers to start a crawl
     *
     * @param array $crawl_params has info like the time of the crawl,
     *      whether starting a new crawl or resuming an old one, etc.
     * @param array $seed_info what urls to crawl, etc as from the crawl.ini
     *      file
     * @param array $machine_urls an array of urls of yioop queue servers
     * @param int $num_fetchers number of fetchers on machine to start.
     *      This parameter and $channel are used to start the daemons
     *      running on the machines if they aren't already running
     * @param int $fetcher_queue_server_ratio maximum of the number 1 and the
     *      number of active fetchers running across all yioop instances
     *      currently divided by the number of queue servers
     * @return bool true on success (request dispatched to queue servers
     *      or local crawl started); false when the seed-site validation
     *      rejects the request
     */
    public function sendStartCrawlMessage($crawl_params, $seed_info = null,
        $machine_urls = null, $num_fetchers = 0,
        $fetcher_queue_server_ratio = 1)
    {
        $channel = (empty($crawl_params[self::CHANNEL])) ? 0 :
            $crawl_params[self::CHANNEL];
        if ($machine_urls != null && !$this->isSingleLocalhost($machine_urls)) {
            $params = [$crawl_params, $seed_info];
            $crawl_time = $crawl_params[self::CRAWL_TIME];
            $sleep_start = $crawl_params[self::SLEEP_START] ?? "00:00";
            $sleep_duration = $crawl_params[self::SLEEP_DURATION] ?? -1;
            $network_status_filename = C\SCHEDULES_DIR .
                "/{$channel}-" . self::network_status_file;
            file_put_contents($network_status_filename,
                serialize([self::CRAWL_TIME => $crawl_time,
                self::SLEEP_START => $sleep_start,
                self::SLEEP_DURATION => $sleep_duration]));
            $this->execMachines("sendStartCrawlMessage",
                $machine_urls, serialize($params), 0, true,
                $fetcher_queue_server_ratio);
            return true;
        }
        $statuses = CrawlDaemon::statuses();
        //If no QueueServers or Fetchers turned on, then turn on
        if ($statuses == [] && $channel != -1) {
            if(!$this->startQueueServerFetchers($channel,
                $num_fetchers)) {
                return false;
            }
        }
        $info = $crawl_params;
        $info[self::FETCHER_QUEUE_SERVER_RATIO] = $fetcher_queue_server_ratio;
        $info_string = serialize($info);
        $queue_messages_filename = CrawlDaemon::getMessageFileName(
            "QueueServer", $channel);
        file_put_contents($queue_messages_filename, $info_string);
        chmod($queue_messages_filename, 0777);
        if ($seed_info != null) {
            $scheduler_info[self::HASH_SEEN_URLS] = [];
            $sites = $seed_info['seed_sites']['url'];
            $sites = array_filter($sites, function($site) {
                return $site[0] != "#"; //ignore comments in file
            });
            $num_sites = count($sites);
            foreach ($sites as $site) {
                $site_parts = preg_split("/\s+/", $site);
                if (strlen($site_parts[0]) > 0) {
                    $scheduler_info[self::TO_CRAWL][] =
                        [$site_parts[0],  0.0, 0, "", 0.0];
                }
            }
            $scheduler_string = "\n" . L\webencode(
                gzcompress(serialize($scheduler_info)));
            file_put_contents(C\SCHEDULES_DIR . "/$channel-" .
                self::schedule_start_name, $scheduler_string);
        }
        return true;
    }
    /**
     * Used to start QueueServers and Fetchers on current machine when
     * it is detected that someone tried to start a crawl but hadn't
     * started any queue servers or fetchers.
     *
     * @param int $channel channel of crawl to start
     * @param int $num_fetchers the number of fetchers on the current machine
     * @return bool whether any processes were started
     */
    function startQueueServerFetchers($channel, $num_fetchers)
    {
        $db = $this->db;
        $success = false;
        $machine_name = "NAME_SERVER";
        if (C\p('NAME_SERVER') == C\baseUrl() && $channel == 0 &&
            $num_fetchers == 0) {
            $sql = "SELECT NAME, CHANNEL, NUM_FETCHERS FROM MACHINE" .
                " WHERE URL='" . C\baseUrl() . "' OR URL='BASE_URL'";
            $result = $db->execute($sql);
            if ($result) {
                $row = $db->fetchArray($result);
                $machine_name = $row['NAME'];
                $channel = intval($row['CHANNEL']);
                $num_fetchers = intval($row['NUM_FETCHERS']);
            }
        }
        $sql = "INSERT INTO ACTIVE_PROCESS VALUES (?, ?, ?)";
        /* This method was supposed to be called if nothing is running
           so shouldn't do anything if not starting any fetchers.
           Checking channel >= handles mirror mode. Even if multi channels
           on a given machine, use only one queue server.
         */
        if ($channel >= 0 && $num_fetchers > 0) {
            CrawlDaemon::start("QueueServer", "$channel", self::INDEXER, 0);
            CrawlDaemon::start("QueueServer", "$channel", self::SCHEDULER, -1);
            $db->execute($sql, [$machine_name, 0, "QueueServer"]);
            $success = true;
        }
        for ($id = 0; $id < $num_fetchers; $id++) {
            $db->execute($sql, [$machine_name, $id, "Fetcher"]);
            CrawlDaemon::start("Fetcher", "$id-$channel", "$channel", -1);
            $success = true;
        }
        sleep(5);
        return $success;
    }
    /**
     * Used to send a message to the queue servers to stop a crawl
     * @param $channel of crawl to stop
     * @param array $machine_urls an array of urls of yioop queue servers
     */
    public function sendStopCrawlMessage($channel, $machine_urls = null)
    {
         if ($machine_urls != null &&
            !$this->isSingleLocalhost($machine_urls)) {
            $net_stat_file = C\SCHEDULES_DIR .
                "/{$channel}-" . self::network_status_file;
            if (file_exists($net_stat_file)) {
                @unlink($net_stat_file);
            }
            $this->execMachines("sendStopCrawlMessage", $machine_urls,
                $channel);
            return;
        }
        $info = [];
        $info[self::STATUS] = "STOP_CRAWL";
        $info_string = serialize($info);
        $queue_messages_filename = CrawlDaemon::getMessageFileName(
             "QueueServer", $channel);
        file_put_contents($queue_messages_filename, $info_string);
    }
    /**
     * Gets a list of all index archives of crawls that have been conducted
     *
     * @param bool $return_arc_bundles whether index bundles used for indexing
     *     arc or other archive bundles should be included in the list
     * @param bool $return_recrawls whether index archive bundles generated as
     *     a result of recrawling should be included in the result
     * @param array $machine_urls an array of urls of yioop queue servers
     * @param bool $cache whether to try to get/set the data to a cache file
     *
     * @return array available IndexArchiveBundle directories and
     *     their meta information this meta information includes the time of
     *     the crawl, its description, the number of pages downloaded, and the
     *     number of partitions used in storing the inverted index
     */
    public function getCrawlList($return_arc_bundles = false,
        $return_recrawls = false, $machine_urls = null, $cache = false)
    {
        if ($machine_urls != null && !$this->isSingleLocalhost($machine_urls)) {
            $arg = ($return_arc_bundles && $return_recrawls) ? 3 :
                (($return_recrawls) ? 2 : (($return_arc_bundles) ? 1 : 0));
            $cache_file = C\CACHE_DIR . "/" .
                self::network_crawllist_base_name . "$arg.txt";
            if ($cache && file_exists($cache_file) && filemtime($cache_file)
                + 300 > time()) {
                return unserialize(file_get_contents($cache_file));
            }
            $list_strings = $this->execMachines("getCrawlList",
                $machine_urls, $arg);
            $list = $this->aggregateCrawlList($list_strings);
            if ($cache) {
                file_put_contents($cache_file, serialize($list));
            }
            return $list;
        }
        $list = [];
        $dirs = glob(C\CACHE_DIR . '/{' . self::index_data_base_name .
            ',' . self::double_index_base_name . '}*',
            GLOB_ONLYDIR | GLOB_BRACE);
        $feed_dir = C\CACHE_DIR . '/' . self::feed_index_data_base_name;
        if (!file_exists($feed_dir)) {
            $info = ['DESCRIPTION' => "feed"];
            $index_archive = new L\FeedDocumentBundle($feed_dir,
                $this->db, false, serialize($info), C\NUM_DOCS_PER_PARTITION);
            $this->db->setWorldPermissionsRecursive($feed_dir);
        }
        foreach ($dirs as $dir) {
            $crawl = [];
            if ($dir != $feed_dir) {
                preg_match('/(' .self::index_data_base_name .
                    '|'. self::double_index_base_name .
                    ')(\d+)$/', $dir, $matches);
                $crawl['CRAWL_TIME'] = $matches[2] ?? 0;
                $bundle_class_name = (!empty($matches[1][0]) &&
                    $matches[1][0] == 'D') ?
                    C\NS_LIB . "DoubleIndexBundle" : ((file_exists($dir .
                    "/summaries")) ? C\NS_LIB . "IndexArchiveBundle" :
                    C\NS_LIB . "IndexDocumentBundle");
            } else {
                $bundle_class_name = (file_exists($feed_dir . "/summaries")) ?
                    C\NS_LIB . "IndexArchiveBundle" :
                    C\NS_LIB . "IndexDocumentBundle";
                $crawl['CRAWL_TIME'] = self::FEED_CRAWL_TIME;
            }
            $queue_dir = str_replace(self::index_data_base_name,
                self::queue_base_name, $dir);
            $queue_dir = str_replace(self::double_index_base_name,
                self::queue_base_name, $queue_dir);
            $info = $bundle_class_name::getArchiveInfo($dir);
            if (isset($info['DESCRIPTION'])) {
                set_error_handler(null);
                $index_info = @unserialize($info['DESCRIPTION']);
                restore_error_handler();
            } else {
                $index_info = [];
                $index_info['DESCRIPTION'] = "ERROR!! $dir<br>" .
                    print_r($info, true);
            }
            $crawl['DESCRIPTION'] = "";
            if (!$return_recrawls &&
                isset($index_info[self::CRAWL_TYPE]) &&
                $index_info[self::CRAWL_TYPE] == self::ARCHIVE_CRAWL) {
                continue;
            } elseif ($return_recrawls  &&
                isset($index_info[self::CRAWL_TYPE]) &&
                $index_info[self::CRAWL_TYPE] == self::ARCHIVE_CRAWL
                && empty($index_info[self::ARC_TYPE])) {
                $crawl['DESCRIPTION'] = "RECRAWL::";
            }
            $message_bundle_dir = C\SCHEDULES_DIR . "/" .
                self::messages_data_base_name . $crawl['CRAWL_TIME'];
            $crawl['RESUMABLE'] =
                MessagesBundle::isResumable($message_bundle_dir);
            $queue_url_folder = $queue_dir . "/".
                L\CrawlQueueBundle::URL_QUEUE_FOLDER;
            if (file_exists($queue_url_folder) &&
                empty($crawl['RESUMABLE'])) {
                $crawl['RESUMABLE'] = L\CrawlQueueBundle::isResumable(
                    $queue_dir);
            }
            if (isset($index_info['DESCRIPTION'])) {
                $crawl['DESCRIPTION'] .= $index_info['DESCRIPTION'];
            }
            $crawl['VISITED_URLS_COUNT'] = $info['VISITED_URLS_COUNT'] ?? 0;
            $crawl['COUNT'] = $info['COUNT'] ?? 0;
            $crawl['ACTIVE_COUNT'] = $info['ACTIVE_COUNT'] ?? 0;
            if (!empty($info['QUERY_COUNT'])) {
                $crawl['QUERY_VISITED_URLS_COUNT'] =
                    $info['QUERY_VISITED_URLS_COUNT'] ?? 0;
                $crawl['QUERY_COUNT'] = $info['QUERY_COUNT'] ?? 0;
            }
            $crawl['NUM_DOCS_PER_PARTITION'] = $info['NUM_DOCS_PER_PARTITION']
                ?? 0;
            $crawl['WRITE_PARTITION'] = $info['WRITE_PARTITION'] ?? 0;
            $list[] = $crawl;
        }
        if ($return_arc_bundles) {
            $dirs = glob(C\ARCHIVES_DIR . '/*', GLOB_ONLYDIR);
            foreach ($dirs as $dir) {
                $crawl = [];
                $crawl['CRAWL_TIME'] = crc32($dir);
                $crawl['DESCRIPTION'] = "ARCFILE::";
                $crawl['ARC_DIR'] = $dir;
                $ini_file = "$dir/arc_description.ini";
                if (!file_exists($ini_file)) {
                    continue;
                } else {
                    $ini = L\parse_ini_with_fallback($ini_file);
                    $crawl['ARC_TYPE'] = $ini['arc_type'];
                    $crawl['DESCRIPTION'] .= $ini['description'];
                }
                $crawl['VISITED_URLS_COUNT'] = 0;
                $crawl['COUNT'] = 0;
                $crawl['NUM_DOCS_PER_PARTITION'] = 0;
                $crawl['WRITE_PARTITION'] = 0;
                $list[] = $crawl;
            }
        }
        return $list;
    }
    /**
     * When @see getCrawlList() is used in a multi-queue server this method
     * used to integrate the crawl lists received by the different machines
     *
     * @param array $list_strings serialized crawl list data from different
     * queue servers
     * @param string $data_field field of $list_strings to use for data
     * @return array list of crawls and their meta data
     */
    public function aggregateCrawlList($list_strings, $data_field = null)
    {
        set_error_handler(null);
        $pre_list = [];
        foreach ($list_strings as $list_string) {
            $a_list = @unserialize(L\webdecode(
                $list_string[self::PAGE]));
            if ($data_field != null) {
                $a_list = $a_list[$data_field] ?? false;
            }
            if (is_array($a_list)) {
                foreach ($a_list as $elt) {
                    $timestamp = $elt['CRAWL_TIME'];
                    if (!isset($pre_list[$timestamp])) {
                        $pre_list[$timestamp] = $elt;
                    } else {
                        if (isset($elt["DESCRIPTION"]) &&
                            $elt["DESCRIPTION"] != "") {
                            $pre_list[$timestamp]["DESCRIPTION"] =
                                $elt["DESCRIPTION"];
                        }
                        $pre_list[$timestamp]["VISITED_URLS_COUNT"] +=
                            $elt["VISITED_URLS_COUNT"];
                        $pre_list[$timestamp]["COUNT"] +=
                            $elt["COUNT"];
                        if (!empty($elt["QUERY_COUNT"])) {
                            $pre_list[$timestamp]["QUERY_VISITED_URLS_COUNT"] +=
                                $elt["QUERY_VISITED_URLS_COUNT"];
                            $pre_list[$timestamp]["QUERY_COUNT"] +=
                                $elt["QUERY_COUNT"];
                        }
                        if (isset($elt['RESUMABLE'])) {
                            $pre_list[$timestamp]['RESUMABLE'] |=
                                $elt['RESUMABLE'];
                        }
                    }
                }
            }
        }
        $list = array_values($pre_list);
        restore_error_handler();
        return $list;
    }
    /**
     * Determines if the length of time since any of the fetchers has spoken
     * with any of the queue servers has exceeded CRAWL_TIMEOUT. If so,
     * typically the caller of this method would do something such as officially
     * stop the crawl.
     *
     * @param array $machine_urls an array of urls of yioop queue servers
     * @return bool whether the current crawl is stalled or not
     */
    public function crawlStalled($machine_urls = null)
    {
        if ($machine_urls != null && !$this->isSingleLocalhost($machine_urls)) {
            $outputs = $this->execMachines("crawlStalled", $machine_urls);
            return $this->aggregateStalled($outputs);
        }
        $stat_prefix = C\SCHEDULES_DIR . "/";
        $stat_prefix_len = strlen($stat_prefix);
        $stat_suffix = "-" . self::crawl_status_file;
        $stat_suffix_len = strlen($stat_suffix);
        $stat_files = glob("$stat_prefix*$stat_suffix");
        $statuses = [];
        foreach ($stat_files as $stat_file) {
            $channel = substr($stat_file, $stat_prefix_len, -$stat_suffix_len);
            $crawl_status = unserialize(file_get_contents($stat_file));
            $non_repeating = (empty($crawl_status["REPEAT_TYPE"]) ||
                intval($crawl_status["REPEAT_TYPE"]) < 0);
            /* CrawlConstants::crawl_status_file file be updated any time data
               sent from fetcher via FetchController update method.
               If no new data has arrived for CRAWL_TIMEOUT amount of time
               assume crawl not active */
            if ($non_repeating && filemtime($stat_file) +
                    C\CRAWL_TIMEOUT < time()) {
                $statuses[$channel] = true;
            }
        }
        return $statuses;
    }
    /**
     * When @see crawlStalled() is used in a multi-queue server this method
     * used to integrate the stalled information received by the different
     * machines
     *
     * @param array $stall_statuses contains web encoded serialized data one
     * one field of which has the boolean data concerning stalled statis
     *
     * @param string $data_field field of $stall_statuses to use for data
     *     if null then each element of $stall_statuses is a web encoded
     *     serialized boolean
     * @return array map channel => bool indicating whether ALL machines
     *     report that channel as stalled (and-reduction across machines)
     */
    public function aggregateStalled($stall_statuses, $data_field = null)
    {
        set_error_handler(null);
        $out_stalled = [];
        foreach ($stall_statuses as $status) {
            $stall_status = @unserialize(L\webdecode($status[self::PAGE]));
            if ($data_field !== null) {
                $stall_status = $stall_status[$data_field] ?? false;
            }
            if ($stall_status) {
                foreach ($stall_status  as $channel => $channel_status) {
                    if (isset($out_stalled[$channel])) {
                        $out_stalled[$channel] = $channel_status &&
                            $out_stalled[$channel];
                    } else {
                        $out_stalled[$channel] = $channel_status;
                    }
                }
            }
        }
        restore_error_handler();
        return $out_stalled;
    }
    /**
     * Returns data about current crawl such as DESCRIPTION, TIMESTAMP,
     * peak memory of various processes, most recent fetcher, most recent
     * urls, urls seen, urls visited, etc.
     *
     * @param array $machine_urls an array of urls of yioop queue servers
     *     on which the crawl is being conducted
     * @return array associative array of the said data
     */
    public function crawlStatus($machine_urls = null)
    {
        if ($machine_urls != null && !$this->isSingleLocalhost($machine_urls)) {
            $status_strings = $this->execMachines("crawlStatus", $machine_urls);
            return $this->aggregateStatuses($status_strings);
        }
        $stat_prefix = C\SCHEDULES_DIR . "/";
        $stat_prefix_len = strlen($stat_prefix);
        $stat_suffix = "-" . self::crawl_status_file;
        $stat_suffix_len = strlen($stat_suffix);
        $stat_files = glob("$stat_prefix*$stat_suffix");
        $data = [];
        $statuses = [];
        foreach ($stat_files as $stat_file) {
            $channel = substr($stat_file, $stat_prefix_len, -$stat_suffix_len);
            $data[$channel] = [];
            $crawl_status =
                @unserialize(file_get_contents($stat_file));
            if (empty($crawl_status)) {
                unlink($stat_file);
                continue;
            }
            $schedule_status_file = C\SCHEDULES_DIR .
                "/$channel-ScheduleStatus.txt";
            $schedule_status_exists = file_exists($schedule_status_file);
            if ($schedule_status_exists) {
                $schedule_status = @unserialize(file_get_contents(
                    $schedule_status_file));
                if (isset($schedule_status[self::TYPE]) &&
                    $schedule_status[self::TYPE] == self::SCHEDULER) {
                    $data[$channel]['SCHEDULER_PEAK_MEMORY'] =
                        isset($schedule_status[self::MEMORY_USAGE]) ?
                        $schedule_status[self::MEMORY_USAGE] : 0;
                }
            }
            $data[$channel] = (isset($crawl_status)
                && is_array($crawl_status)) ?
                array_merge($data[$channel], $crawl_status) : $data[$channel];
            if (isset($data[$channel]['VISITED_COUNT_HISTORY']) &&
                count($data[$channel]['VISITED_COUNT_HISTORY']) > 1) {
                $recent = array_shift($data[$channel]['VISITED_COUNT_HISTORY']);
                $data[$channel]["MOST_RECENT_TIMESTAMP"] = $recent[0];
                $oldest = array_pop($data[$channel]['VISITED_COUNT_HISTORY']);
                unset($data[$channel]['VISITED_COUNT_HISTORY']);
                $change_in_time_hours = floatval(time() - $oldest[0]) /
                    floatval(C\ONE_HOUR);
                $change_in_urls = $recent[1] - $oldest[1];
                $data[$channel]['VISITED_URLS_COUNT_PER_HOUR'] =
                    max((($change_in_time_hours > 0) ?
                    $change_in_urls/$change_in_time_hours : 0), 0);
            } else {
                $data[$channel]['VISITED_URLS_COUNT_PER_HOUR'] = 0;
            }
        }
        return $data;
    }
    /**
     * When @see crawlStatus() is used in a multi-queue server this method
     * used to integrate the status information received by the different
     * machines
     *
     * @param array $status_strings list of one web-encoded serialized
     *     status string per machine, each carrying the
     *     per-channel status info for that machine
     * @param string $data_field field of $status_strings to use for data
     * @return array associative array of DESCRIPTION, TIMESTAMP,
     * peak memory of various processes, most recent fetcher, most recent
     * urls, urls seen, urls visited, etc.
     */
    public function aggregateStatuses($status_strings, $data_field = null)
    {
        $status = [];
        $init_channel_status = [
            'WEBAPP_PEAK_MEMORY' => 0,
            'FETCHER_PEAK_MEMORY' => 0,
            'QUEUE_PEAK_MEMORY' => 0,
            'SCHEDULER_PEAK_MEMORY' => 0,
            'COUNT' => 0,
            'VISITED_URLS_COUNT' => 0,
            'VISITED_URLS_COUNT_PER_HOUR' => 0,
            'MOST_RECENT_TIMESTAMP' => 0,
            'DESCRIPTION' => "",
            'MOST_RECENT_FETCHER' => "",
            'MOST_RECENT_URLS_SEEN' => [],
            'CRAWL_TIME' => 0
        ];
        set_error_handler(null);
        foreach ($status_strings as $status_string) {
            $a_status = @unserialize(L\webdecode(
                    $status_string[self::PAGE]));
            if ($data_field != null) {
                $a_status = $a_status[$data_field] ?? false;
            }
            $count_fields = ["COUNT", "VISITED_URLS_COUNT_PER_HOUR",
                "VISITED_URLS_COUNT"];
            if (empty($a_status)) {
                continue;
            }
            foreach ($a_status as $channel => $a_status_data) {
                if (empty($status[$channel])) {
                    $status[$channel] = $init_channel_status;
                }
                foreach ($count_fields as $field) {
                    if (isset($a_status_data[$field])) {
                        $status[$channel][$field] += $a_status_data[$field];
                    }
                }
                if (isset($a_status_data["CRAWL_TIME"]) &&
                    $a_status_data["CRAWL_TIME"] >=
                    $status[$channel]['CRAWL_TIME']) {
                    $status[$channel]['CRAWL_TIME'] =
                        $a_status_data["CRAWL_TIME"];
                    $text_fields = ["DESCRIPTION", "MOST_RECENT_FETCHER"];
                    foreach ($text_fields as $field) {
                        if (isset($a_status_data[$field])) {
                            if ($status[$channel][$field] == "" ||
                                in_array($status[$channel][$field],
                                    ["BEGIN_CRAWL", "RESUME_CRAWL"])) {
                                $status[$channel][$field] =
                                    $a_status_data[$field];
                            }
                        }
                    }
                }
                if (isset($a_status_data["MOST_RECENT_TIMESTAMP"]) &&
                    $status[$channel]["MOST_RECENT_TIMESTAMP"] <=
                        $a_status_data["MOST_RECENT_TIMESTAMP"]) {
                    $status[$channel]["MOST_RECENT_TIMESTAMP"] =
                        $a_status_data["MOST_RECENT_TIMESTAMP"];
                    if (isset($a_status_data['MOST_RECENT_URLS_SEEN'])) {
                        $status[$channel]['MOST_RECENT_URLS_SEEN'] =
                            $a_status_data['MOST_RECENT_URLS_SEEN'];
                    }
                }
                $memory_fields = ["WEBAPP_PEAK_MEMORY", "FETCHER_PEAK_MEMORY",
                    "QUEUE_PEAK_MEMORY", "SCHEDULER_PEAK_MEMORY"];
                foreach ($memory_fields as $field) {
                    $a_status_data[$field] = (isset($a_status_data[$field])) ?
                        $a_status_data[$field] : 0;
                    $status[$channel][$field] =
                        max($status[$channel][$field], $a_status_data[$field]);
                }
            }
        }
        restore_error_handler();
        return $status;
    }
    /**
     * This method is used to reduce the number of network requests
     * needed by the crawlStatus method of admin_controller. It returns
     * an array containing the results of the @see crawlStalled
     * @see crawlStatus and @see getCrawlList methods
     *
     * @param array $machine_urls an array of urls of yioop queue servers
     * @param bool $use_cache whether to try to use a cached version of the
     *      the crawl info or to always recompute it.
     * @return array containing three components one for each of the three
     *     kinds of results listed above
     */
    public function combinedCrawlInfo($machine_urls = null, $use_cache = false)
    {
        if ($machine_urls != null && !$this->isSingleLocalhost($machine_urls)) {
            $combined_crawl_info_file = C\CACHE_DIR .
                "/CombinedCrawlInfo.txt";
            if ($use_cache && file_exists($combined_crawl_info_file) &&
                filemtime($combined_crawl_info_file) + C\MIN_QUERY_CACHE_TIME <
                time()) {
                return unserialize(file_get_contents(
                    $combined_crawl_info_file));
            }
            $combined_strings =
                $this->execMachines("combinedCrawlInfo", $machine_urls);
            $combined = [];
            $combined[] = $this->aggregateStalled($combined_strings,
                0);
            $combined[] = $this->aggregateStatuses($combined_strings,
                1);
            $combined[] = $this->aggregateCrawlList($combined_strings,
                2);
            if (!file_exists($combined_crawl_info_file) ||
                filemtime($combined_crawl_info_file) + C\MIN_QUERY_CACHE_TIME >
                time()) {
                file_put_contents($combined_crawl_info_file,
                    serialize($combined));
            }
            return $combined;
        }
        $combined = [];
        $combined[] = $this->crawlStalled();
        $combined[] = $this->crawlStatus();
        $combined[] = $this->getCrawlList(false, true);
        return $combined;
    }
    /**
     * Add the provided urls to the schedule directory of URLs that will
     * be crawled
     *
     * @param string $timestamp Unix timestamp of crawl to add to schedule of
     * @param array $inject_urls urls to be added to the schedule of
     *     the active crawl
     * @param array $machine_urls an array of urls of yioop queue servers
     * @return bool true when the URLs were successfully written to the
     *     schedule directory; false on write failure; void when the
     *     call was forwarded to remote queue servers
     */
    public function injectUrlsCurrentCrawl($timestamp, $inject_urls,
        $machine_urls = null)
    {
        if ($machine_urls != null &&
            !$this->isSingleLocalhost($machine_urls, $timestamp)) {
            $this->execMachines("injectUrlsCurrentCrawl", $machine_urls,
                serialize(array($timestamp, $inject_urls)));
            return;
        }

        $dir = C\SCHEDULES_DIR . "/" . self::schedule_data_base_name .
            $timestamp;
        if (!file_exists($dir)) {
            mkdir($dir);
            chmod($dir, 0777);
        }
        $day = floor($timestamp/C\ONE_DAY) - 1;
            /* want before all other schedules,
               execute next */
        $dir .= "/$day";
        if (!file_exists($dir)) {
            mkdir($dir);
            chmod($dir, 0777);
        }
        $count = count($inject_urls);
        if ($count > 0) {
            $now = time();
            $schedule_data = [];
            $schedule_data[self::SCHEDULE_TIME] =
                $timestamp;
            $schedule_data[self::TO_CRAWL] = [];
            for ($i = 0; $i < $count; $i++) {
                $url = $inject_urls[$i];
                $hash = L\crawlHash($now.$url);
                $schedule_data[self::TO_CRAWL][] =
                    [$url, 1, $hash];
            }
            $data_string = L\webencode(
                gzcompress(serialize($schedule_data)));
            $data_hash = L\crawlHash($data_string);
            file_put_contents($dir."/At1From127-0-0-1".
                "WithHash$data_hash.txt", $data_string);
            return true;
        }
        return false;
    }
}
