deviceservice.pl

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

   # list all the printers
   if ($defaultList || ($printersOption > 0))
   {
      # XXX: does it make sense to have this lock here?
      # In perl, sometimes accessing vars in a way that
      # seems to be leave the variable unchanged on the surface
      # actually changes things behind the scenes, but it's
      # "hard to know when" according to perl docs
      lock(%printerMap);
      foreach my $key (sort keys %printerMap)
      {

         my $data = $printerMap{$key};
         $resultString .=
            $key . ";" . $data->{model} . ";" . $data->{sn} . "\n";
      }

   }

   # list all the modems
   if ($defaultList || ($modemsOption > 0))
   {
      # XXX: does it make sense to have this lock here?
      # see above comment
      lock(%modemMap);
      foreach my $key (sort keys %modemMap)
      {

         my $data = $modemMap{$key};
         $resultString .=
            $key . ";" . $data->{model} . ";" . $data->{sn} . "\n";
      }
   }

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

sub handleQuery
{
     my $info = shift;

     #Check whether Trust level is sufficient for this command.
     if ($info->{trustLevel} < 2)
     {
         return STAF::STAFResult->new(STAFResult::kAccessDenied,
             "Trust level 2 required for QUERY request. Requesting " .
             "machine's trust level: " .  $info->{trustLevel});
     }

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

     my $resolveResult;

     my $printerValue;
     my $modemValue;

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

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

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

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

     $printerValue = $resolveResult->{result};

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

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

     $modemValue = $resolveResult->{result};

     # look up the information associated with $printerValue or $modemValue
     if ($printerValue ne "")
     {
         lock(%printerMap);

         if (defined $printerMap{$printerValue})
         {
             my $printer = $printerValue;
             my $data = $printerMap{$printerValue};
             $resultString = "Printer : " . $printer . "\n";
             $resultString .= "Model   : " . $data->{model} . "\n";
             $resultString .= "Serial# : " . $data->{sn} . "\n";
         }
         else
         {
             return STAF::STAFResult->new(STAFResult::kDoesNotExist,
                 $printerValue);
         }

     }
     elsif ($modemValue ne (""))
     {
         lock(%modemMap);

         if (defined $modemMap{$modemValue})
         {
             my $modem = $modemValue;
             my $data = $modemMap{$modem};
             $resultString = "Modem   : " . $modem . "\n";
             $resultString .= "Model   : " . $data->{model} . "\n";
             $resultString .= "Serial# : " . $data->{sn} . "\n";
         }
         else
         {
             return STAF::STAFResult->new(STAFResult::kDoesNotExist,
                 $printerValue);
         }
     }
     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 handleDelete
{
   my $info = shift;

   # Check whether Trust level is sufficient for this command.
   if ($info->{trustLevel} < 4)
   {
      return STAF::STAFResult->new(STAFResult::kAccessDenied,
          "Trust level 4 required for DELETE request. Requesting " .
          "machine's trust level: " .  $info->{trustLevel});
   }

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

   my $resultString = "";
   my $resolveResult;

   my $printerValue;
   my $modemValue;

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

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

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

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

   $printerValue = $resolveResult->{result};

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

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

   $modemValue = $resolveResult->{result};

   # delete printer or modem if it can find it
   if ($printerValue ne "")
   {
      lock(%printerMap);

      if(defined $printerMap{$printerValue})
      {
         delete $printerMap{$printerValue};
      }
      else
      {
         return STAF::STAFResult->new(STAFResult::kDoesNotExist,
             $printerValue);
      }
   }
   elsif ($modemValue ne "")
   {
      lock(%modemMap);

      if(defined $modemMap{$modemValue})
      {
         delete $modemMap{$modemValue};
      }
      else
      {
         return STAF::STAFResult->new(STAFResult::kDoesNotExist, $modemValue);
      }
   }
   else
   {
      return STAF::STAFResult->new(STAFResult::kInvalidRequestString,
          "Device name resolved to empty string");
   }

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

sub term
{
   unregisterHelpData(kDeviceInvalidSerialNumber);

   #Un-register the service handle
   $fHandle->unRegister();

   #XXX: Need to handle unsuccessful un-registration

   return STAFResult::kOk;
}

# XXX: This method should not be here.
sub destruct
{
   return STAFResult::kOk;
}

#this method will resolve any STAF variables that
#are contained within the Option Value
sub resolveVar
{
     my ($machine, $optionValue, $requestNumber) = @_;
     my $value = "";
     my $resolvedResult;

     # look for something starting with '{'
     if ($optionValue =~ m/^\{/)
     {
         $resolvedResult =
             $fHandle->submit2($machine, "var", "resolve request " .
               $requestNumber . " string " . $optionValue);

         if ($resolvedResult->{rc} != 0)
         {
             return $resolvedResult;
         }

         $value = $resolvedResult->{result};
     }
     else
     {
         $value = $optionValue;
     }

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

# Register error codes for the STAX Service with the HELP service
sub registerHelpData
{
   my ($errorNumber, $info, $description) = @_;

   my $res = $fHandle->submit2(STAFHandle::kReqSync, "local", "HELP",
                      "REGISTER SERVICE " . $fServiceName .
                      " ERROR " . $errorNumber .
                      " INFO " . STAF::STAFUtil->WrapData($info) .
                      " DESCRIPTION " .
                      STAF::STAFUtil->WrapData($description));
}

#Un-register error codes for the STAX Service with the HELP service
sub unregisterHelpData
{
   my $errorNumber = @_;
   my $res = $fHandle->submit2(STAFHandle::kReqSync, "local", "HELP",
                   "UNREGISTER SERVICE " . $fServiceName .
                   " ERROR " . $errorNumber);
}

# XXX: This method should only need init, acceptRequest, term, and ARGV[0].
our $subHash = {
                 serviceName => $ARGV[0],
                 init =>      \&init,
                 acceptRequest =>\&acceptRequest,
                 term => \&term,
               };

# It is VERY IMPORTANT that you call this
STAFServiceInterface->start($subHash);
#******************************************************************************

package DeviceData;

sub new
{
   # XXX: TMG: this is weird, but you can't assign
   # unshared data to a shared object, so your objects
   # will need to be recursively shared, and as of now,
   # that does not happen automatically in perl, though
   # artur bergman claims it might be soon.

   my $type = shift;
   my $model : shared = shift;
   my $sn : shared = shift;

   my $obj = &threads::shared::share({});

   $obj->{model} = $model;
   $obj->{sn} = $sn;

   bless ($obj, $type);

   return $obj;
}