DeciderAgent.php

Go to the documentation of this file.

<?php
/*
 Author: Daniele Fognini
 Copyright (C) 2014-2019, Siemens AG

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.

 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, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
namespace Fossology\Decider;

use Fossology\Lib\Agent\Agent;
use Fossology\Lib\BusinessRules\AgentLicenseEventProcessor;
use Fossology\Lib\BusinessRules\ClearingDecisionProcessor;
use Fossology\Lib\BusinessRules\LicenseMap;
use Fossology\Lib\Dao\ClearingDao;
use Fossology\Lib\Dao\HighlightDao;
use Fossology\Lib\Dao\UploadDao;
use Fossology\Lib\Data\DecisionTypes;
use Fossology\Lib\Data\LicenseMatch;
use Fossology\Lib\Data\Tree\Item;
use Fossology\Lib\Data\Tree\ItemTreeBounds;
use Fossology\Lib\Dao\ShowJobsDao;

include_once(__DIR__ . "/version.php");

class DeciderAgent extends Agent
{
  const RULES_NOMOS_IN_MONK = 0x1;
  const RULES_NOMOS_MONK_NINKA = 0x2;
  const RULES_BULK_REUSE = 0x4;
  const RULES_WIP_SCANNER_UPDATES = 0x8;
  const RULES_OJO_NO_CONTRADICTION = 0x10;
  const RULES_ALL = 0xf; // self::RULES_NOMOS_IN_MONK | self::RULES_NOMOS_MONK_NINKA | ... -> feature not available in php5.3

  private $activeRules;
  private $uploadDao;
  private $clearingDecisionProcessor;
  private $agentLicenseEventProcessor;
  private $clearingDao;
  private $highlightDao;
  private $showJobsDao;
  private $decisionTypes;
  private $licenseMap = null;
  private $licenseMapUsage = null;

  function __construct($licenseMapUsage=null)
  {
    parent::__construct(AGENT_DECIDER_NAME, AGENT_DECIDER_VERSION, AGENT_DECIDER_REV);

    $this->uploadDao = $this->container->get('dao.upload');
    $this->clearingDao = $this->container->get('dao.clearing');
    $this->highlightDao = $this->container->get('dao.highlight');
    $this->showJobsDao = $this->container->get('dao.show_jobs');
    $this->decisionTypes = $this->container->get('decision.types');
    $this->clearingDecisionProcessor = $this->container->get('businessrules.clearing_decision_processor');
    $this->agentLicenseEventProcessor = $this->container->get('businessrules.agent_license_event_processor');

    $this->licenseMapUsage = $licenseMapUsage;
    $this->agentSpecifOptions = "r:";
  }

  function processUploadId($uploadId)
  {
    $args = $this->args;
    $this->activeRules = array_key_exists('r', $args) ? intval($args['r']) : self::RULES_ALL;
    $this->licenseMap = new LicenseMap($this->dbManager, $this->groupId, $this->licenseMapUsage);

    if (array_key_exists("r", $args) && (($this->activeRules&self::RULES_BULK_REUSE)== self::RULES_BULK_REUSE)) {
      $bulkReuser = new BulkReuser();
      $bulkIds = $this->clearingDao->getPreviousBulkIds($uploadId, $this->groupId, $this->userId);
      if (count($bulkIds) == 0) {
        return true;
      }
      $jqId=0;
      $minTime="4";
      $maxTime="60";
      foreach ($bulkIds as $bulkId) {
        $jqId = $bulkReuser->rerunBulkAndDeciderOnUpload($uploadId, $this->groupId, $this->userId, $bulkId, $jqId);
        $this->heartbeat(1);
        if (!empty($jqId)) {
          $jqIdRow = $this->showJobsDao->getDataForASingleJob($jqId);
          while ($this->showJobsDao->getJobStatus($jqId)) {
            $this->heartbeat(0);
            $timeInSec = $this->showJobsDao->getEstimatedTime($jqIdRow['jq_job_fk'],'',0,0,1);
            if ($timeInSec > $maxTime) {
              sleep($maxTime);
            } else if ($timeInSec < $minTime) {
              sleep($minTime);
            } else {
              sleep($timeInSec);
            }
          }
        }
      }
    }
    $parentBounds = $this->uploadDao->getParentItemBounds($uploadId);
    foreach ($this->uploadDao->getContainedItems($parentBounds) as $item) {
      $process = $this->processItem($item);
      $this->heartbeat($process);
    }
    return true;
  }

  private function processItem(Item $item)
  {
    $itemTreeBounds = $item->getItemTreeBounds();

    $unMappedMatches = $this->agentLicenseEventProcessor->getLatestScannerDetectedMatches($itemTreeBounds);
    $projectedScannerMatches = $this->remapByProjectedId($unMappedMatches);

    $lastDecision = $this->clearingDao->getRelevantClearingDecision($itemTreeBounds, $this->groupId);

    if (null!==$lastDecision && $lastDecision->getType()==DecisionTypes::IRRELEVANT) {
      return 0;
    }

    $currentEvents = $this->clearingDao->getRelevantClearingEvents($itemTreeBounds, $this->groupId);

    $markAsWip = false;
    if (null !== $lastDecision && $projectedScannerMatches
      && ($this->activeRules & self::RULES_WIP_SCANNER_UPDATES) == self::RULES_WIP_SCANNER_UPDATES) {
      $licensesFromDecision = array();
      foreach ($lastDecision->getClearingLicenses() as $clearingLicense) {
        $licenseIdFromEvent = $this->licenseMap->getProjectedId($clearingLicense->getLicenseId());
        $licensesFromDecision[$licenseIdFromEvent] = $licenseIdFromEvent;
      }
      $markAsWip = $this->existsUnhandledMatch($projectedScannerMatches,$licensesFromDecision);
    }

    if (null !== $lastDecision && $markAsWip) {
      $this->clearingDao->markDecisionAsWip($item->getId(), $this->userId, $this->groupId);
      return 1;
    }

    if (null!==$lastDecision || 0<count($currentEvents)) {
      return 0;
    }

    $haveDecided = false;

    if (($this->activeRules&self::RULES_OJO_NO_CONTRADICTION) == self::RULES_OJO_NO_CONTRADICTION) {
      $haveDecided = $this->autodecideIfOjoMatchesNoContradiction($itemTreeBounds, $projectedScannerMatches);
    }

    if (!$haveDecided && ($this->activeRules&self::RULES_NOMOS_IN_MONK) == self::RULES_NOMOS_IN_MONK) {
      $haveDecided = $this->autodecideNomosMatchesInsideMonk($itemTreeBounds, $projectedScannerMatches);
    }

    if (!$haveDecided && ($this->activeRules&self::RULES_NOMOS_MONK_NINKA)== self::RULES_NOMOS_MONK_NINKA) {
      $haveDecided = $this->autodecideNomosMonkNinka($itemTreeBounds, $projectedScannerMatches);
    }

    if (!$haveDecided && $markAsWip) {
      $this->clearingDao->markDecisionAsWip($item->getId(), $this->userId, $this->groupId);
    }

    return ($haveDecided||$markAsWip ? 1 : 0);
  }

  private function existsUnhandledMatch($projectedScannerMatches, $licensesFromDecision)
  {
    foreach (array_keys($projectedScannerMatches) as $projectedLicenseId) {
      if (!array_key_exists($projectedLicenseId, $licensesFromDecision)) {
        return true;
      }
    }
    return false;
  }

  private function autodecideIfOjoMatchesNoContradiction(ItemTreeBounds $itemTreeBounds, $matches)
  {
    $licenseMatchExists = count($matches) > 0;
    foreach ($matches as $licenseMatches) {
      $licenseMatchExists = $licenseMatchExists && $this->areOtherScannerFindingsAndOJOAgreed($licenseMatches);
    }

    if ($licenseMatchExists) {
      $this->clearingDecisionProcessor->makeDecisionFromLastEvents($itemTreeBounds, $this->userId, $this->groupId, DecisionTypes::IDENTIFIED, $global=true);
    }
    return $licenseMatchExists;
  }

  private function autodecideNomosMonkNinka(ItemTreeBounds $itemTreeBounds, $matches)
  {
    $canDecide = (count($matches)>0);

    foreach ($matches as $licenseMatches) {
      if (!$canDecide) { // &= is not lazy
        break;
      }
      $canDecide &= $this->areNomosMonkNinkaAgreed($licenseMatches);
    }

    if ($canDecide) {
      $this->clearingDecisionProcessor->makeDecisionFromLastEvents($itemTreeBounds, $this->userId, $this->groupId, DecisionTypes::IDENTIFIED, $global=true);
    }
    return $canDecide;
  }

  private function autodecideNomosMatchesInsideMonk(ItemTreeBounds $itemTreeBounds, $matches)
  {
    $canDecide = (count($matches)>0);

    foreach ($matches as $licenseMatches) {
      if (!$canDecide) { // &= is not lazy
        break;
      }
      $canDecide &= $this->areNomosMatchesInsideAMonkMatch($licenseMatches);
    }

    if ($canDecide) {
      $this->clearingDecisionProcessor->makeDecisionFromLastEvents($itemTreeBounds, $this->userId, $this->groupId, DecisionTypes::IDENTIFIED, $global=true);
    }
    return $canDecide;
  }

  protected function remapByProjectedId($matches)
  {
    $remapped = array();
    foreach ($matches as $licenseId => $licenseMatches) {
      $projectedId = $this->licenseMap->getProjectedId($licenseId);

      foreach ($licenseMatches as $agent => $agentMatches) {
        $haveId = array_key_exists($projectedId, $remapped);
        $haveAgent = $haveId && array_key_exists($agent, $remapped[$projectedId]);
        if ($haveAgent) {
          $remapped[$projectedId][$agent] = array_merge($remapped[$projectedId][$agent], $agentMatches);
        } else {
          $remapped[$projectedId][$agent] = $agentMatches;
        }
      }
    }
    return $remapped;
  }

  private function isRegionIncluded($small, $big)
  {
    return ($big[0] >= 0) && ($small[0] >= $big[0]) && ($small[1] <= $big[1]);
  }

  private function areNomosMatchesInsideAMonkMatch($licenseMatches)
  {
    if (!array_key_exists("nomos", $licenseMatches)) {
      return false;
    }
    if (!array_key_exists("monk", $licenseMatches)) {
      return false;
    }

    foreach ($licenseMatches["nomos"] as $licenseMatch) {
      $matchId = $licenseMatch->getLicenseFileId();
      $nomosRegion = $this->highlightDao->getHighlightRegion($matchId);

      $found = false;
      foreach ($licenseMatches["monk"] as $monkLicenseMatch) {
        $monkRegion = $this->highlightDao->getHighlightRegion($monkLicenseMatch->getLicenseFileId());
        if ($this->isRegionIncluded($nomosRegion, $monkRegion)) {
          $found = true;
          break;
        }
      }
      if (!$found) {
        return false;
      }
    }

    return true;
  }

  protected function areNomosMonkNinkaAgreed($licenseMatches)
  {
    $scanners = array('nomos','monk','ninka');
    $vote = array();
    foreach ($scanners as $scanner) {
      if (!array_key_exists($scanner, $licenseMatches)) {
        return false;
      }
      foreach ($licenseMatches[$scanner] as $licenseMatch) {
        $licId = $licenseMatch->getLicenseId();
        $vote[$licId][$scanner] = true;
      }
    }

    foreach ($vote as $licId=>$voters) {
      if (count($voters) != 3) {
        return false;
      }
    }
    return true;
  }

  protected function getLicenseIdsOfMatchesForScanner($scanner, $licenseMatches)
  {
    if (array_key_exists($scanner, $licenseMatches) === true) {
      return array_map(
        function ($match) {
          return $match->getLicenseId();
        }, $licenseMatches[$scanner]);
    }
    return [];
  }

  protected function areOtherScannerFindingsAndOJOAgreed($licenseMatches)
  {
    $findingsByOjo = $this->getLicenseIdsOfMatchesForScanner('ojo', $licenseMatches);
    if (count($findingsByOjo) == 0) {
      // nothing to do
      return false;
    }

    $findingsByOtherScanner = $this->getLicenseIdsOfMatchesForScanner('nomos', $licenseMatches);
    if (count($findingsByOtherScanner) == 0) {
      // nothing found by other scanner, so no contradiction
      return true;
    }
    foreach ($findingsByOtherScanner as $findingsByScanner) {
      if (in_array($findingsByScanner, $findingsByOjo) === false) {
        // contradiction found
        return false;
      }
    }
    return true;
  }
}