deviceservice.pl

Software Testing Automation Framework (STAF)的开发代码

#############################################################################
# Software Testing Automation Framework (STAF)                              #
# (C) Copyright IBM Corp. 2004                                              #
#                                                                           #
# This software is licensed under the Common Public License (CPL) V1.0.     #
#############################################################################

package main;

use strict;
use warnings;
use 5.008;

use threads;
use threads::shared;

use PLSTAFService;

use constant kDeviceInvalidSerialNumber => scalar 4001;
use constant kVersion => scalar "3.0.0";

our $fServiceName;         # passed in as ARGV[0]
our $fHandle;              # staf handle for service
our $fListParser ;         # .
our $fQueryParser;         # parsers for different requests
our $fAddParser ;          # .
our $fDeleteParser;        # .
our $fLineSep;             # line separator
our %printerMap : shared;  # map to maintain list of printers
our %modemMap : shared;    # map to maintain list of modems


# XXX: This method should disappear.
sub construct
{
   return STAFResult::kOk;
}
sub init
{
   my $info = shift;
   print "Init";
   my $rc = STAFResult::kOk;

   $fServiceName = $info->{"serviceName"};

   #XXX: need to handle unsuccessful registration
   $fHandle = STAF::STAFHandle->new("STAF/Service/" . $fServiceName);

   # Add Parser
   $fAddParser = STAFCommandParser->new();

   $fAddParser->addOption("ADD", 1, STAFCommandParser::VALUENOTALLOWED);
   $fAddParser->addOption("PRINTER", 1, STAFCommandParser::VALUEREQUIRED);
   $fAddParser->addOption("MODEL", 1, STAFCommandParser::VALUEREQUIRED);
   $fAddParser->addOption("SN", 1, STAFCommandParser::VALUEREQUIRED);
   $fAddParser->addOption("MODEM", 1, STAFCommandParser::VALUEREQUIRED);

   $fAddParser->addOptionGroup("PRINTER MODEM", 0, 1);

   # if you specify ADD, MODEM is required
   $fAddParser->addOptionNeed("ADD", "MODEL");

   # if you specify ADD, SN is required
   $fAddParser->addOptionNeed("ADD", "SN");

   # if you specify ADD, PRINTER or MODEM is required
   $fAddParser->addOptionNeed("PRINTER MODEM", "ADD");

   # if you specify PRINTER or MODEM, ADD is required
   $fAddParser->addOptionNeed("ADD", "PRINTER MODEM");

   # LIST parser
   $fListParser = STAFCommandParser->new();

   $fListParser->addOption("LIST", 1, STAFCommandParser::VALUENOTALLOWED);
   $fListParser->addOption("PRINTERS", 1, STAFCommandParser::VALUENOTALLOWED);
   $fListParser->addOption("MODEMS", 1, STAFCommandParser::VALUENOTALLOWED);

   # QUERY parser
   $fQueryParser = STAFCommandParser->new();

   $fQueryParser->addOption("QUERY", 1, STAFCommandParser::VALUENOTALLOWED);
   $fQueryParser->addOption("PRINTER", 1, STAFCommandParser::VALUEREQUIRED);
   $fQueryParser->addOption("MODEM", 1, STAFCommandParser::VALUEREQUIRED);

   # this means you can have PRINTER or MODEM, but not both
   $fQueryParser->addOptionGroup("PRINTER MODEM", 0, 1);

   # if you specify PRINTER or MODEM, QUERY is required
   $fQueryParser->addOptionNeed("PRINTER MODEM", "QUERY");

   # if you specify QUERY, PRINTER or MODEM is required
   $fQueryParser->addOptionNeed("QUERY", "PRINTER MODEM");

   # DELETE parser
   $fDeleteParser = STAFCommandParser->new();

   $fDeleteParser->addOption("DELETE", 1, STAFCommandParser::VALUENOTALLOWED);
   $fDeleteParser->addOption("PRINTER", 1, STAFCommandParser::VALUEREQUIRED);
   $fDeleteParser->addOption("MODEM", 1, STAFCommandParser::VALUEREQUIRED);
   $fDeleteParser->addOption("CONFIRM", 1, STAFCommandParser::VALUENOTALLOWED);

   # this means you must have PRINTER or MODEM, but not both
   $fDeleteParser->addOptionGroup("PRINTER MODEM", 0, 1);

   # if you specify PRINTER or MODEM, DELETE is required
   $fDeleteParser->addOptionNeed("PRINTER MODEM", "DELETE");

   # if you specify DELETE, PRINTER or MODEM is required
   $fDeleteParser->addOptionNeed("DELETE", "PRINTER MODEM");

   # if you specify DELETE, CONFIRM is required
   $fDeleteParser->addOptionNeed("DELETE", "CONFIRM");

   my $lineSepResult =  $fHandle->submit2(STAFHandle::kReqSync, "local",
                              "var", "resolve string {STAF/Config/Sep/Line}");

   $fLineSep = $lineSepResult->{result};

   registerHelpData(kDeviceInvalidSerialNumber, "Invalid Serial Number",
                  "A non-numeric value was specified for serial number");

   return $rc;
}


sub acceptRequest
{
   my $info = shift;

   my $lowerRequest = lc($info->{request});
   my $requestType = "";

   #get first "word" in request
   if($lowerRequest =~ m/\b(\w*)\b/)
   {
      $requestType = $&;
   }
   else
   {
      return STAF::STAFResult->new(STAFResult::kInvalidRequestString,
          "Unknown DeviceService Request: " . ($info->{request}));
   }

   if ($requestType eq "list")
   {
      return handleList($info);
   }
   elsif ($requestType eq "query")
   {
      return handleQuery($info);
   }
   elsif ($requestType eq "add")
   {
      return handleAdd($info);
   }
   elsif ($requestType eq "delete")
   {
      return handleDelete($info);
   }
   elsif ($requestType eq "help")
   {
      return handleHelp();
   }
   elsif ($requestType eq "version")
   {
      return handleVersion();
   }
   else
   {
      return STAF::STAFResult->new(STAFResult::kInvalidRequestString,
          "Unknown DeviceService Request: " . $info->{request});
   }
}
sub handleVersion
{
   return STAF::STAFResult->new(STAFResult::kOk, kVersion);
}
sub handleHelp
{
   return STAF::STAFResult->new(STAFResult::kOk,
         "DeviceService Service Help" . $fLineSep
         . $fLineSep . "ADD     (PRINTER <printerName> | MODEM <modemName>)" .
         " MODEL <model> SN <serial#>"
         . $fLineSep . "DELETE  PRINTER <printerName> | MODEM <modemName> " .
         "CONFIRM"
         . $fLineSep . "LIST    [PRINTERS] [MODEMS]"
         . $fLineSep . "QUERY   PRINTER <printerName> | MODEM <modemName>"
         . $fLineSep . "VERSION" . $fLineSep . "HELP");

}

sub handleAdd {
   my $info = shift;

   if($info->{"trustLevel"} < 3)
   {
      return STAF::STAFResult->new(STAFResult::kAccessDenied,
         "Trust level 3 required for ADD request. Requesting " .
         "machine's trust level: " . $info->{"trustLevel"});
   }

   my $result;
   my $resolveResult;
   my $resultString = "";
   my $printerValue = "";
   my $modemValue = "";
   my $modelValue = "";
   my $snValue;

   # parse request
   my $parsedRequest = $fAddParser->parse($info->{"request"});

   # check results of parse
   if($parsedRequest->{"rc"} != STAFResult::kOk)
   {
      return STAF::STAFResult->new(STAFResult::kInvalidRequestString,
          $parsedRequest->{"errorBuffer"});
   }

   # resolve the value after 'printer' if necessary
   $resolveResult = resolveVar($info->{"localMachine"},
                                 $parsedRequest->optionValue("printer"),
                                 $info->{"requestNumber"});

   # check results of resolve
   if ($resolveResult->{"rc"} != STAFResult::kOk)
   {
      return $resolveResult;
   }

   $printerValue = $resolveResult->{"result"};

   # resolve the value after 'modem' if necessary
   $resolveResult = resolveVar($info->{"localMachine"},
                  $parsedRequest->optionValue("modem"),
                  $info->{"requestNumber"});

   # check the results of resovle
   if ($resolveResult->{"rc"} != STAFResult::kOk)
   {
      return $resolveResult;
   }

   $modemValue = $resolveResult->{"result"};

   # resolve the value after 'model' if necessary
   $resolveResult = resolveVar($info->{"localMachine"},
                              $parsedRequest->optionValue("model"),
                              $info->{"requestNumber"});

   if ($resolveResult->{"rc"} != STAFResult::kOk)
   {
      return $resolveResult;
   }

   $modelValue = $resolveResult->{"result"};

   # resolve the value after 'sn' if necessary
   $resolveResult = resolveVar($info->{"localMachine"},
      $parsedRequest->optionValue("sn"),$info->{"requestNumber"});

   if ($resolveResult->{"rc"} != STAFResult::kOk)
   {
      return $resolveResult;
   }

   # make sure the result is a number
   if($resolveResult->{result} =~ m/^[0-9]+$/)
   {
      $snValue = $resolveResult->{"result"};
   }
   else
   {
      return STAF::STAFResult->new(kDeviceInvalidSerialNumber, $snValue);
   }

  # add the printer to the map
  if ($printerValue ne "")
  {
     lock(%printerMap);
     $printerMap{$printerValue} = DeviceData->new($modelValue, $snValue);
  }
  # if no printer value, add the modem to the map
  elsif ($modemValue ne "")
  {
     lock(%modemMap);
     $modemMap{$modemValue} = DeviceData->new($modelValue, $snValue);
  }
  else
  {
     # this should only happen when the option value resolves to an empty string
     return STAF::STAFResult->new(STAFResult::kInvalidRequestString,
         "Device name resolved to empty string");
  }

  return STAF::STAFResult->new(STAFResult::kOk, $resultString);
}

sub handleList
{
   my $info = shift;

   if($info->{trustLevel} < 2)
   {
      return STAF::STAFResult->new(STAFResult::kAccessDenied,
          "Trust level 2 required for LIST request. Requesting " .
          "machine's trust level: " .  $info->{trustLevel});
   }

   my $result = STAF::STAFResult->new(STAFResult::kOk, "");
   my $resultString = "";

   my $printersOption;
   my $modemsOption;

   # parse request
   my $parsedRequest = $fListParser->parse($info->{request});

   # check result of parse
   if ($parsedRequest->{rc} != STAFResult::kOk)
   {
      return STAF::STAFResult->new(STAFResult::kInvalidRequestString,
                      $parsedRequest->{errorBuffer});
   }

   # is 'printers' specified?
   $printersOption = $parsedRequest->optionTimes("printers");

   # is 'modems' specified?
   $modemsOption = $parsedRequest->optionTimes("modems");

   my $defaultList = 0;

   # if neither is specified, default is to show everything
   if ($printersOption == 0 && $modemsOption == 0)
   {
      $defaultList = 1;
   }