DeciderAgentPlugin.php

<?php
/*
 SPDX-FileCopyrightText: © 2014-2018 Siemens AG
 
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
use Fossology\Lib\Plugin\AgentPlugin;
use Symfony\Component\HttpFoundation\Request;
 
include_once(__DIR__ . "/../agent/version.php");
 
class DeciderAgentPlugin extends AgentPlugin
{
  const RULES_FLAG = "-r";
  const LICENSE_FLAG = "-t";
 
  function __construct()
  {
    $this->Name = "agent_decider";
    $this->Title = _("Automatic Concluded License Decider, based on scanners Matches");
    $this->AgentName = AGENT_DECIDER_NAME;
 
    parent::__construct();
  }
 
 
  public function renderContent(&$vars)
  {
    global $SysConf;
    $renderer = $GLOBALS['container']->get('twig.environment');
    $vars['isNinkaInstalled'] = false;
    if ($ninkaUi=plugin_find('agent_ninka')) {
      $vars['isNinkaInstalled'] = $ninkaUi->isNinkaInstalled();
    }
    $vars['isSpacyInstalled'] = $this->isSpacyInstalled();
    $licenseTypes = array_map('trim', explode(',',
        $SysConf['SYSCONFIG']['LicenseTypes']));
    $vars['licenseTypes'] = array_combine($licenseTypes, $licenseTypes);
    return $renderer->load('agent_decider.html.twig')->render($vars);
  }
 
  public function renderFoot(&$vars)
  {
    return "";
  }
 
  public function getScriptIncludes(&$vars)
  {
    return "";
  }
 
  public function scheduleAgent($jobId, $uploadId, &$errorMsg, $request)
  {
    $dependencies = array();
 
    $rules = $request->get('deciderRules', []);
    if (!is_array($rules)) {
      $rules = [];
    }
    $agents = $request->get('agents', []);
    if (!is_array($agents)) {
      $agents = [];
    }
    if (in_array('agent_nomos', $agents)) {
      $checkAgentNomos = true;
    } else {
      $checkAgentNomos = $request->get('Check_agent_nomos', false);
    }
 
    if (in_array('agent_copyright', $agents)) {
      $checkAgentCopyright = true;
    } else {
      $checkAgentCopyright = $request->get('Check_agent_copyright') ?: false;
    }
    $rulebits = 0;
 
    foreach ($rules as $rule) {
      switch ($rule) {
        case 'nomosInMonk':
          $dependencies[] = 'agent_nomos';
          $dependencies[] = 'agent_monk';
          $rulebits |= 0x1;
          break;
        case 'nomosMonkNinka':
          $dependencies[] = 'agent_nomos';
          $dependencies[] = 'agent_monk';
          $dependencies[] = 'agent_ninka';
          $rulebits |= 0x2;
          break;
        case 'reuseBulk':
          $dependencies[] = 'agent_nomos';
          $dependencies[] = 'agent_monk';
          $dependencies[] = 'agent_reuser';
          $rulebits |= 0x4;
          break;
        case 'wipScannerUpdates':
          $this->addScannerDependencies($dependencies, $request);
          $rulebits |= 0x8;
          break;
        case 'ojoNoContradiction':
          if ($checkAgentNomos) {
            $dependencies[] = 'agent_nomos';
          }
          $dependencies[] = 'agent_ojo';
          $rulebits |= 0x10;
          break;
        case 'copyrightDeactivation':
          if ($checkAgentCopyright) {
            $dependencies[] = 'agent_copyright';
          }
          $rulebits |= 0x20;
          break;
        case 'copyrightDeactivationClutterRemoval':
          if ($checkAgentCopyright) {
            $dependencies[] = 'agent_copyright';
          }
          $rulebits |= 0x40;
          break;
        case 'licenseTypeConc':
          $dependencies[] = 'agent_compatibility';
          $rulebits |= 0x80;
          break;
        case 'kotobaAgent':
          $rulebits |= 0x100;
          break;
      }
    }
 
    if (empty($rulebits)) {
      return 0;
    }
 
    // If only kotobaAgent is selected, schedule kotoba_bulk agent directly without scheduling decider
    if ($rulebits == 0x100) {
      $kotobaPlugin = \plugin_find("agent_kotoba");
      if ($kotobaPlugin !== null) {
        return $kotobaPlugin->AgentAdd($jobId, $uploadId, $errorMsg, array(), null, $request);
      }
      return 0;
    }
 
    // If kotobaAgent is selected along with other rules, add kotoba_bulk as dependency
    if ($rulebits & 0x100) {
      $dependencies[] = 'agent_kotoba';
    }
 
    $args = self::RULES_FLAG . $rulebits;
 
    if ($rulebits & 0x80) {
      $licenseType = $this->getLicenseTypeConf($request);
      if ($licenseType != "") {
        $args .= " " . self::LICENSE_FLAG . escapeshellarg($licenseType);
      }
    }
 
    return parent::AgentAdd($jobId, $uploadId, $errorMsg,
        array_unique($dependencies), $args, $request);
  }
 
  protected function addScannerDependencies(&$dependencies, Request $request)
  {
    $agentList = $request->get('agents') ?: array();
    if (!is_array($agentList)) {
      $agentList = array();
    }
    foreach (array('agent_nomos', 'agent_monk', 'agent_ninka') as $agentName) {
      if (in_array($agentName, $dependencies)) {
        continue;
      }
      if ($request->get('Check_'.$agentName)) {
        $dependencies[] = $agentName;
        continue;
      }
      if (in_array($agentName, $agentList)) {
        $dependencies[] = $agentName;
      }
    }
  }
 
  public function preInstall()
  {
    menu_insert("ParmAgents::" . $this->Title, 0, $this->Name);
  }
 
  private function getLicenseTypeConf(Request $request)
  {
    global $SysConf;
    $licenseTypes = array_map('trim', explode(',',
        $SysConf['SYSCONFIG']['LicenseTypes']));
    $licenseType = $request->get("licenseTypeConc", "");
    if (!is_string($licenseType)) {
      return "";
    }
    $licenseType = trim($licenseType);
    if (in_array($licenseType, $licenseTypes)) {
      return $licenseType;
    }
    return "";
  }
 
  public function isSpacyInstalled()
  {
    global $SysConf;
    return file_exists("/home/" .
      $SysConf['DIRECTORIES']['PROJECTUSER'] . "/pythondeps/bin/spacy");
  }
}
 
register_plugin(new DeciderAgentPlugin());