Example #1
0
  public static void convertManagedOperationResults(
      ManagedOperation operation,
      MetaValue resultMetaValue,
      Configuration complexResults,
      OperationDefinition operationDefinition) {
    ConfigurationDefinition resultConfigDef =
        operationDefinition.getResultsConfigurationDefinition();
    // Don't return any results if we have no definition with which to display them
    if (resultConfigDef == null || resultConfigDef.getPropertyDefinitions().isEmpty()) {
      if (resultMetaValue != null) {
        LOG.error(
            "Plugin error: Operation ["
                + operationDefinition.getName()
                + "] is defined as returning no results, but it returned non-null results: "
                + resultMetaValue.toString());
      }
      return;
    } else {
      Map<String, PropertyDefinition> resultPropDefs = resultConfigDef.getPropertyDefinitions();
      // There should and must be only one property definition to map to the results from the
      // Profile Service,
      // otherwise there will be a huge mismatch.
      if (resultPropDefs.size() > 1)
        LOG.error(
            "Operation ["
                + operationDefinition.getName()
                + "] is defined with multiple result properties: "
                + resultPropDefs.values());

      PropertyDefinition resultPropDef = resultPropDefs.values().iterator().next();

      // Don't return any results, if the actual result object is null.
      if (resultMetaValue == null) {
        // Check if result is required or not, and if it is, log an error.
        if (resultPropDef.isRequired()) {
          LOG.error(
              "Plugin error: Operation ["
                  + operationDefinition.getName()
                  + "] is defined as returning a required result, but it returned null.");
        }
        return;
      }

      MetaType resultMetaType = operation.getReturnType();
      if (!MetaTypeUtils.instanceOf(resultMetaValue, resultMetaType))
        LOG.debug(
            "Profile Service Error: Result type ("
                + resultMetaType
                + ") of ["
                + operation.getName()
                + "] ManagedOperation does not match the type of the value returned by invoke() ("
                + resultMetaValue
                + ").");

      PropertyAdapter propertyAdapter = PropertyAdapterFactory.getPropertyAdapter(resultMetaValue);
      Property resultProp = propertyAdapter.convertToProperty(resultMetaValue, resultPropDef);
      complexResults.put(resultProp);
    }
  }
Example #2
0
    public Object invoke(Object[] args) throws Exception {
      if (!LazyLoadScenario.isShouldLoad()) return null;

      Configuration parameters =
          ConfigurationClassBuilder.translateParametersToConfig(
              definition.getParametersConfigurationDefinition(), args);

      ResourceOperationSchedule schedule =
          remoteClient
              .getOperationManager()
              .scheduleResourceOperation(
                  remoteClient.getSubject(),
                  resourceId,
                  definition.getName(),
                  0,
                  0,
                  0,
                  30000,
                  parameters,
                  "Executed from commandline");

      ResourceOperationHistoryCriteria criteria = new ResourceOperationHistoryCriteria();
      criteria.addFilterJobId(schedule.getJobId());
      criteria.addFilterResourceIds(resourceId);
      criteria.addSortStartTime(PageOrdering.DESC); // put most recent at top of results
      criteria.setPaging(0, 1); // only return one result, in effect the latest
      criteria.fetchOperationDefinition(true);
      criteria.fetchParameters(true);
      criteria.fetchResults(true);

      int retries = 10;
      ResourceOperationHistory history = null;
      while (history == null && retries-- > 0) {
        Thread.sleep(1000);
        PageList<ResourceOperationHistory> histories =
            remoteClient
                .getOperationManager()
                .findResourceOperationHistoriesByCriteria(remoteClient.getSubject(), criteria);
        if (histories.size() > 0
            && histories.get(0).getStatus() != OperationRequestStatus.INPROGRESS) {
          history = histories.get(0);
        }
      }

      Configuration result = (history != null ? history.getResults() : null);

      Object returnResults =
          ConfigurationClassBuilder.translateResults(
              definition.getResultsConfigurationDefinition(), result);

      return returnResults;
    }
  private void assertVersion2(ResourceType resourceType) {
    PropertyDefinition prop;
    Set<String> seen =
        new HashSet<String>(2); // we use to this remember names of the things that we've seen

    assert resourceType.getChildSubCategories().size() == 1;
    assert resourceType.getChildSubCategories().get(0).getName().equals(SUBCAT);
    assert resourceType.getChildSubCategories().get(0).getDisplayName().equals(SUBCAT_DISPLAYNAME);

    seen.clear();
    ConfigurationDefinition pcDef = resourceType.getPluginConfigurationDefinition();
    assert pcDef.getGroupDefinitions().size() == 2;
    for (PropertyGroupDefinition group : pcDef.getGroupDefinitions()) {
      seen.add(group.getName());
      if (group.getName().equals(CHANGED_PC_GROUP)) {
        assert group.isDefaultHidden() == CHANGED_PC_GROUP_HIDDEN;
      } else if (group.getName().equals(NEW_PC_GROUP)) {
        assert group.isDefaultHidden() == NEW_PC_GROUP_HIDDEN;
      } else {
        assert false : "Unexpected group [" + group.getName() + "]:" + group;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }

    prop = pcDef.get(CHANGED_PC_PROP);
    assert prop != null;
    assert prop.getName().equals(CHANGED_PC_PROP);
    assert prop.isRequired() == CHANGED_PC_PROP_REQUIRED;
    assert prop.getPropertyGroupDefinition().getName().equals(CHANGED_PC_GROUP);
    prop = pcDef.get(NEW_PC_PROP);
    assert prop != null;
    assert prop.getName().equals(NEW_PC_PROP);
    assert prop.isRequired() == NEW_PC_PROP_REQUIRED;
    assert prop.getPropertyGroupDefinition().getName().equals(NEW_PC_GROUP);

    seen.clear();
    assert resourceType.getProcessScans().size() == 2;
    for (ProcessScan processScan : resourceType.getProcessScans()) {
      seen.add(processScan.getName());
      if (processScan.getName().equals(CHANGED_PROCESS_SCAN_NAME)) {
        assert processScan.getQuery().equals(CHANGED_PROCESS_SCAN_QUERY);
      } else if (processScan.getName().equals(NEW_PROCESS_SCAN_NAME)) {
        assert processScan.getQuery().equals(NEW_PROCESS_SCAN_QUERY);
      } else {
        assert false : "Unexpected process scan[" + processScan.getName() + "]:" + processScan;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }

    seen.clear();
    assert resourceType.getOperationDefinitions().size() == 2;
    for (OperationDefinition op : resourceType.getOperationDefinitions()) {
      seen.add(op.getName());
      if (op.getName().equals(CHANGED_OP_NAME)) {
        assert op.getTimeout().intValue() == CHANGED_OP_TIMEOUT;
        assert op.getDescription().equals(CHANGED_OP_DESC);
      } else if (op.getName().equals(NEW_OP_NAME)) {
        assert op.getTimeout().intValue() == NEW_OP_TIMEOUT;
        assert op.getDescription().equals(NEW_OP_DESC);
      } else {
        assert false : "Unexpected operation [" + op.getName() + "]:" + op;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }

    seen.clear();
    assert resourceType.getMetricDefinitions().size() == 3; // include built-in Availability metric
    for (MeasurementDefinition metric : resourceType.getMetricDefinitions()) {
      if (metric.getName().equals(MeasurementDefinition.AVAILABILITY_NAME)) {
        // expected, ignore
        continue;
      }

      seen.add(metric.getName());
      if (metric.getName().equals(CHANGED_METRIC_PROP)) {
        // even though our _v2 plugin set this to something different, our upgrade doesn't change it
        // because
        // we don't want to overwrite changes a user possibly made to the defaut interval (aka
        // metric template)
        assert metric.getDefaultInterval() == METRIC_DEFAULT_INTERVAL;
      } else if (metric.getName().equals(NEW_METRIC_PROP)) {
        assert metric.getDefaultInterval() == NEW_METRIC_DEFAULT_INTERVAL;
      } else {
        assert false : "Unexpected metric [" + metric.getName() + "]:" + metric;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }

    seen.clear();
    assert resourceType.getEventDefinitions().size() == 2;
    for (EventDefinition event : resourceType.getEventDefinitions()) {
      seen.add(event.getName());
      if (event.getName().equals(CHANGED_EVENT_NAME)) {
        assert event.getDescription().equals(CHANGED_EVENT_DESC);
      } else if (event.getName().equals(NEW_EVENT_NAME)) {
        assert event.getDescription().equals(NEW_EVENT_DESC);
      } else {
        assert false : "Unexpected event [" + event.getName() + "]:" + event;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }

    assert resourceType.getResourceConfigurationDefinition().getGroupDefinitions().size() == 0;
    prop = resourceType.getResourceConfigurationDefinition().get(CHANGED_RC_PROP);
    assert prop != null;
    assert prop.getName().equals(CHANGED_RC_PROP);
    assert prop.isRequired() == CHANGED_RC_PROP_REQUIRED;
    prop = resourceType.getResourceConfigurationDefinition().get(NEW_RC_PROP);
    assert prop != null;
    assert prop.getName().equals(NEW_RC_PROP);
    assert prop.isRequired() == NEW_RC_PROP_REQUIRED;

    seen.clear();
    assert resourceType.getDriftDefinitionTemplates().size() == 2;
    for (DriftDefinitionTemplate drift : resourceType.getDriftDefinitionTemplates()) {
      DriftDefinition def = drift.getTemplateDefinition();
      seen.add(def.getName());
      if (def.getName().equals(CHANGED_DRIFT_DEF_NAME)) {
        BaseDirectory driftBasedir = def.getBasedir();
        assert driftBasedir.getValueContext().equals(CHANGED_DRIFT_DEF_BASEDIR_CONTEXT);
        assert driftBasedir.getValueName().equals(CHANGED_DRIFT_DEF_BASEDIR_VALUE);
      } else if (def.getName().equals(NEW_DRIFT_DEF_NAME)) {
        BaseDirectory driftBasedir = def.getBasedir();
        assert driftBasedir.getValueContext().equals(NEW_DRIFT_DEF_BASEDIR_CONTEXT);
        assert driftBasedir.getValueName().equals(NEW_DRIFT_DEF_BASEDIR_VALUE);
      } else {
        assert false : "Unexpected drift def [" + def.getName() + "]:" + def;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }

    seen.clear();
    ResourceTypeBundleConfiguration bundle = resourceType.getResourceTypeBundleConfiguration();
    assert bundle.getBundleDestinationBaseDirectories().size() == 2;
    for (BundleDestinationBaseDirectory bundleBasedir :
        bundle.getBundleDestinationBaseDirectories()) {
      seen.add(bundleBasedir.getName());
      if (bundleBasedir.getName().equals(CHANGED_BUNDLE_TARGET_NAME)) {
        assert bundleBasedir.getValueContext().equals(CHANGED_BUNDLE_BASEDIR_CONTEXT);
        assert bundleBasedir.getValueName().equals(CHANGED_BUNDLE_BASEDIR_VALUE);
      } else if (bundleBasedir.getName().equals(NEW_BUNDLE_TARGET_NAME)) {
        assert bundleBasedir.getValueContext().equals(NEW_BUNDLE_BASEDIR_CONTEXT);
        assert bundleBasedir.getValueName().equals(NEW_BUNDLE_BASEDIR_VALUE);
      } else {
        assert false
            : "Unexpected bundle basedir [" + bundleBasedir.getName() + "]:" + bundleBasedir;
      }
    }
    if (seen.size() != 2) {
      assert false : "did not see what we expected to see: " + seen;
    }
  }
  private void assertVersion1(ResourceType resourceType) {
    PropertyGroupDefinition group;
    PropertyDefinition prop;
    ProcessScan processScan;
    OperationDefinition op;
    MeasurementDefinition metric;
    EventDefinition event;
    DriftDefinitionTemplate drift;
    BaseDirectory driftBasedir;
    ResourceTypeBundleConfiguration bundle;
    BundleDestinationBaseDirectory bundleBasedir;

    assert resourceType.getChildSubCategories().size() == 1;
    assert resourceType.getChildSubCategories().get(0).getName().equals(SUBCAT);
    assert resourceType.getChildSubCategories().get(0).getDisplayName().equals(SUBCAT_DISPLAYNAME);

    assert resourceType.getPluginConfigurationDefinition().getGroupDefinitions().size() == 1;
    group = resourceType.getPluginConfigurationDefinition().getGroupDefinitions().get(0);
    assert group.getName().equals(PC_GROUP);
    assert group.isDefaultHidden() == PC_GROUP_HIDDEN;
    prop = resourceType.getPluginConfigurationDefinition().get(PC_PROP);
    assert prop != null;
    assert prop.getName().equals(PC_PROP);
    assert prop.isRequired() == PC_PROP_REQUIRED;
    assert prop.getPropertyGroupDefinition().getName().equals(PC_GROUP);

    assert resourceType.getProcessScans().size() == 1;
    processScan = resourceType.getProcessScans().iterator().next();
    assert processScan.getName().equals(PROCESS_SCAN_NAME);
    assert processScan.getQuery().equals(PROCESS_SCAN_QUERY);

    assert resourceType.getOperationDefinitions().size() == 1;
    op = resourceType.getOperationDefinitions().iterator().next();
    assert op.getName().equals(OP_NAME);
    assert op.getTimeout().intValue() == OP_TIMEOUT;
    assert op.getDescription().equals(OP_DESC);

    assert resourceType.getMetricDefinitions().size() == 2; // include built-in Availability metric
    metric = resourceType.getMetricDefinitions().iterator().next();
    assert metric.getName().equals(METRIC_PROP);
    assert metric.getDefaultInterval() == METRIC_DEFAULT_INTERVAL;

    assert resourceType.getEventDefinitions().size() == 1;
    event = resourceType.getEventDefinitions().iterator().next();
    assert event.getName().equals(EVENT_NAME);
    assert event.getDescription().equals(EVENT_DESC);

    assert resourceType.getResourceConfigurationDefinition().getGroupDefinitions().size() == 0;
    prop = resourceType.getResourceConfigurationDefinition().get(RC_PROP);
    assert prop != null;
    assert prop.getName().equals(RC_PROP);
    assert prop.isRequired() == RC_PROP_REQUIRED;

    assert resourceType.getDriftDefinitionTemplates().size() == 1;
    drift = resourceType.getDriftDefinitionTemplates().iterator().next();
    assert drift.getTemplateDefinition().getName().equals(DRIFT_DEF_NAME);
    driftBasedir = drift.getTemplateDefinition().getBasedir();
    assert driftBasedir.getValueContext().equals(DRIFT_DEF_BASEDIR_CONTEXT);
    assert driftBasedir.getValueName().equals(DRIFT_DEF_BASEDIR_VALUE);

    bundle = resourceType.getResourceTypeBundleConfiguration();
    assert bundle.getBundleDestinationBaseDirectories().size() == 1;
    bundleBasedir = bundle.getBundleDestinationBaseDirectories().iterator().next();
    assert bundleBasedir.getName().equals(BUNDLE_TARGET_NAME);
    assert bundleBasedir.getValueContext().equals(BUNDLE_BASEDIR_CONTEXT);
    assert bundleBasedir.getValueName().equals(BUNDLE_BASEDIR_VALUE);
  }