phpDocumentor InternetAccessLog
[ class tree: InternetAccessLog ] [ index: InternetAccessLog ] [ all elements ]
InternetAccessLog
Packages:
InternetAccessLog

Source for file MongoRandomElements.class.php

Documentation is available at MongoRandomElements.class.php

  1. <?php
  2. /**
  3.  *  MongoRandomElements.class.php
  4.  *  File with the class used to generate random elements and save then in MongoDB (users, URL's ...)
  5.  *  @author José Manuel Ciges Regueiro <jmanuel@ciges.net>, Web page {@link http://www.ciges.net}
  6.  *  @license http://www.gnu.org/copyleft/gpl.html GNU GPLv3
  7.  *  @version 20121220
  8.  *
  9.  *  @package InternetAccessLog
  10.  *  @filesource
  11.  */
  12. require_once("RandomElements.class.php");
  13.  /**
  14.  *  This class is used to generate random elements (users, IP's and URL's) and save them into MongoDB
  15.  *  With this elements created we can simulate non FTP and FTP log entries (in our demo the acces by FTP are stored in a separate collection)
  16.  */
  17.  class MongoRandomElements extends RandomElements    {
  18.  
  19.     /**#@+
  20.      *  Default names for random data collections
  21.      */
  22.     const RNDUSERSC_NAME = "Random_UsersList";
  23.     const RNDIPSC_NAME = "Random_IPsList";
  24.     const RNDDOMAINSC_NAME = "Random_DomainsList";
  25.     const NONFTPLOG_NAME = "NonFTP_Access_log";
  26.     const FTPLOG_NAME = "FTP_Access_log";
  27.     /**#@-*/
  28.     
  29.     /**#@+
  30.      *  Default prefixes for monthly reports
  31.      */
  32.     const USERS_REPORT_PREFIX = "Users_Monthly_Report_";
  33.     const DOMAINS_REPORT_PREFIX = "Domains_Monthly_Report_";
  34.     /**#@-*/
  35.     
  36.     /**#@+
  37.      * Constants for default connection values
  38.      */
  39.     const DEFAULT_USER = "mongodb";
  40.     const DEFAULT_PASSWORD = "mongodb";
  41.     const DEFAULT_HOST = "localhost";
  42.     const DEFAULT_DB = "InternetAccessLog";
  43.     const DEFAULT_SAFEMODE = false;
  44.     /**#@-*/
  45.     
  46.     /**
  47.      * Connection to the database
  48.      * @access private
  49.      * @var Mongo 
  50.      */
  51.     private $db_conn;
  52.     /**
  53.      * Database name
  54.      * @access private
  55.      * @var Mongo 
  56.      */
  57.     private $db_databasename;
  58.     
  59.     /**#@+
  60.      * Number of element of each created collection in MongoDB (for cache purposes)
  61.      * @access private
  62.      * @var string
  63.      */
  64.     private $rnd_users_number;
  65.     private $rnd_ips_number;
  66.     private $rnd_domains_number;
  67.     /**#@-*/
  68.  
  69.     /** 
  70.     *  This function queries the database to return the users number (records in Random_UsersList)
  71.     *  @return integer 
  72.     *  @access public
  73.     */
  74.     public function getUserNumber() {
  75.         $this->rnd_users_number = $this->getUserCollection()->count();
  76.         return $this->rnd_users_number;
  77.     }
  78.  
  79.     /**
  80.      *  This function returns the username searching by the id
  81.      *  @param integer $userid 
  82.      *  @return string $username
  83.      *  @access public
  84.      */
  85.     public function getUserFromID($userid) {
  86.         $cursor = $this->getUserCollection()->find(array('_id' => $userid));
  87.         if ($cursor->hasNext()) {
  88.             $row = $cursor->getNext();
  89.             return $row['user'];
  90.         }
  91.     }
  92.  
  93.     /** 
  94.     *  This function queries the database to return the domains number (records in Random_DomainsList)
  95.     *  @return integer 
  96.     *  @access public
  97.     */
  98.     public function getDomainNumber() {
  99.         $this->rnd_domains_number = $this->getDomainCollection()->count();
  100.         return $this->rnd_domains_number;
  101.     }
  102.  
  103.     /**
  104.      *  This function returns the domain searching by the id. If the domain does not exist null is returner
  105.      *  @param integer $id 
  106.      *  @return string $domain
  107.      *  @access public
  108.      */
  109.     public function getDomainFromID($id) {
  110.         $cursor = $this->getDomainCollection()->find(array('_id' => $id));
  111.         if ($cursor->hasNext()) {
  112.             $row = $cursor->getNext();
  113.             return $row['domain'];
  114.         }
  115.     }
  116.     
  117.     /**
  118.      *  This function returns the user data from the reports for a year and month specified. If there is no data returns null
  119.      *  @param string $username 
  120.      *  @param integer $year 
  121.      *  @param integer $month   Number from 1 to 12
  122.      *  @return array 
  123.      *  @access public
  124.      */
  125.     public function getUserCollectedData($username, $year, $month)  {
  126.         $col = self::USERS_REPORT_PREFIX.$year.sprintf("%02d", $month);
  127.         $cursor = $this->getDB()->$col->find(array('_id' => $username));
  128.         if ($cursor->hasNext()) {
  129.             return $cursor->getNext();
  130.         }
  131.     }
  132.  
  133.     /**
  134.      *  This function returns the domain data from the reports for a year and month specified. If there is no data returns null
  135.      *  @param string $domainname 
  136.      *  @param integer $year 
  137.      *  @param integer $month   Number from 1 to 12
  138.      *  @return array 
  139.      *  @access public
  140.      */
  141.     public function getDomainCollectedData($domainname, $year, $month)  {
  142.         $col = self::DOMAINS_REPORT_PREFIX.$year.sprintf("%02d", $month);
  143.         $cursor = $this->getDB()->$col->find(array('_id' => $domainname));
  144.         if ($cursor->hasNext()) {
  145.             return $cursor->getNext();
  146.         }
  147.     }
  148.  
  149.     /**
  150.      *  This function add a fake user to the collection passed as second argument. If not collection done then the user will be added to Random_UsersList.
  151.      *  This function is coded for load tests, not for real user. The id is the id generated by Mongo
  152.      *  Returns true if the user has been succesfull added, false if not
  153.      *  @param string $username 
  154.      *  @param string $collectionname 
  155.      *  @access public
  156.      *  @return boolean 
  157.      */
  158.     public function addFakeUser($username, $collectionname = self::RNDUSERSC_NAME)   {
  159.         $user_col = $this->getDB()->$collectionname;
  160.         try {
  161.             $doc = array("user" => $username);
  162.             $user_col->insert($doc, array("safe" => $this->safemode));
  163.             return true;
  164.         }
  165.         catch (MongoConnectionException $e) {
  166.             return false;
  167.         }
  168.     }
  169.     
  170.     /**
  171.      *  This function verifies if the user exists in the collection passed as second argument. If not collection done then the user will be added to Random_UsersList.
  172.      *  @param string $username 
  173.      *  @param string $tablename 
  174.      *  @return boolean 
  175.      *  @access public
  176.      */
  177.     public function existUser($username, $collectionname = self::RNDUSERSC_NAME)    {
  178.         $cursor = $this->getDB()->$collectionname->find(array('user' => $username))->limit(1); 
  179.         $cursor->count() > 0;
  180.     }
  181.     
  182.     /**
  183.      *  Constructor. For creating an instance we need to pass all the parameters for the MongoDB database where the data will be stored (user, password, host & database name). The fifth parameter tells if the insertions will we made in safe mode or not (by default they are NOT safe)
  184.      *  <ul>
  185.      *  <li>The default user and password will be mongodb
  186.      *  <li>The default host will be localhost
  187.      *  <li>The default database name will be InternetAccessLog
  188.      *  <li>Inertions will be NOT safe by default
  189.      *  </ul>
  190.      *  @param string $user 
  191.      *  @param string $password 
  192.      *  @param string $host 
  193.      *  @param string $database 
  194.      *  @param boolean $safemode 
  195.      */
  196.     function __construct($user = self::DEFAULT_USER, $password = self::DEFAULT_PASSWORD, $host = self::DEFAULT_HOST, $database = self::DEFAULT_DB, $safemode = self::DEFAULT_SAFEMODE)    {
  197.         // Open a connection to MongoDB
  198.         try {
  199.             $this->db_conn = new Mongo("mongodb://".$user.":".$password."@".$host."/".$database);
  200.             $this->db_databasename = $database;
  201.         }
  202.         catch (MongoConnectionException $e) {
  203.             die("Connection to MongoDB impossible: (".$e->getCode().") ".$e->getMessage()."\n");
  204.         }
  205.         
  206.         // Stores the number of elements of each stored random elements collection
  207.         $db = $this->db_databasename;
  208.         $this->safemode = $safemode;
  209.         $userscol_name = self::RNDUSERSC_NAME;
  210.         $ipscol_name = self::RNDIPSC_NAME;
  211.         $domainscol_name = self::RNDDOMAINSC_NAME;
  212.         $nonftp_log_name = self::NONFTPLOG_NAME;
  213.         $ftp_log_name = self::FTPLOG_NAME;
  214.         $this->rnd_users_number =  $this->db_conn->$db->$userscol_name->count();
  215.         $this->rnd_ips_number = $this->db_conn->$db->$ipscol_name->count();
  216.         $this->rnd_domains_number = $this->db_conn->$db->$domainscol_name->count();
  217.     }
  218.  
  219.     /**
  220.      *  Destructor. Close the open connection to MongoDB database
  221.       */
  222.     function __destruct()    {
  223.         $this->db_conn->close();
  224.     }
  225.     
  226.     /**
  227.      *  Get the connection created to the database (the db, not the server)
  228.      *  @return MongoDB 
  229.      */
  230.      public function getDB()    {
  231.         $databasename = $this->db_databasename;
  232.         return $this->db_conn->$databasename;
  233.      }
  234.  
  235.     /**
  236.      *  Sends an aggregation array of commands to the database and returns the results (array of documents). If no documents are got null is returned
  237.      *  @param array $pipeline 
  238.      *  @param string $collection 
  239.      *  @return array 
  240.      *  @access public
  241.      */
  242.     public function getResults($pipeline, $collection = "NonFTP_Access_log")    {
  243.         $db = $this->getDB();
  244.         MongoCursor::$timeout = -1;         
  245.         $data = $this->getDB()->command (
  246.             array(
  247.                 "aggregate" => $collection,
  248.                 "pipeline" => $pipeline
  249.             ));
  250.         return $data['result'];
  251.     }
  252.      
  253.     /**
  254.      *  Sends an aggregation array of commands to the database and returns the first document. If no documents are got null is returned
  255.      *  @param array $pipeline 
  256.      *  @param string $collection 
  257.      *  @return array 
  258.      *  @access public
  259.      */
  260.     public function getRow($pipeline, $collection = "NonFTP_Access_log")    {        
  261.         $data = $this->getResults($pipeline, $collection);
  262.         return $data[0];
  263.     }
  264.  
  265.     /**
  266.      *  Sends an aggregation array of commands to the database and returns the field '_id' of the first document. If no documents are got null is returned
  267.      *  @param array $pipeline 
  268.      *  @param string $collection 
  269.      *  @return array 
  270.      *  @access public
  271.      */
  272.     public function getOne($pipeline, $collection)    {
  273.         $row = $this->getRow($pipeline, $collection);
  274.         return $row['_id'];
  275.     }
  276.  
  277.     /**
  278.      *  Get a link to the users collection
  279.      *  @return MongoCollection 
  280.      */
  281.     public function getUserCollection() {
  282.         $user_col_name = MongoRandomElements::RNDUSERSC_NAME;
  283.         return $this->getDB()->$user_col_name;
  284.     }
  285.  
  286.     /**
  287.      *  Get a link to the domains collection
  288.      *  @return MongoCollection 
  289.      */
  290.     public function getDomainCollection() {
  291.         $user_col_name = MongoRandomElements::RNDDOMAINSC_NAME;
  292.         return $this->getDB()->$user_col_name;
  293.     }
  294.     
  295.     /**
  296.      *  Save random users in MongoDB.
  297.      *  The parameters are the number of users to create and to booleans: if we want an unique index to be created for the user name (default is TRUE) and if we want that the user name is unique (default TRUE).
  298.      *  If the user name is going to be unique the existence of the name is verified with a query before inserting a new one.
  299.      *  The id will be autonumeric (1, 2, 3 ....)
  300.      *  @param integer $number 
  301.      *  @param boolean $use_index 
  302.      *  @param boolean $dont_repeat 
  303.      */
  304.     function createUsers($number, $use_index = TRUE, $dont_repeat = TRUE)    {
  305.         $id = $this->rnd_users_number + 1;   // Autonumeric
  306.         
  307.         $db = $this->db_databasename;      
  308.         $col_name = self::RNDUSERSC_NAME;
  309.         $col = $this->db_conn->$db->$col_name;
  310.         
  311.         if ($use_index) {
  312.             $col->ensureIndex(array('user' => 1), array("unique" => true));    // Unique index for the 'user' field
  313.         }
  314.         $i = 1;
  315.         while ($i <= $number)    {
  316.             $user = $this->getRandomUser();
  317.             // We verify if the user is in the collection only if it is needed
  318.             $insert = TRUE;
  319.             if ($dont_repeat) {
  320.                 $cursor = $col->find(array("user" => $user))->limit(1);
  321.                 if ($cursor->count() > 0)  {
  322.                     $insert = FALSE;
  323.                 }
  324.             }
  325.             if ($insert)   {
  326.                 try {
  327.                     $col->insert(array("_id" => $id, "user" => $user), array("safe" => $this->safemode));
  328.                     $id++;
  329.                 }
  330.                 catch (MongoConnectionException $e) {
  331.                     die("Save of user document in MongoDB not possible: (".$e->getCode().") ".$e->getMessage()."\n");
  332.                 }
  333.                 $i++;
  334.             }
  335.         }
  336.         $this->rnd_users_number = $col->count();
  337.     }
  338.     
  339.     /**
  340.      *  Returns true if the random users collection has at least one user
  341.      *  @return boolean 
  342.      */
  343.     function randomUsers_exists()    {
  344.         $db = $this->db_databasename;
  345.         $col = self::RNDUSERSC_NAME;
  346.         $this->db_conn->$db->$col->count() > 0 ? true : false;
  347.     }
  348.  
  349.     /**
  350.      *  Save random IPs in MongoDB
  351.      *  The parameters are the number of IPs to create and to booleans: if we want an unique index to be created for the ip (default is TRUE) and if we want that the ip is unique (default TRUE).
  352.      *  If the ip is going to be unique the existence of the name is verified with a query before inserting a new one
  353.      *  The id will be autonumeric (1, 2, 3 ....)
  354.      *  @param integer $number 
  355.      *  @param boolean $use_index 
  356.      *  @param boolean $dont_repeat_users 
  357.      ***/
  358.     function createIPs($number, $use_index = TRUE, $dont_repeat = TRUE)    {
  359.         $id = $this->rnd_ips_number + 1;   // Autonumeric
  360.         
  361.         $db = $this->db_databasename;      
  362.         $col_name = self::RNDIPSC_NAME;
  363.         $col = $this->db_conn->$db->$col_name;
  364.         
  365.         if ($use_index) {
  366.             $col->ensureIndex(array('ip' => 1), array("unique" => true));    // Unique index for the 'ip' field
  367.         }
  368.         $i = 1;
  369.         while ($i <= $number)    {
  370.             $ip = $this->getRandomIP();
  371.             // We verify if the user is in the collection only if it is needed
  372.             $insert = TRUE;
  373.             if ($dont_repeat) {
  374.                 $cursor = $col->find(array("ip" => $ip))->limit(1);
  375.                 if ($cursor->count() > 0)  {
  376.                     $insert = FALSE;
  377.                 }
  378.             }
  379.             if ($insert)   {
  380.                 try {
  381.                     $col->insert(array("_id" => $id, "ip" => $ip), array("safe" => $this->safemode));
  382.                     $id++;
  383.                 }
  384.                 catch (MongoConnectionException $e) {
  385.                     die("Save of IP document in MongoDB not possible: (".$e->getCode().") ".$e->getMessage()."\n");
  386.                 }
  387.                 $i++;
  388.             }
  389.         }    
  390.         $this->rnd_ips_number = $col->count();
  391.     }    
  392.     
  393.     /**
  394.      *  Returns true if the IPs collection has at least one IP
  395.      *  @return boolean 
  396.      */
  397.     function randomIPs_exists()    {
  398.         $db = $this->db_databasename;
  399.         $col = self::RNDIPSC_NAME;
  400.         $this->db_conn->$db->$col->count() > 0 ? true : false;
  401.     }
  402.  
  403.     /**
  404.      *  Save random domains in MongoDB
  405.      *  The parameter are the number of domains to create and to booleans: if we want an unique index to be created for the domain (default is TRUE) and if we want that the domain is unique (default TRUE).
  406.      *  If the domain is going to be unique the existence of the name is verified with a query before inserting a new one
  407.      *  The id will be autonumeric (1, 2, 3 ....)
  408.      *  @param integer $number 
  409.      *  @param boolean $use_index 
  410.      *  @param boolean $dont_repeat_users 
  411.      */
  412.     function createDomains($number, $use_index = TRUE, $dont_repeat = TRUE)    {
  413.         $id = $this->rnd_domains_number + 1;   // Autonumeric
  414.         
  415.         $db = $this->db_databasename;      
  416.         $col_name = self::RNDDOMAINSC_NAME;
  417.         $col = $this->db_conn->$db->$col_name;
  418.         
  419.         if ($use_index) {
  420.             $col->ensureIndex(array('domain' => 1), array("unique" => true));    // Unique index for the 'domain' field
  421.         }
  422.         $i = 1;
  423.         while ($i <= $number)    {
  424.             $domain = $this->getRandomDomain();
  425.             // We verify if the user is in the collection only if it is needed
  426.             $insert = TRUE;
  427.             if ($dont_repeat) {
  428.                 $cursor = $col->find(array("domain" => $domain))->limit(1);
  429.                 if ($cursor->count() > 0)  {
  430.                     $insert = FALSE;
  431.                 }   
  432.             }
  433.             if ($insert)   {
  434.                 try {
  435.                     $col->insert(array("_id" => $id, "domain" => $domain), array("safe" => $this->safemode));
  436.                     $id++;
  437.                 }
  438.                 catch (MongoConnectionException $e) {
  439.                     die("Save of domain document in MongoDB not possible: (".$e->getCode().") ".$e->getMessage()."\n");
  440.                 }
  441.                 $i++;
  442.             }
  443.         }
  444.         $this->rnd_domains_number = $col->count();
  445.     }
  446.     
  447.     /**
  448.      *  Returns true if the random domains collection has at least one domain
  449.      *  @return boolean 
  450.      */
  451.     function randomDomains_exists()    {
  452.         $db = $this->db_databasename;
  453.         $col = self::RNDDOMAINSC_NAME;
  454.         $this->db_conn->$db->$col->count() > 0 ? true : false;
  455.     }
  456.  
  457.     /**
  458.      *  Returns a random IP from the generated collection
  459.      *  @returns string
  460.      */
  461.     function searchIP()    {
  462.         $position = mt_rand(1, $this->rnd_ips_number);
  463.         $col = self::RNDIPSC_NAME;
  464.         $cursor = $this->getDB()->$col->find(array('_id' => $position));
  465.         if ($cursor->hasNext()) {
  466.             $row = $cursor->getNext();
  467.             return $row['ip'];
  468.         }
  469.     }
  470.     
  471.     /**
  472.      *  Returns a random user from the generated collection
  473.      *  @return string 
  474.      */
  475.     function searchUser()    {
  476.         $position = mt_rand(1, $this->rnd_users_number);
  477.         $db = $this->db_databasename;
  478.         $col = self::RNDUSERSC_NAME;
  479.         $cursor = $this->getDB()->$col->find(array('_id' => $position));
  480.         if ($cursor->hasNext()) {
  481.             $row = $cursor->getNext();
  482.             return $row["user"];
  483.         }
  484.     }
  485.     
  486.     /**
  487.      *  Returns a random HTTP method from the generated collection
  488.      *  @returns string
  489.      */
  490.     function searchHTTPMethod()    {
  491.         return $this->getRandomHTTPMethod();
  492.     }
  493.     
  494.     /**
  495.      *  Returns a random FTP method from the generated collection
  496.      *  @returns string
  497.      */
  498.     function searchFTPMethod()    {
  499.         return $this->getRandomFTPMethod();
  500.     }
  501.     
  502.     /**
  503.      *  Returns a random domain
  504.      *  @returns string
  505.      */
  506.     function searchDomain() {
  507.         $position = mt_rand(1, $this->rnd_domains_number);
  508.         $col = self::RNDDOMAINSC_NAME;
  509.         $cursor = $this->getDB()->$col->find(array("_id" => $position));
  510.         if ($cursor->hasNext()) {
  511.             $row = $cursor->getNext();
  512.             return $row["domain"];
  513.         }
  514.     }
  515.     
  516.     /**
  517.      *  Returns a random URI
  518.      *  @returns string
  519.      */
  520.     function searchURI()    {
  521.         return $this->getRandomString(mt_rand(0,100));
  522.     }
  523.  
  524.     /**
  525.      *  Returns a random size
  526.      *  @returns integer
  527.      */
  528.     function searchSize()    {
  529.         return $this->getRandomSize();
  530.     }
  531.  
  532.     /**
  533.      *  Returns a random protocol
  534.      *  @returns string
  535.      */
  536.     function searchProtocol()    {
  537.         return $this->getRandomProtocol();
  538.     }
  539.     
  540.     /**
  541.      *  Returns a random return code
  542.      *  @returns integer
  543.      */
  544.     function searchReturnCode()    {
  545.         return $this->getRandomRetourCode();
  546.     }
  547.  
  548.     /**
  549.      *  Return a random log entry for non FTP access (http and tunnel)
  550.      *  It has two optional arguments, initial and final timestamps, if we want to get a random time in log entry created
  551.      *  @param integer $initial_timestamp 
  552.      *  @param integer $final_timestamp 
  553.      *  @returns array
  554.      */
  555.     function getRandomNonFTPLogEntry()    {
  556.         if (func_num_args() == 2)    {    
  557.             $initial_timestamp = func_get_arg(0);
  558.             $final_timestamp =  func_get_arg(1);
  559.             $ts = mt_rand($initial_timestamp, $final_timestamp);
  560.         }
  561.         elseif (func_num_args() != 0)    {
  562.             $arguments = func_get_args();
  563.             die("Incorrect arguments number in getRrandomSORLogEntry function: ".implode(" ", $arguments)."\n");
  564.         }
  565.         else {
  566.             $ts = time();
  567.         }
  568.         
  569.         $document = array(
  570.             'clientip' => $this->searchIP(),
  571.             'user' => $this->searchUser(),
  572.             'datetime' => $ts,
  573.             'method' => $this->searchHTTPMethod(),
  574.             'protocol' => $this->searchProtocol(),
  575.             'domain' => $this->searchDomain(),
  576.             'uri' => $this->searchURI(),
  577.             'return_code' => $this->searchReturnCode(),
  578.             'size' => $this->searchSize()    // Size is recorded in the database as string
  579.         );
  580.         
  581.         return $document;
  582.     }
  583.     
  584.     /**
  585.      *  Update Users or Domains monthly and daily report
  586.      *  This function is private and is meant to be used each time an access log is processed to have real time statistics
  587.      *  @param string $collection_name 
  588.      *  @param string $id document id (user or domain name)
  589.      *  @param timestamp $timestamp 
  590.      *  @param integer $volume 
  591.      *  @access private
  592.      */
  593.     function saveReport($collection_name, $id, $timestamp, $volume)  {
  594.     
  595.         $db = $this->db_databasename;
  596.         $col = $this->db_conn->$db->$collection_name;
  597.         # Document creation if it not exists
  598.         try {
  599.             $cursor = $col->find(array("_id" => $id));
  600.             if ($cursor->count() == 0) {
  601.                 $col->insert(array('_id' => $id), array("safe" => $this->safemode));
  602.             }
  603.     
  604.             # Updating monthly and daily values
  605.             $day = (int) strftime("%e", $timestamp);
  606.             $col->update(
  607.                 array('_id' => $id),
  608.                 array('$inc' => array(
  609.                     'nb' => 1, 
  610.                     'volume' => $volume,
  611.                     "daily.$day.nb" => 1,
  612.                     "daily.$day.volume" => $volume
  613.                     )
  614.                 ),
  615.                 array("safe" => $this->safemode)
  616.             );
  617.         }
  618.         catch (MongoException $e) {
  619.             die("Saving/Updating data to ".$collection_name." collection for id ".$id." not possible: (".$e->getCode().") ".$e->getMessage()."\n");
  620.         }
  621.     }
  622.  
  623.     /**
  624.      *  Reads ALL logs entries fron both collections NonFTP and FTP and saves reports entries for users and domains
  625.      *  @access public
  626.      */
  627.     function generateReports()  {
  628.         $log_collections = array(self::NONFTPLOG_NAME, self::FTPLOG_NAME);
  629.         foreach ($log_collections as $col)  {
  630.             $cursor = $this->getDB()->$col->find();
  631.             $i = 1;
  632.             while ($cursor->hasNext()) {
  633.                 $log_entry = $cursor->getNext();
  634.                 $timestamp = $log_entry["datetime"]->sec;
  635.                 $yearmonth = strftime("%Y%m", $timestamp);
  636.                 $this->saveReport(self::USERS_REPORT_PREFIX.$yearmonth, $log_entry["user"], $timestamp, $log_entry['size']);
  637.                 $this->saveReport(self::DOMAINS_REPORT_PREFIX.$yearmonth, $log_entry["domain"], $timestamp, $log_entry['size']);
  638.                 
  639.                 if ($i % 10000 == 0)    {
  640.                     printf("%d\n", $i);
  641.                     }
  642.                 $i++;
  643.             }
  644.         }
  645.     }
  646.  
  647.     /**
  648.      *  Receives a log entry and saves the data and, optionally, monthly and daily precalculated values in database.
  649.      *  By default the reports are created. If the second argument is FALSE they will not be generated
  650.      *  The id for the document in Mongo is created automatically by MongoDB (as an ObjectID)
  651.      *
  652.      *  @param array $log_entry log entry as returned by {@link getRandomNonFTPLogEntry}
  653.      *  @param boolean $create_reports 
  654.      */
  655.     function saveRandomNonFTPLogEntry($log_entry, $create_reports=TRUE)    {
  656.         $document = $log_entry;
  657.         $document["datetime"] = new MongoDate($log_entry["datetime"]);
  658.         
  659.         $db = $this->db_databasename;
  660.         $nonftp_log_name = self::NONFTPLOG_NAME;
  661.         $col = $this->db_conn->$db->$nonftp_log_name;
  662.         try {
  663.             $col->insert($document, array("safe" => $this->safemode));
  664.         }
  665.         catch (MongoException $e) {
  666.             die("Saving document to SOR_Access_log collection not possible: (".$e->getCode().") ".$e->getMessage()."\n");
  667.         }
  668.         
  669.         # Monthly reports data update
  670.         if ($create_reports)    {
  671.             $timestamp = $log_entry["datetime"];
  672.             $yearmonth = strftime("%Y%m", $timestamp);
  673.             $this->saveReport(self::USERS_REPORT_PREFIX.$yearmonth, $document["user"], $timestamp, $document['size']);
  674.             $this->saveReport(self::DOMAINS_REPORT_PREFIX.$yearmonth, $document["domain"], $timestamp, $document['size']);
  675.         }
  676.         
  677.     }
  678.  
  679.     /**
  680.      *  Return a random log entry for FTP access. It is very similar to HTTP and tunnel access but with less fields (there is no protocol and return code)
  681.      *  It has two optional arguments, initial and final timestamps, if we want to get a random time in log entry created
  682.      *  @param integer $initial_timestamp 
  683.      *  @param integer $final_timestamp 
  684.      *  @returns array
  685.      */
  686.     function getRandomFTPLogEntry()    {
  687.         if (func_num_args() == 2)    {    
  688.             $initial_timestamp = func_get_arg(0);
  689.             $final_timestamp =  func_get_arg(1);
  690.             $ts = mt_rand($initial_timestamp, $final_timestamp);
  691.         }
  692.         elseif (func_num_args() != 0)    {
  693.             $arguments = func_get_args();
  694.             die("Incorrect arguments number in getRrandomSORLogEntry function: ".implode(" ", $arguments)."\n");
  695.         }
  696.         else {
  697.             $ts = time();
  698.         }
  699.         
  700.         $document = array(
  701.             'clientip' => $this->searchIP(),
  702.             'user' => $this->searchUser(),
  703.             'datetime' => $ts,
  704.             'method' => $this->searchFTPMethod(),
  705.             'domain' => $this->searchDomain(),
  706.             'uri' => $this->searchURI(),
  707.             'size' => $this->searchSize()    // Size is recorded in the database as string
  708.         );
  709.         
  710.         return $document;
  711.     }
  712.  
  713.     /**
  714.      *  Receives a FTP log entry and saves the data and, optionally, monthly and daily precalculated values in database.
  715.      *  By default the reports are created. If the second argument is FALSE they will not be generated
  716.      *  The id for the document in Mongo is created automatically by MongoDB (as an ObjectID)
  717.      *
  718.      *  @param array $log_entry log entry as returned by {@link getRandomNonFTPLogEntry}
  719.      *  @param boolean $create_reports 
  720.      */
  721.     function saveRandomFTPLogEntry($log_entry, $create_reports=TRUE)    {
  722.         $document = $log_entry;
  723.         $document["datetime"] = new MongoDate($log_entry["datetime"]);
  724.         
  725.         $db = $this->db_databasename;
  726.         $nonftp_log_name = self::FTPLOG_NAME;
  727.         $col = $this->db_conn->$db->$nonftp_log_name;
  728.         try {
  729.             $col->insert($document, array("safe" => $this->safemode));
  730.         }
  731.         catch (MongoException $e) {
  732.             die("Saving document to SOR_Access_log collection not possible: (".$e->getCode().") ".$e->getMessage()."\n");
  733.         }
  734.         
  735.         # Monthly reports data update
  736.         if ($create_reports)    {
  737.             $timestamp = $log_entry["datetime"];
  738.             $yearmonth = strftime("%Y%m", $timestamp);
  739.             $this->saveReport(self::USERS_REPORT_PREFIX.$yearmonth, $document["user"], $timestamp, $document['size']);
  740.             $this->saveReport(self::DOMAINS_REPORT_PREFIX.$yearmonth, $document["domain"], $timestamp, $document['size']);
  741.         }
  742.         
  743.     }
  744.     
  745. }
  746.  
  747. ?>
Documentation generated on Fri, 12 Apr 2013 12:02:19 +0200 by phpDocumentor 1.4.4