@Test(expected = IllegalArgumentException.class)
 public void forbidDuplicatedType() {
   ResourceTypeTree.builder()
       .addType(ResourceType.builder("TRK").build())
       .addType(ResourceType.builder("TRK").build())
       .build();
 }
 /**
  * Extract the id from a resource_type element and add to the resource map. Also extract the ids
  * from any contained method and its representation or fault elements.
  *
  * @param file the URI of the current WADL file being processed
  * @param r the resource_type element
  * @throws javax.xml.bind.JAXBException if the WADL file is invalid or if the code generator
  *     encounters a problem.
  * @throws java.io.IOException if the specified WADL file cannot be read.
  */
 protected void extractResourceTypeIds(ResourceType r, URI file)
     throws JAXBException, IOException {
   String id = processIDHref(file, r.getId(), null, r);
   if (id != null) ifaceMap.put(id, null);
   for (Method child : r.getMethod()) {
     extractMethodIds((Method) child, file);
   }
 }
Beispiel #3
0
 public static String getValueByCode(String code) {
   for (ResourceType c : ResourceType.values()) {
     if (c.getCode().equals(code)) {
       return c.value;
     }
   }
   return null;
 }
 @Test(expected = IllegalArgumentException.class)
 public void forbidNullRelation() {
   ResourceTypeTree.builder()
       .addType(ResourceType.builder("TRK").build())
       .addType(ResourceType.builder("DIR").build())
       .addRelations("DIR" /* missing child */)
       .build();
 }
public class ResourceTypeTreeTest {
  private final ResourceTypeTree tree =
      ResourceTypeTree.builder()
          .addType(ResourceType.builder("TRK").build())
          .addType(ResourceType.builder("DIR").build())
          .addType(ResourceType.builder("FIL").build())
          .addType(ResourceType.builder("UTS").build())
          .addRelations("TRK", "DIR")
          .addRelations("DIR", "FIL")
          .addRelations("DIR", "UTS")
          .build();

  @Test
  public void getTypes() {
    assertThat(tree.getTypes().size(), is(4));
    assertThat(qualifiers(tree.getTypes()), hasItems("TRK", "DIR", "FIL", "UTS"));
  }

  @Test
  public void getChildren() {
    assertThat(tree.getChildren("TRK").size(), is(1));
    assertThat(tree.getChildren("TRK"), hasItems("DIR"));

    assertThat(tree.getChildren("DIR").size(), is(2));
    assertThat(tree.getChildren("DIR"), hasItems("FIL", "UTS"));

    assertThat(tree.getChildren("FIL").size(), is(0));
  }

  @Test
  public void getRoot() {
    assertThat(tree.getRootType(), is(ResourceType.builder("TRK").build()));
  }

  @Test
  public void getLeaves() {
    assertThat(tree.getLeaves().size(), is(2));
    assertThat(tree.getLeaves(), hasItems("FIL", "UTS"));
  }

  @Test(expected = IllegalArgumentException.class)
  public void forbidNullRelation() {
    ResourceTypeTree.builder()
        .addType(ResourceType.builder("TRK").build())
        .addType(ResourceType.builder("DIR").build())
        .addRelations("DIR" /* missing child */)
        .build();
  }

  @Test(expected = IllegalArgumentException.class)
  public void forbidDuplicatedType() {
    ResourceTypeTree.builder()
        .addType(ResourceType.builder("TRK").build())
        .addType(ResourceType.builder("TRK").build())
        .build();
  }
}
 public ResourceTypeTree build() {
   Collection<String> children = relations.values();
   for (ResourceType type : types) {
     if (!children.contains(type.getQualifier())) {
       root = type;
       break;
     }
   }
   return new ResourceTypeTree(this);
 }
Beispiel #7
0
 public static ResourceType getFileType(String fileName) {
   for (ResourceType type : ResourceType.values()) {
     for (String ext : type.getExts()) {
       if (fileName.endsWith(ext)) {
         return type;
       }
     }
   }
   return UNKNOWN;
 }
Beispiel #8
0
 public static void checkResourceType(ResourceType<?> resource) {
   // Check optional fields
   URI href = resource.getHref();
   if (href != null) checkHref(href);
   String type = resource.getType();
   if (type != null) checkType(type);
   Set<Link> links = resource.getLinks();
   if (links != null && !links.isEmpty()) {
     for (Link link : links) checkLink(link);
   }
 }
 /**
  * Build an abstract tree for a resource types in a WADL file
  *
  * @param ifaceId the identifier of the resource type
  * @param a the application element of the root WADL file
  */
 protected void buildResourceTypes(String ifaceId, Application a) {
   try {
     URI file = new URI(ifaceId.substring(0, ifaceId.indexOf('#')));
     ResourceType type = (ResourceType) idMap.get(ifaceId);
     ResourceTypeNode node = new ResourceTypeNode(type);
     for (Method m : type.getMethod()) {
       addMethodToResourceType(node, m, file);
     }
     ifaceMap.put(ifaceId, node);
   } catch (URISyntaxException ex) {
     ex.printStackTrace();
   }
 }
 /**
  * A comma-separated list that specifies the types of AWS resources for which AWS Config records
  * configuration changes (for example, <code>AWS::EC2::Instance</code> or <code>
  * AWS::CloudTrail::Trail</code>).
  *
  * <p>Before you can set this option to <code>true</code>, you must set the <code>allSupported
  * </code> option to <code>false</code>.
  *
  * <p>If you set this option to <code>true</code>, when AWS Config adds support for a new type of
  * resource, it will not record resources of that type unless you manually add that type to your
  * recording group.
  *
  * <p>For a list of valid <code>resourceTypes</code> values, see the <b>resourceType Value</b>
  * column in <a href=
  * "http://docs.aws.amazon.com/config/latest/developerguide/resource-config-reference.html#supported-resources"
  * >Supported AWS Resource Types</a>.
  *
  * @param resourceTypes A comma-separated list that specifies the types of AWS resources for which
  *     AWS Config records configuration changes (for example, <code>AWS::EC2::Instance</code> or
  *     <code>AWS::CloudTrail::Trail</code>).
  *     <p>Before you can set this option to <code>true</code>, you must set the <code>allSupported
  *     </code> option to <code>false</code>.
  *     <p>If you set this option to <code>true</code>, when AWS Config adds support for a new type
  *     of resource, it will not record resources of that type unless you manually add that type to
  *     your recording group.
  *     <p>For a list of valid <code>resourceTypes</code> values, see the <b>resourceType Value</b>
  *     column in <a href=
  *     "http://docs.aws.amazon.com/config/latest/developerguide/resource-config-reference.html#supported-resources"
  *     >Supported AWS Resource Types</a>.
  * @return Returns a reference to this object so that method calls can be chained together.
  * @see ResourceType
  */
 public RecordingGroup withResourceTypes(ResourceType... resourceTypes) {
   com.amazonaws.internal.SdkInternalList<String> resourceTypesCopy =
       new com.amazonaws.internal.SdkInternalList<String>(resourceTypes.length);
   for (ResourceType value : resourceTypes) {
     resourceTypesCopy.add(value.toString());
   }
   if (getResourceTypes() == null) {
     setResourceTypes(resourceTypesCopy);
   } else {
     getResourceTypes().addAll(resourceTypesCopy);
   }
   return this;
 }
  /**
   * Use this in place of valueOf.
   *
   * @param value real value
   * @return ResourceType corresponding to the value
   */
  public static ResourceType fromValue(String value) {
    if (value == null || "".equals(value)) {
      throw new IllegalArgumentException("Value cannot be null or empty!");
    }

    for (ResourceType enumEntry : ResourceType.values()) {
      if (enumEntry.toString().equals(value)) {
        return enumEntry;
      }
    }

    throw new IllegalArgumentException("Cannot create enum from " + value + " value!");
  }
Beispiel #12
0
  public boolean evaluateConfirmationExpression(
      UserType user,
      ShadowType shadow,
      ExpressionType expressionType,
      Task task,
      OperationResult result)
      throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException {
    Validate.notNull(user, "User must not be null.");
    Validate.notNull(shadow, "Resource object shadow must not be null.");
    Validate.notNull(expressionType, "Expression must not be null.");
    Validate.notNull(result, "Operation result must not be null.");

    ResourceType resource = resolveResource(shadow, result);
    ExpressionVariables variables = getDefaultXPathVariables(user, shadow, resource);
    String shortDesc = "confirmation expression for " + resource.asPrismObject();

    PrismPropertyDefinition<Boolean> outputDefinition =
        new PrismPropertyDefinition<>(
            ExpressionConstants.OUTPUT_ELMENT_NAME, DOMUtil.XSD_BOOLEAN, prismContext);
    Expression<PrismPropertyValue<Boolean>, PrismPropertyDefinition<Boolean>> expression =
        expressionFactory.makeExpression(expressionType, outputDefinition, shortDesc, task, result);

    ExpressionEvaluationContext params =
        new ExpressionEvaluationContext(null, variables, shortDesc, task, result);
    PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple =
        ModelExpressionThreadLocalHolder.evaluateExpressionInContext(
            expression, params, task, result);
    Collection<PrismPropertyValue<Boolean>> nonNegativeValues = outputTriple.getNonNegativeValues();
    if (nonNegativeValues == null || nonNegativeValues.isEmpty()) {
      throw new ExpressionEvaluationException(
          "Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
    }
    if (nonNegativeValues.size() > 1) {
      throw new ExpressionEvaluationException(
          "Expression returned more than one value ("
              + nonNegativeValues.size()
              + ") in "
              + shortDesc);
    }
    PrismPropertyValue<Boolean> resultpval = nonNegativeValues.iterator().next();
    if (resultpval == null) {
      throw new ExpressionEvaluationException(
          "Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
    }
    Boolean resultVal = resultpval.getValue();
    if (resultVal == null) {
      throw new ExpressionEvaluationException(
          "Expression returned no value (" + nonNegativeValues.size() + ") in " + shortDesc);
    }
    return resultVal;
  }
Beispiel #13
0
 public String toString() {
   StringBuffer sb = new StringBuffer();
   sb.append("<");
   for (int i = 0; i < ResourceType.values().length; i++) {
     if (i != 0) {
       sb.append(", ");
     }
     ResourceType resourceType = ResourceType.values()[i];
     sb.append(StringUtils.toLowerCase(resourceType.name()));
     sb.append(StringUtils.format(" weight=%.1f", getWeight(resourceType)));
   }
   sb.append(">");
   return sb.toString();
 }
 /**
  * storeResult
  *
  * @param collectionSet a {@link org.opennms.netmgt.collectd.SnmpCollectionSet} object.
  * @param entry a {@link org.opennms.netmgt.collectd.SNMPCollectorEntry} object.
  * @param res a {@link org.opennms.netmgt.snmp.SnmpResult} object.
  */
 public void storeResult(
     SnmpCollectionSet collectionSet, SNMPCollectorEntry entry, SnmpResult res) {
   LOG.debug("Setting attribute: {}.[{}] = '{}'", this, res.getInstance(), res.getValue());
   SnmpCollectionResource resource = null;
   if (this.getAlias().equals("ifAlias")) {
     resource = m_resourceType.findAliasedResource(res.getInstance(), res.getValue().toString());
   } else {
     resource = m_resourceType.findResource(res.getInstance());
   }
   if (resource == null) {
     collectionSet.notifyIfNotFound(this, res);
   } else {
     resource.setAttributeValue(this, res.getValue());
   }
 }
Beispiel #15
0
 public void delete_resources(ResourceType t, List<String> value) {
   Set<String> resources = resource_map.get(t);
   if (resources != null && !resources.isEmpty()) {
     t.postHook(resources, value);
     resources.removeAll(value);
   }
 }
 public Builder addType(ResourceType type) {
   Preconditions.checkNotNull(type);
   Preconditions.checkArgument(
       !types.contains(type), String.format("%s is already registered", type.getQualifier()));
   types.add(type);
   return this;
 }
  /**
   * Simple call to connector test() method.
   *
   * @throws Exception
   */
  @Test
  public void test310TestConnectionNegative() throws Exception {
    final String TEST_NAME = "test310TestConnectionNegative";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN

    OperationResult result = new OperationResult(TEST_NAME);

    ConnectorInstance badConnector =
        factory.createConnectorInstance(
            connectorType,
            ResourceTypeUtil.getResourceNamespace(badResourceType),
            "test connector");
    badConnector.configure(
        badResourceType.getConnectorConfiguration().asPrismContainerValue(), result);

    // WHEN

    badConnector.test(result);

    // THEN
    result.computeStatus("test failed");
    display("Test result (FAILURE EXPECTED)", result);
    AssertJUnit.assertNotNull(result);
    OperationResult connectorConnectionResult = result.getSubresults().get(1);
    AssertJUnit.assertNotNull(connectorConnectionResult);
    System.out.println(
        "Test \"connector connection\" result: "
            + connectorConnectionResult
            + " (FAILURE EXPECTED)");
    AssertJUnit.assertTrue(
        "Unexpected success of bad connector test", !connectorConnectionResult.isSuccess());
    AssertJUnit.assertTrue(!result.isSuccess());
  }
 public static void setParsedResourceSchemaConditional(
     ResourceType resourceType, ResourceSchema parsedSchema) {
   if (hasParsedSchema(resourceType)) {
     return;
   }
   PrismObject<ResourceType> resource = resourceType.asPrismObject();
   resource.setUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA, parsedSchema);
 }
 private CollectionTracker getCollectionTracker() {
   SnmpInstId[] instances = m_resourceType.getCollectionInstances();
   if (instances != null
       && Boolean.getBoolean(
           "org.opennms.netmgt.collectd.SnmpCollector.limitCollectionToInstances")) {
     return getMibObj().getCollectionTracker(instances);
   } else {
     return getMibObj().getCollectionTracker();
   }
 }
 @Override
 public int hashCode() {
   final int prime = 31;
   int result = super.hashCode();
   result = prime * result + ((address == null) ? 0 : address.hashCode());
   result = prime * result + ((addressOnParent == null) ? 0 : addressOnParent.hashCode());
   result = prime * result + ((resourceSubType == null) ? 0 : resourceSubType.hashCode());
   result = prime * result + ((resourceType == null) ? 0 : resourceType.hashCode());
   return result;
 }
Beispiel #21
0
 private void addResourceTypes() throws IOException {
   RandomAccessFile f = new RandomAccessFile("randomResourceType.csv", "r");
   String dataString = null;
   while ((dataString = f.readLine()) != null) {
     String[] data = dataString.split(";");
     ResourceType insert = new ResourceType();
     if (data[0].length() < 45) {
       insert.setResourceTypeName(data[0]);
     } else {
       insert.setResourceTypeName(data[0].substring(0, 44));
     }
     System.out.println(insert);
     try {
       resourceTypeDAO.insertResourceType(insert);
     } catch (ResourceTypeNameExistsException e) {
       e.printStackTrace();
     }
   }
   f.close();
 }
Beispiel #22
0
  public ResourceTypes(ResourceTypeTree[] trees) {
    Preconditions.checkNotNull(trees);

    Map<String, ResourceTypeTree> treeMap = Maps.newHashMap();
    Map<String, ResourceType> typeMap = Maps.newLinkedHashMap();
    Collection<ResourceType> rootsSet = Sets.newHashSet();

    for (ResourceTypeTree tree : trees) {
      rootsSet.add(tree.getRootType());
      for (ResourceType type : tree.getTypes()) {
        if (treeMap.containsKey(type.getQualifier())) {
          throw new IllegalStateException(
              "Qualifier " + type.getQualifier() + " is defined in several trees");
        }
        treeMap.put(type.getQualifier(), tree);
        typeMap.put(type.getQualifier(), type);
      }
    }
    treeByQualifier = ImmutableMap.copyOf(treeMap);
    typeByQualifier = ImmutableMap.copyOf(typeMap);
    rootTypes = ImmutableList.copyOf(rootsSet);
  }
  public static ResourceType find_resource_type(String s) {

    s = s.trim().toUpperCase();

    try {
      return ResourceType.valueOf(s);
    } catch (IllegalArgumentException e) {
    }

    // try singular
    if (s.endsWith("S")) {
      s = s.substring(0, s.length() - 1);
    } else {
      return null;
    }

    try {
      return ResourceType.valueOf(s);
    } catch (IllegalArgumentException e) {
    }
    return null;
  }
Beispiel #24
0
  @Override
  public int hashCode() {
    List<Object> list = new ArrayList<Object>();

    boolean present_resourceType = true && (isSetResourceType());
    list.add(present_resourceType);
    if (present_resourceType) list.add(resourceType.getValue());

    boolean present_uri = true && (isSetUri());
    list.add(present_uri);
    if (present_uri) list.add(uri);

    return list.hashCode();
  }
Beispiel #25
0
@Private
@Evolving
public class ResourceWeights {
  public static final ResourceWeights NEUTRAL = new ResourceWeights(1.0f);

  private float[] weights = new float[ResourceType.values().length];

  public ResourceWeights(float memoryWeight, float cpuWeight) {
    weights[ResourceType.MEMORY.ordinal()] = memoryWeight;
    weights[ResourceType.CPU.ordinal()] = cpuWeight;
  }

  public ResourceWeights(float weight) {
    setWeight(weight);
  }

  public ResourceWeights() {}

  public void setWeight(float weight) {
    for (int i = 0; i < weights.length; i++) {
      weights[i] = weight;
    }
  }

  public void setWeight(ResourceType resourceType, float weight) {
    weights[resourceType.ordinal()] = weight;
  }

  public float getWeight(ResourceType resourceType) {
    return weights[resourceType.ordinal()];
  }

  public String toString() {
    StringBuffer sb = new StringBuffer();
    sb.append("<");
    for (int i = 0; i < ResourceType.values().length; i++) {
      if (i != 0) {
        sb.append(", ");
      }
      ResourceType resourceType = ResourceType.values()[i];
      sb.append(StringUtils.toLowerCase(resourceType.name()));
      sb.append(StringUtils.format(" weight=%.1f", getWeight(resourceType)));
    }
    sb.append(">");
    return sb.toString();
  }
}
Beispiel #26
0
  /**
   * Register a new application on the node
   *
   * @param node the node to register on
   * @param type the type of an application
   * @param appInfo the appInfo string for the application
   */
  protected void addAppToNode(ClusterNode node, ResourceType type, String appInfo) {
    synchronized (node) {
      // Update primary index.
      Map<ResourceType, String> apps = nameToApps.get(node.getName());
      apps.put(type, appInfo);

      // Update runnable indices.
      for (Map.Entry<ResourceType, RunnableIndices> entry : typeToIndices.entrySet()) {
        if (type.equals(entry.getKey())) {
          if (node.checkForGrant(Utilities.getUnitResourceRequest(type), resourceLimit)) {
            RunnableIndices r = entry.getValue();
            r.addRunnable(node);
          }
        }
      }
    }
  }
Beispiel #27
0
  public static ExpressionVariables getDefaultXPathVariables(
      UserType user, ShadowType shadow, ResourceType resource) {

    ExpressionVariables variables = new ExpressionVariables();
    if (user != null) {
      variables.addVariableDefinition(ExpressionConstants.VAR_USER, user.asPrismObject());
    }

    if (shadow != null) {
      variables.addVariableDefinition(ExpressionConstants.VAR_ACCOUNT, shadow.asPrismObject());
    }

    if (resource != null) {
      variables.addVariableDefinition(ExpressionConstants.VAR_RESOURCE, resource.asPrismObject());
    }

    return variables;
  }
  @BeforeMethod
  public void initUcf() throws Exception {
    TestUtil.displayTestTile("initUcf");

    File file = new File(FILENAME_RESOURCE_OPENDJ);
    FileInputStream fis = new FileInputStream(file);

    // Resource
    PrismObject<ResourceType> resource =
        PrismTestUtil.parseObject(new File(FILENAME_RESOURCE_OPENDJ));
    resourceType = resource.asObjectable();

    // Resource: Second copy for negative test cases
    PrismObject<ResourceType> badResource =
        PrismTestUtil.parseObject(new File(FILENAME_RESOURCE_OPENDJ_BAD));
    badResourceType = badResource.asObjectable();

    // Connector
    PrismObject<ConnectorType> connector =
        PrismTestUtil.parseObject(new File(FILENAME_CONNECTOR_LDAP));
    connectorType = connector.asObjectable();

    factory = connectorFactoryIcfImpl;

    cc =
        factory.createConnectorInstance(
            connectorType, ResourceTypeUtil.getResourceNamespace(resourceType), "test connector");
    AssertJUnit.assertNotNull("Cannot create connector instance", cc);

    connectorSchema = cc.generateConnectorSchema();
    AssertJUnit.assertNotNull("Cannot generate connector schema", cc);
    display("Connector schema", connectorSchema);

    OperationResult result = new OperationResult("initUcf");
    cc.configure(resourceType.getConnectorConfiguration().asPrismContainerValue(), result);
    cc.initialize(null, null, false, result);
    // TODO: assert something

    resourceSchema = cc.fetchResourceSchema(null, result);
    display("Resource schema", resourceSchema);

    AssertJUnit.assertNotNull(resourceSchema);
  }
  public static RefinedResourceSchema parse(ResourceType resourceType, PrismContext prismContext)
      throws SchemaException {

    ResourceSchema originalResourceSchema = getResourceSchema(resourceType, prismContext);
    if (originalResourceSchema == null) {
      return null;
    }

    String contextDescription = "definition of " + resourceType;

    RefinedResourceSchemaImpl rSchema = new RefinedResourceSchemaImpl(originalResourceSchema);

    SchemaHandlingType schemaHandling = resourceType.getSchemaHandling();
    if (schemaHandling != null) {
      parseObjectTypeDefsFromSchemaHandling(
          rSchema,
          resourceType,
          schemaHandling,
          schemaHandling.getObjectType(),
          null,
          prismContext,
          contextDescription);
    }

    parseObjectTypesFromSchema(rSchema, resourceType, prismContext, contextDescription);

    // We need to parse associations and auxiliary object classes in a second pass. We need to have
    // all object classes parsed before correctly setting association
    // targets
    for (RefinedObjectClassDefinition rOcDef : rSchema.getRefinedDefinitions()) {
      ((RefinedObjectClassDefinitionImpl) rOcDef).parseAssociations(rSchema);
      ((RefinedObjectClassDefinitionImpl) rOcDef).parseAuxiliaryObjectClasses(rSchema);
    }

    // We can parse attributes only after we have all the object class info parsed (including
    // auxiliary object classes)
    for (RefinedObjectClassDefinition rOcDef : rSchema.getRefinedDefinitions()) {
      ((RefinedObjectClassDefinitionImpl) rOcDef).parseAttributes(rSchema, contextDescription);
    }

    return rSchema;
  }
 @Override
 public boolean equals(Object obj) {
   if (this == obj) return true;
   if (!super.equals(obj)) return false;
   if (getClass() != obj.getClass()) return false;
   ResourceAllocationSettingData other = (ResourceAllocationSettingData) obj;
   if (address == null) {
     if (other.address != null) return false;
   } else if (!address.equals(other.address)) return false;
   if (addressOnParent == null) {
     if (other.addressOnParent != null) return false;
   } else if (!addressOnParent.equals(other.addressOnParent)) return false;
   if (resourceSubType == null) {
     if (other.resourceSubType != null) return false;
   } else if (!resourceSubType.equals(other.resourceSubType)) return false;
   if (resourceType == null) {
     if (other.resourceType != null) return false;
   } else if (!resourceType.equals(other.resourceType)) return false;
   return true;
 }