<artifactId>snakeyaml</artifactId>
<version>1.17</version>
</dependency>
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-collections4</artifactId>
+ <version>${commons.collections.version}</version>
+ </dependency>
</dependencies>
</project>
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+public class ActivityDefinition {
+
+ private String delegate;
+ private String set_state;
+ private String call_operation;
+ private String inline;
+
+ public String getDelegate() {
+ return delegate;
+ }
+
+ public void setDelegate(String delegate) {
+ this.delegate = delegate;
+ }
+
+ public String getSet_state() {
+ return set_state;
+ }
+
+ public void setSet_state(String set_state) {
+ this.set_state = set_state;
+ }
+
+ public String getCall_operation() {
+ return call_operation;
+ }
+
+ public void setCall_operation(String call_operation) {
+ this.call_operation = call_operation;
+ }
+
+ public String getInline() {
+ return inline;
+ }
+
+ public void setInline(String inline) {
+ this.inline = inline;
+ }
+}
private String derived_from;
private String version;
+ private Map<String, String> metadata;
private String description;
private String mime_type;
private List<String> file_ext;
this.version = version;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
public String getDescription() {
return description;
}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+import java.util.Map;
+
+public class Credential {
+ private String protocol;
+ private String token_type;
+ private String token;
+ private Map<String, String> keys;
+ private String user;
+
+ public Credential(){
+ this.token_type = "password";
+ }
+
+ public String getProtocol() {
+ return protocol;
+ }
+
+ public void setProtocol(String protocol) {
+ this.protocol = protocol;
+ }
+
+ public String getToken_type() {
+ return token_type;
+ }
+
+ public void setToken_type(String token_type) {
+ this.token_type = token_type;
+ }
+
+ public String getToken() {
+ return token;
+ }
+
+ public void setToken(String token) {
+ this.token = token;
+ }
+
+ public Map<String, String> getKeys() {
+ return keys;
+ }
+
+ public void setKeys(Map<String, String> keys) {
+ this.keys = keys;
+ }
+
+ public String getUser() {
+ return user;
+ }
+
+ public void setUser(String user) {
+ this.user = user;
+ }
+}
private String derived_from;
private String version;
+ Map<String, String> metadata;
private String description;
private List<Constraint> constraints;
private Map<String, PropertyDefinition> properties;
this.version = version;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
/**
* Gets description.
*
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+public class EventFilter {
+
+ private String node;
+ private String requirement;
+ private String capability;
+
+ public String getNode() {
+ return node;
+ }
+
+ public void setNode(String node) {
+ this.node = node;
+ }
+
+ public String getRequirement() {
+ return requirement;
+ }
+
+ public void setRequirement(String requirement) {
+ this.requirement = requirement;
+ }
+
+ public String getCapability() {
+ return capability;
+ }
+
+ public void setCapability(String capability) {
+ this.capability = capability;
+ }
+}
private String type;
private String description;
+ private Map<String, String> metadata;
private Map<String, Object> properties;
private List<String> members;
+ private Map<String, Object> interfaces;
public String getType() {
return type;
public void setMembers(List<String> members) {
this.members = members;
}
+
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
+ public Map<String, Object> getInterfaces() {
+ return interfaces;
+ }
+
+ public void setInterfaces(
+ Map<String, Object> interfaces) {
+ this.interfaces = interfaces;
+ }
}
private String derived_from;
private String version;
+ private Map<String, String> metadata;
private String description;
private Map<String, PropertyDefinition> properties;
private List<String> members;
+ private List<Map<String, RequirementDefinition>> requirements;
+ private Map<String, CapabilityDefinition> capabilities;
private Map<String, Object> interfaces;
public String getDerived_from() {
this.version = version;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
+ public List<Map<String, RequirementDefinition>> getRequirements() {
+ return requirements;
+ }
+
+ public void setRequirements(
+ List<Map<String, RequirementDefinition>> requirements) {
+ this.requirements = requirements;
+ }
+
+ public Map<String, CapabilityDefinition> getCapabilities() {
+ return capabilities;
+ }
+
+ public void setCapabilities(
+ Map<String, CapabilityDefinition> capabilities) {
+ this.capabilities = capabilities;
+ }
+
public String getDescription() {
return description;
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.openecomp.sdc.tosca.datatypes.model;
+import org.apache.commons.collections4.MapUtils;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
public class InterfaceDefinition {
+
+ private String type;
+ private Map<String, PropertyDefinition> inputs;
+ private Map<String, OperationDefinition> operations;
+
+ public String getType() {
+ return type;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public Map<String, PropertyDefinition> getInputs() {
+ return inputs;
+ }
+
+ public void setInputs(
+ Map<String, PropertyDefinition> inputs) {
+ this.inputs = inputs;
+ }
+
+ public Map<String, OperationDefinition> getOperations() {
+ return operations;
+ }
+
+ public void addOperation(String operationName, OperationDefinition operationDefinition) {
+ if (MapUtils.isEmpty(this.operations)) {
+ this.operations = new HashMap<>();
+ }
+ this.operations.put(operationName, operationDefinition);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof InterfaceDefinition)) {
+ return false;
+ }
+ InterfaceDefinition that = (InterfaceDefinition) o;
+ return Objects.equals(type, that.type) &&
+ Objects.equals(inputs, that.inputs) &&
+ Objects.equals(operations, that.operations);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(type, inputs, operations);
+ }
}
package org.openecomp.sdc.tosca.datatypes.model;
+import org.apache.commons.collections4.MapUtils;
+import java.util.HashMap;
+import java.util.Map;
public class InterfaceType {
+ private String derived_from;
+ private String version;
+ private Map<String, String> metadata;
+ private String description;
+ private Map<String, PropertyDefinition> inputs;
+ private Map<String, OperationDefinition> operations;
+
+ public Map<String, PropertyDefinition> getInputs() {
+ return inputs;
+ }
+
+ public void setInputs(
+ Map<String, PropertyDefinition> inputs) {
+ this.inputs = inputs;
+ }
+
+ public String getDerived_from() {
+ return derived_from;
+ }
+
+ public void setDerived_from(String derived_from) {
+ this.derived_from = derived_from;
+ }
+
+ public String getVersion() {
+ return version;
+ }
+
+ public void setVersion(String version) {
+ this.version = version;
+ }
+
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public Map<String, OperationDefinition> getOperations() {
+ return operations;
+ }
+
+ public void setOperations(
+ Map<String, OperationDefinition> operations) {
+ this.operations = operations;
+ }
+
+ public void addOperation(String operationName, OperationDefinition operationDefinition) {
+ if(MapUtils.isEmpty(this.operations)){
+ this.operations = new HashMap<>();
+ }
+ this.operations.put(operationName, operationDefinition);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof InterfaceType)) {
+ return false;
+ }
+
+ InterfaceType that = (InterfaceType) o;
+
+ if (getDerived_from() != null ? !getDerived_from().equals(that.getDerived_from())
+ : that.getDerived_from() != null) {
+ return false;
+ }
+ if (getVersion() != null ? !getVersion().equals(that.getVersion())
+ : that.getVersion() != null) {
+ return false;
+ }
+ if (getMetadata() != null ? !getMetadata().equals(that.getMetadata())
+ : that.getMetadata() != null) {
+ return false;
+ }
+ if (getDescription() != null ? !getDescription().equals(that.getDescription())
+ : that.getDescription() != null) {
+ return false;
+ }
+ if (getInputs() != null ? !getInputs().equals(that.getInputs()) : that.getInputs() != null) {
+ return false;
+ }
+ return getOperations() != null ? getOperations().equals(that.getOperations())
+ : that.getOperations() == null;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = getDerived_from() != null ? getDerived_from().hashCode() : 0;
+ result = 31 * result + (getVersion() != null ? getVersion().hashCode() : 0);
+ result = 31 * result + (getMetadata() != null ? getMetadata().hashCode() : 0);
+ result = 31 * result + (getDescription() != null ? getDescription().hashCode() : 0);
+ result = 31 * result + (getInputs() != null ? getInputs().hashCode() : 0);
+ result = 31 * result + (getOperations() != null ? getOperations().hashCode() : 0);
+ return result;
+ }
}
private String type;
private String description;
+ private Map<String, String> metadata;
private List<String> directives;
private Map<String, Object> properties;
private Map<String, Object> attributes;
private List<Map<String, RequirementAssignment>> requirements;
private Map<String, CapabilityAssignment> capabilities;
- private Map<String, InterfaceDefinition> interfaces;
+ private Map<String, Object> interfaces;
private Map<String, ArtifactDefinition> artifacts;
private NodeFilter node_filter;
private String copy;
this.description = description;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
public List<String> getDirectives() {
return directives;
}
this.capabilities = capabilities;
}
- public Map<String, InterfaceDefinition> getInterfaces() {
+ public Map<String, Object> getInterfaces() {
return interfaces;
}
- public void setInterfaces(Map<String, InterfaceDefinition> interfaces) {
+ public void setInterfaces(Map<String, Object> interfaces) {
this.interfaces = interfaces;
}
@Override
public NodeTemplate clone() {
YamlUtil yamlUtil = new YamlUtil();
- NodeTemplate clone = yamlUtil.yamlToObject(yamlUtil.objectToYaml(this), NodeTemplate.class);
- return clone;
+ return yamlUtil.yamlToObject(yamlUtil.objectToYaml(this), NodeTemplate.class);
}
@Override
private String derived_from;
private String version;
+ private Map<String, String> metadata;
private String description;
private Map<String, PropertyDefinition> properties;
private Map<String, AttributeDefinition> attributes;
this.version = version;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
public String getDescription() {
return description;
}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+import java.util.Map;
+
+public class OperationDefinition {
+
+ private String description;
+ private String implementation;
+ private Map<String, PropertyDefinition> inputs;
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public String getImplementation() {
+ return implementation;
+ }
+
+ public void setImplementation(String implementation) {
+ this.implementation = implementation;
+ }
+
+ public Map<String, PropertyDefinition> getInputs() {
+ return inputs;
+ }
+
+ public void setInputs(
+ Map<String, PropertyDefinition> inputs) {
+ this.inputs = inputs;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof OperationDefinition)) {
+ return false;
+ }
+
+ OperationDefinition that = (OperationDefinition) o;
+
+ if (getDescription() != null ? !getDescription().equals(that.getDescription())
+ : that.getDescription() != null) {
+ return false;
+ }
+ if (getImplementation() != null ? !getImplementation().equals(that.getImplementation())
+ : that.getImplementation() != null) {
+ return false;
+ }
+ return getInputs() != null ? getInputs().equals(that.getInputs()) : that.getInputs() == null;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = getDescription() != null ? getDescription().hashCode() : 0;
+ result = 31 * result + (getImplementation() != null ? getImplementation().hashCode() : 0);
+ result = 31 * result + (getInputs() != null ? getInputs().hashCode() : 0);
+ return result;
+ }
+}
public class PolicyDefinition implements Template {
private String type;
private String description;
+ private Map<String, String> metadata;
private Map<String, Object> properties;
private List<String> targets;
this.description = description;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
public Map<String, Object> getProperties() {
return properties;
}
private String derived_from;
private String version;
+ private Map<String, String> metadata;
private String description;
private Map<String, PropertyDefinition> properties;
private List<String> targets;
+ private List<Trigger> triggers;
public String getDerived_from() {
return derived_from;
public void setTargets(List<String> targets) {
this.targets = targets;
}
+
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
+ public List<Trigger> getTriggers() {
+ return triggers;
+ }
+
+ public void setTriggers(
+ List<Trigger> triggers) {
+ this.triggers = triggers;
+ }
}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+public class PreconditionDefinition {
+
+ private String target;
+ private String target_relationship;
+ private Constraint condition;
+
+ public String getTarget() {
+ return target;
+ }
+
+ public void setTarget(String target) {
+ this.target = target;
+ }
+
+ public String getTarget_relationship() {
+ return target_relationship;
+ }
+
+ public void setTarget_relationship(String target_relationship) {
+ this.target_relationship = target_relationship;
+ }
+
+ public Constraint getCondition() {
+ return condition;
+ }
+
+ public void setCondition(Constraint condition) {
+ this.condition = condition;
+ }
+}
private String type;
private String description;
+ private Map<String, String> metadata;
private Map<String, Object> properties;
private Map<String, Object> attributes;
private Map<String, RequirementAssignment> requirements;
private Map<String, CapabilityAssignment> capabilities;
- private Map<String, InterfaceDefinition> interfaces;
+ private Map<String, Object> interfaces;
private String copy;
public String getType() {
this.description = description;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
public Map<String, Object> getProperties() {
return properties;
}
this.capabilities = capabilities;
}
- public Map<String, InterfaceDefinition> getInterfaces() {
+ public Map<String, Object> getInterfaces() {
return interfaces;
}
- public void setInterfaces(Map<String, InterfaceDefinition> interfaces) {
+ public void setInterfaces(Map<String, Object> interfaces) {
this.interfaces = interfaces;
}
private String derived_from;
private String version;
+ private Map<String, String> metadata;
private String description;
private Map<String, PropertyDefinition> properties;
private Map<String, AttributeDefinition> attributes;
this.version = version;
}
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
public String getDescription() {
return description;
}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+public class Repository {
+
+ private String description;
+ private String url;
+ private Credential credential;
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public String getUrl() {
+ return url;
+ }
+
+ public void setUrl(String url) {
+ this.url = url;
+ }
+
+ public Credential getCredential() {
+ return credential;
+ }
+
+ public void setCredential(Credential credential) {
+ this.credential = credential;
+ }
+}
/*
- * Copyright © 2016-2017 European Support Limited
+ * Copyright © 2016-2018 European Support Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.openecomp.sdc.tosca.datatypes.model;
+import org.apache.commons.collections4.MapUtils;
import org.openecomp.sdc.tosca.datatypes.model.heatextend.AnnotationType;
+
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
public class ServiceTemplate implements Template {
private String tosca_definitions_version;
private Map<String, String> metadata;
+ private Object dsl_definitions;
+ private Map<String, Repository> repositories;
private String description;
private List<Map<String, Import>> imports;
private Map<String, ArtifactType> artifact_types;
this.metadata = metadata;
}
+ public Object getDsl_definitions() {
+ return dsl_definitions;
+ }
+
+ public void setDsl_definitions(Object dsl_definitions) {
+ this.dsl_definitions = dsl_definitions;
+ }
+
+ public Map<String, Repository> getRepositories() {
+ return repositories;
+ }
+
+ public void setRepositories(
+ Map<String, Repository> repositories) {
+ this.repositories = repositories;
+ }
+
public String getDescription() {
return description;
}
this.interface_types = interface_types;
}
+ public void addInterfaceType(String interfaceKey, InterfaceType interfaceType) {
+ if (MapUtils.isEmpty(this.interface_types)) {
+ this.interface_types = new HashMap<>();
+ }
+
+ this.interface_types.put(interfaceKey, interfaceType);
+ }
+
public Map<String, PolicyType> getPolicy_types() {
return policy_types;
}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+import java.util.List;
+
+public class StepDefinition {
+
+ private String target;
+ private String target_relationship;
+ private String operation_host;
+ private List<Constraint> filter;
+ private List<ActivityDefinition> activities;
+ private String on_success;
+ private String on_failure;
+
+
+ public String getTarget() {
+ return target;
+ }
+
+ public void setTarget(String target) {
+ this.target = target;
+ }
+
+ public String getTarget_relationship() {
+ return target_relationship;
+ }
+
+ public void setTarget_relationship(String target_relationship) {
+ this.target_relationship = target_relationship;
+ }
+
+ public String getOperation_host() {
+ return operation_host;
+ }
+
+ public void setOperation_host(String operation_host) {
+ this.operation_host = operation_host;
+ }
+
+ public List<Constraint> getFilter() {
+ return filter;
+ }
+
+ public void setFilter(List<Constraint> filter) {
+ this.filter = filter;
+ }
+
+ public List<ActivityDefinition> getActivities() {
+ return activities;
+ }
+
+ public void setActivities(List<ActivityDefinition> activities) {
+ this.activities = activities;
+ }
+
+ public String getOn_success() {
+ return on_success;
+ }
+
+ public void setOn_success(String on_success) {
+ this.on_success = on_success;
+ }
+
+ public String getOn_failure() {
+ return on_failure;
+ }
+
+ public void setOn_failure(String on_failure) {
+ this.on_failure = on_failure;
+ }
+}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+import java.sql.Timestamp;
+
+public class TimeInterval {
+ private Timestamp start_time;
+ private Timestamp end_time;
+
+ public Timestamp getStart_time() {
+ return start_time;
+ }
+
+ public void setStart_time(Timestamp start_time) {
+ this.start_time = start_time;
+ }
+
+ public Timestamp getEnd_time() {
+ return end_time;
+ }
+
+ public void setEnd_time(Timestamp end_time) {
+ this.end_time = end_time;
+ }
+}
package org.openecomp.sdc.tosca.datatypes.model;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Objects;
private Map<String, ParameterDefinition> outputs;
private SubstitutionMapping substitution_mappings;
private Map<String, PolicyDefinition> policies;
+ private List<WorkflowDefinition> workflows;
public String getDescription() {
return description;
public void setPolicies(Map<String, PolicyDefinition> policies) {
this.policies = policies;
}
+
+ public List<WorkflowDefinition> getWorkflows() {
+ return workflows;
+ }
+
+ public void setWorkflows(List<WorkflowDefinition> workflows) {
+ this.workflows = workflows;
+ }
}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+import java.sql.Time;
+
+public class Trigger {
+
+ private String description;
+ private String event_type;
+ private TimeInterval schedule;
+ private EventFilter target_filter;
+ private Constraint condition;
+ private Constraint constraint;
+ private String period;
+ private int evaluations;
+ private String method;
+ //action - String or operation?
+ private Object action;
+
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public String getEvent_type() {
+ return event_type;
+ }
+
+ public void setEvent_type(String event_type) {
+ this.event_type = event_type;
+ }
+
+ public TimeInterval getSchedule() {
+ return schedule;
+ }
+
+ public void setSchedule(TimeInterval schedule) {
+ this.schedule = schedule;
+ }
+
+ public EventFilter getTarget_filter() {
+ return target_filter;
+ }
+
+ public void setTarget_filter(EventFilter target_filter) {
+ this.target_filter = target_filter;
+ }
+
+ public Constraint getCondition() {
+ return condition;
+ }
+
+ public void setCondition(Constraint condition) {
+ this.condition = condition;
+ }
+
+ public Constraint getConstraint() {
+ return constraint;
+ }
+
+ public void setConstraint(Constraint constraint) {
+ this.constraint = constraint;
+ }
+
+ public String getPeriod() {
+ return period;
+ }
+
+ public void setPeriod(String period) {
+ this.period = period;
+ }
+
+ public int getEvaluations() {
+ return evaluations;
+ }
+
+ public void setEvaluations(int evaluations) {
+ this.evaluations = evaluations;
+ }
+
+ public String getMethod() {
+ return method;
+ }
+
+ public void setMethod(String method) {
+ this.method = method;
+ }
+
+ public Object getAction() {
+ return action;
+ }
+
+ public void setAction(Object action) {
+ this.action = action;
+ }
+}
--- /dev/null
+package org.openecomp.sdc.tosca.datatypes.model;
+
+import java.util.List;
+import java.util.Map;
+
+public class WorkflowDefinition {
+ private String description;
+ private Map<String, String> metadata;
+ private Map<String, PropertyDefinition> inputs;
+ private List<PreconditionDefinition> preconditions;
+ private Map<String, StepDefinition> steps;
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public Map<String, String> getMetadata() {
+ return metadata;
+ }
+
+ public void setMetadata(Map<String, String> metadata) {
+ this.metadata = metadata;
+ }
+
+ public Map<String, PropertyDefinition> getInputs() {
+ return inputs;
+ }
+
+ public void setInputs(
+ Map<String, PropertyDefinition> inputs) {
+ this.inputs = inputs;
+ }
+
+ public List<PreconditionDefinition> getPreconditions() {
+ return preconditions;
+ }
+
+ public void setPreconditions(
+ List<PreconditionDefinition> preconditions) {
+ this.preconditions = preconditions;
+ }
+
+ public Map<String, StepDefinition> getSteps() {
+ return steps;
+ }
+
+ public void setSteps(
+ Map<String, StepDefinition> steps) {
+ this.steps = steps;
+ }
+}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.openecomp.sdc.common.utils;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
public class CommonUtil {
+ private static final String DEFAULT = "default";
+ private static final String _DEFAULT = "_default";
private CommonUtil() {
// prevent instantiation
public static FileContentHandler validateAndUploadFileContent(OnboardingTypesEnum type,
byte[] uploadedFileData)
throws IOException {
- return getFileContentMapFromOrchestrationCandidateZipAndValidateNoFolders(type, uploadedFileData);
+ return getFileContentMapFromOrchestrationCandidateZipAndValidateNoFolders(type,
+ uploadedFileData);
}
/**
* Gets files out of the zip AND validates zip is flat (no folders)
*
- *
- * @param type
* @param uploadFileData zip file
* @return FileContentHandler if input is valid and has no folders
*/
private static FileContentHandler getFileContentMapFromOrchestrationCandidateZipAndValidateNoFolders(
OnboardingTypesEnum type, byte[] uploadFileData)
throws IOException {
- Pair<FileContentHandler,List<String> > pair = getFileContentMapFromOrchestrationCandidateZip(uploadFileData);
+ Pair<FileContentHandler, List<String>> pair =
+ getFileContentMapFromOrchestrationCandidateZip(uploadFileData);
- if(isFileOriginFromZip(type.toString())) {
+ if (isFileOriginFromZip(type.toString())) {
validateNoFolders(pair.getRight());
}
return pair.getLeft();
}
- public static Pair<FileContentHandler,List<String> > getFileContentMapFromOrchestrationCandidateZip(
- byte[] uploadFileData)
- throws IOException {
+ public static Pair<FileContentHandler, List<String>> getFileContentMapFromOrchestrationCandidateZip(
+ byte[] uploadFileData)
+ throws IOException {
ZipEntry zipEntry;
List<String> folderList = new ArrayList<>();
FileContentHandler mapFileContent = new FileContentHandler();
- try ( ByteArrayInputStream in = new ByteArrayInputStream(uploadFileData);
- ZipInputStream inputZipStream = new ZipInputStream(in)){
+ try (ByteArrayInputStream in = new ByteArrayInputStream(uploadFileData);
+ ZipInputStream inputZipStream = new ZipInputStream(in)) {
byte[] fileByteContent;
String currentEntryName;
fileByteContent = FileUtils.toByteArray(inputZipStream);
int index = lastIndexFileSeparatorIndex(currentEntryName);
- if (index != -1) { //todo ?
+ if (index != -1) {
folderList.add(currentEntryName);
}
- if(isFile(currentEntryName)) {
+ if (isFile(currentEntryName)) {
mapFileContent.addFile(currentEntryName, fileByteContent);
}
}
throw new IOException(exception);
}
- return new ImmutablePair<>(mapFileContent,folderList);
+ return new ImmutablePair<>(mapFileContent, folderList);
}
private static boolean isFile(String currentEntryName) {
return validateFilesExtensions(allowedExtensions, files);
}
- public static boolean isFileOriginFromZip(String fileOrigin){
- return Objects.nonNull(fileOrigin)
+ public static boolean isFileOriginFromZip(String fileOrigin) {
+ return Objects.nonNull(fileOrigin)
&& fileOrigin.equalsIgnoreCase(OnboardingTypesEnum.ZIP.toString());
}
+
+ public static Set<String> getClassFieldNames(Class<? extends Object> classType) {
+ Set<String> fieldNames = new HashSet<>();
+ Arrays.stream(classType.getDeclaredFields()).forEach(field -> fieldNames.add(field.getName()));
+
+ return fieldNames;
+ }
+
+ public static <T> Optional<T> createObjectUsingSetters(Object objectCandidate,
+ Class<T> classToCreate)
+ throws Exception {
+ if (Objects.isNull(objectCandidate)) {
+ return Optional.empty();
+ }
+
+ Map<String, Object> objectAsMap = getObjectAsMap(objectCandidate);
+ T result = classToCreate.newInstance();
+ BeanUtils.populate(result, objectAsMap);
+
+ return Optional.of(result);
+ }
+
+ public static Map<String, Object> getObjectAsMap(Object obj) {
+ Map<String, Object> objectAsMap = obj instanceof Map ? (Map<String, Object>) obj
+ : new ObjectMapper().convertValue(obj, Map.class);
+
+ if (objectAsMap.containsKey(DEFAULT)) {
+ Object defaultValue = objectAsMap.get(DEFAULT);
+ objectAsMap.remove(DEFAULT);
+ objectAsMap.put(_DEFAULT, defaultValue);
+ }
+ return objectAsMap;
+ }
}
return CsarFileTypes.externalFile;
}
- private Optional<Manifest> getCsarManifest(Map<String, byte[]> csarFiles) throws IOException {
- Optional<byte[]> manifestContent = getManifestContent(csarFiles);
-
- if (manifestContent.isPresent()) {
- ByteArrayInputStream byteInputStream = new ByteArrayInputStream(manifestContent.get());
-
- return Optional.of(new Manifest(byteInputStream));
- }
-
- return Optional.empty();
- }
-
- private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
- NodeTemplate nodeTemplate = new NodeTemplate();
-
- Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
- nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
- nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
- nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
- nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
- nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
- nodeTemplate.setInterfaces(
- (Map<String, InterfaceDefinition>) nodeTemplateAsMap.get("interfaces"));
- nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get("node_filter"));
- nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
- nodeTemplate.setRequirements(
- (List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
- nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
- nodeTemplate.setCapabilities(
- convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));
+ private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
+ NodeTemplate nodeTemplate = new NodeTemplate();
+
+ Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
+ nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
+ nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
+ nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
+ nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
+ nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
+ nodeTemplate.setInterfaces(
+ (Map<String, Object>) nodeTemplateAsMap.get("interfaces"));
+ nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get("node_filter"));
+ nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
+ nodeTemplate.setRequirements(
+ (List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
+ nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
+ nodeTemplate.setCapabilities(
+ convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));
return nodeTemplate;
}
package org.openecomp.core.impl;
import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang.StringUtils;
import org.openecomp.core.converter.errors.CreateToscaObjectErrorBuilder;
import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.utils.CommonUtil;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
-import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
public class ToscaConverterUtil {
- private static final String SET = "set";
private static final String DEFAULT = "default";
private static final String DEFAULT_CAPITAL = "Default";
private static final Set<String> DEFAULT_VALUE_KEYS;
- private static final Logger LOGGER = LoggerFactory.getLogger(ToscaConverterUtil.class);
-
static {
DEFAULT_VALUE_KEYS =
Stream.of(DEFAULT, DEFAULT_CAPITAL).collect(Collectors.toSet());
// static utility methods only, prevent instantiation
}
- public static <T> Optional<T> createObjectFromClass(String objectId,
+ static <T> Optional<T> createObjectFromClass(String objectId,
Object objectCandidate,
Class<T> classToCreate) {
try {
- return createObjectUsingSetters(objectCandidate, classToCreate);
+ return CommonUtil.createObjectUsingSetters(objectCandidate, classToCreate);
} catch (Exception ex) {
throw new CoreException(
new CreateToscaObjectErrorBuilder(classToCreate.getSimpleName(), objectId)
}
}
- private static <T> Optional<T> createObjectUsingSetters(Object objectCandidate,
- Class<T> classToCreate)
- throws ReflectiveOperationException {
- if (Objects.isNull(objectCandidate)
- || !(objectCandidate instanceof Map)) {
- return Optional.empty();
- }
-
- Map<String, Object> objectAsMap = (Map<String, Object>) objectCandidate;
- Field[] classFields = classToCreate.getDeclaredFields();
- T result = classToCreate.newInstance();
-
- for (Field field : classFields) {
- Object fieldValueToAssign = objectAsMap.get(field.getName());
- String methodName = SET + StringUtils.capitalize(field.getName());
-
- if(shouldSetterMethodNeedsToGetInvoked(classToCreate, field, fieldValueToAssign, methodName)) {
- classToCreate.getMethod(methodName, field.getType()).invoke(result, fieldValueToAssign);
- }
- }
-
- return Optional.of(result);
- }
- private static <T> boolean shouldSetterMethodNeedsToGetInvoked(Class<T> classToCreate,
- Field field,
- Object fieldValueToAssign,
- String methodName) {
-
- try {
- return Objects.nonNull(fieldValueToAssign)
- && Objects.nonNull(classToCreate.getMethod(methodName, field.getType()));
- } catch (NoSuchMethodException e) {
- LOGGER.debug(String.format("Could not extract method '%s' from class '%s'. returning false " +
- "with filedType '%s'.", methodName, classToCreate, field.getType()), e);
- return false;
- }
- }
- public static Optional<Object> getDefaultValue(Object entryValue,
+ static Optional<Object> getDefaultValue(Object entryValue,
Object objectToAssignDefaultValue) {
if (!(entryValue instanceof Map)
|| Objects.isNull(objectToAssignDefaultValue)) {
--- /dev/null
+package org.openecomp.sdc.tosca.errors;
+
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+
+public class CreateInterfaceObjectErrorBuilder {
+
+ private static final String COULD_NOT_CREATE_OBJECT_MSG =
+ "Could not create %s from %s. Reason - %s";
+ private final ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+
+ public CreateInterfaceObjectErrorBuilder(String interfaceClassName,
+ String interfaceId,
+ String reason) {
+ builder.withId(ToscaErrorCodes.INVALID_INTERFACE_VALUE);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(
+ String.format(COULD_NOT_CREATE_OBJECT_MSG, interfaceClassName, interfaceId, reason));
+ }
+
+ public ErrorCode build() {
+ return builder.build();
+ }
+}
--- /dev/null
+package org.openecomp.sdc.tosca.errors;
+
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+
+public class CreateInterfaceOperationObjectErrorBuilder {
+ private static final String COULD_NOT_CREATE_OBJECT_MSG =
+ "Could not create Operation from %s. Reason - %s";
+ private final ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+
+ public CreateInterfaceOperationObjectErrorBuilder(String operationId,
+ String reason) {
+ builder.withId(ToscaErrorCodes.INVALID_INTERFACE_VALUE);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(
+ String.format(COULD_NOT_CREATE_OBJECT_MSG, operationId, reason));
+ }
+
+ public ErrorCode build() {
+ return builder.build();
+ }
+}
package org.openecomp.sdc.tosca.errors;
-public class ToscaErrorCodes {
+class ToscaErrorCodes {
static final String INVALID_SUBSTITUTE_NODE_TEMPLATE = "INVALID_SUBSTITUTE_NODE_TEMPLATE";
static final String INVALID_SUBSTITUTION_SERVICE_TEMPLATE =
static final String TOSCA_INVALID_SUBSTITUTE_NODE_TEMPLATE =
"TOSCA_INVALID_SUBSTITUTE_NODE_TEMPLATE";
static final String TOSCA_INVALID_ADD_ACTION_NULL_ENTITY = "TOSCA_INVALID_ADD_ACTION_NULL_ENTITY";
+ static final String INVALID_INTERFACE_VALUE = "INVALID_INTERFACE_VALUE";
}
--- /dev/null
+package org.openecomp.sdc.tosca.errors;
+
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+
+public class ToscaInvalidInterfaceValueErrorBuilder {
+
+ private static final String INVALID_INTERFACE_MSG =
+ "Cannot create interface object. reason - %s";
+ private final ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+
+ public ToscaInvalidInterfaceValueErrorBuilder(String reason) {
+ builder.withId(ToscaErrorCodes.INVALID_INTERFACE_VALUE);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(String.format(INVALID_INTERFACE_MSG, reason));
+ }
+
+ public ErrorCode build() {
+ return builder.build();
+ }
+}
package org.openecomp.sdc.tosca.services;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.openecomp.core.utilities.CommonMethods;
import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.utils.CommonUtil;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
import org.openecomp.sdc.tosca.datatypes.model.EntrySchema;
import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
import org.openecomp.sdc.tosca.datatypes.model.Import;
+import org.openecomp.sdc.tosca.datatypes.model.InterfaceDefinition;
+import org.openecomp.sdc.tosca.datatypes.model.InterfaceType;
import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
import org.openecomp.sdc.tosca.datatypes.model.NodeType;
+import org.openecomp.sdc.tosca.datatypes.model.OperationDefinition;
import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
import org.openecomp.sdc.tosca.datatypes.model.PolicyDefinition;
import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
import org.openecomp.sdc.tosca.datatypes.model.TopologyTemplate;
import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
+import org.openecomp.sdc.tosca.errors.CreateInterfaceObjectErrorBuilder;
+import org.openecomp.sdc.tosca.errors.CreateInterfaceOperationObjectErrorBuilder;
import org.openecomp.sdc.tosca.errors.InvalidAddActionNullEntityErrorBuilder;
import org.openecomp.sdc.tosca.errors.InvalidRequirementAssignmentErrorBuilder;
+import org.openecomp.sdc.tosca.errors.ToscaInvalidInterfaceValueErrorBuilder;
import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
import java.io.ByteArrayInputStream;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
+import java.util.Set;
/**
* The type Data model util.
private static final Logger logger = LoggerFactory.getLogger(DataModelUtil.class);
private static final String SERVICE_TEMPLATE = "Service Template";
private static final String NODE_TYPE = "Node Type";
+ private static final String OPERATIONS = "operations";
/**
* Add substitution mapping.
return capabilityMapping;
}
+
+ public static void addInterfaceOperation(ServiceTemplate serviceTemplate,
+ String interfaceId,
+ String operationId,
+ OperationDefinition operationDefinition) {
+ Map<String, Object> interfaceTypes = serviceTemplate.getInterface_types();
+ if (MapUtils.isEmpty(interfaceTypes)
+ || Objects.isNull(interfaceTypes.get(interfaceId))) {
+ return;
+ }
+
+ Object interfaceObject = interfaceTypes.get(interfaceId);
+ Map<String, Object> interfaceAsMap = CommonUtil.getObjectAsMap(interfaceObject);
+ interfaceAsMap.put(operationId, operationDefinition);
+ }
+
+ public static Map<String, InterfaceType> getInterfaceTypes(ServiceTemplate serviceTemplate) {
+ Map<String, Object> interfaceTypes = serviceTemplate.getInterface_types();
+
+ if (MapUtils.isEmpty(interfaceTypes)) {
+ return new HashMap<>();
+ }
+
+ Map<String, InterfaceType> convertedInterfaceTypes = new HashMap<>();
+ for (Map.Entry<String, Object> interfaceEntry : interfaceTypes.entrySet()) {
+ try {
+ Optional<InterfaceType> interfaceType =
+ convertObjToInterfaceType(interfaceEntry.getKey(), interfaceEntry.getValue());
+ interfaceType.ifPresent(
+ interfaceValue -> convertedInterfaceTypes.put(interfaceEntry.getKey(), interfaceValue));
+ } catch (Exception e) {
+ throw new CoreException(
+ new ToscaInvalidInterfaceValueErrorBuilder(e.getMessage()).build());
+ }
+ }
+
+ return convertedInterfaceTypes;
+ }
+
+ public static Optional<InterfaceDefinition> convertObjToInterfaceDefinition(
+ String interfaceId, Object interfaceObj)
+ throws CoreException {
+
+ try {
+ Optional<InterfaceDefinition> interfaceDefinition =
+ CommonUtil.createObjectUsingSetters(interfaceObj, InterfaceDefinition.class);
+ interfaceDefinition.ifPresent(interfaceDefinition1 -> updateInterfaceDefinitionOperations(
+ CommonUtil.getObjectAsMap(interfaceObj),
+ interfaceDefinition1));
+ return interfaceDefinition;
+ } catch (Exception ex) {
+ throw new CoreException(
+ new CreateInterfaceObjectErrorBuilder(InterfaceDefinition.class.getName(), interfaceId,
+ ex.getMessage()).build());
+ }
+
+ }
+
+ public static Optional<Object> convertInterfaceDefinitionToObj(
+ InterfaceDefinition interfaceDefinition) {
+ return converInetrfaceToToscaInterfaceObj(interfaceDefinition);
+ }
+
+ public static Optional<InterfaceType> convertObjToInterfaceType(String interfaceId,
+ Object interfaceObj)
+ throws CoreException {
+ try {
+ Optional<InterfaceType> interfaceType =
+ CommonUtil.createObjectUsingSetters(interfaceObj, InterfaceType.class);
+ interfaceType.ifPresent(
+ interfaceType1 -> updateInterfaceTypeOperations(CommonUtil.getObjectAsMap(interfaceObj),
+ interfaceType1));
+ return interfaceType;
+ } catch (Exception ex) {
+ throw new CoreException(
+ new CreateInterfaceObjectErrorBuilder(InterfaceType.class.getName(), interfaceId,
+ ex.getMessage()).build());
+ }
+ }
+
+ public static Optional<Object> convertInterfaceTypeToObj(InterfaceType interfaceType) {
+ return converInetrfaceToToscaInterfaceObj(interfaceType);
+ }
+
+ private static Optional<Object> converInetrfaceToToscaInterfaceObj(Object interfaceEntity) {
+ if (Objects.isNull(interfaceEntity)) {
+ return Optional.empty();
+ }
+
+ Map<String, Object> interfaceAsMap = CommonUtil.getObjectAsMap(interfaceEntity);
+ Map<String, Object> operations = (Map<String, Object>) interfaceAsMap.get(OPERATIONS);
+ if (MapUtils.isNotEmpty(operations)) {
+ interfaceAsMap.remove(OPERATIONS);
+ interfaceAsMap.putAll(operations);
+ }
+
+ ObjectMapper objectMapper = new ObjectMapper();
+ objectMapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);
+ return Optional.of(objectMapper.convertValue(interfaceAsMap, Object.class));
+ }
+
+ private static void updateInterfaceTypeOperations(Map<String, Object> interfaceAsMap,
+ InterfaceType interfaceType) {
+
+ Set<String> fieldNames = CommonUtil.getClassFieldNames(InterfaceType.class);
+
+ for (Map.Entry<String, Object> entry : interfaceAsMap.entrySet()) {
+ Optional<OperationDefinition> operationDefinition =
+ createOperation(entry.getKey(), entry.getValue(), fieldNames);
+ operationDefinition
+ .ifPresent(operation -> interfaceType.addOperation(entry.getKey(), operation));
+ }
+ }
+
+ private static Optional<OperationDefinition> createOperation(String propertyName,
+ Object operationCandidate,
+ Set<String> fieldNames)
+ throws CoreException {
+ if (!fieldNames.contains(propertyName)) {
+ try {
+ return CommonUtil.createObjectUsingSetters(operationCandidate, OperationDefinition.class);
+ } catch (Exception ex) {
+ throw new CoreException(
+ new CreateInterfaceOperationObjectErrorBuilder(propertyName, ex.getMessage()).build());
+ }
+ }
+
+ return Optional.empty();
+ }
+
+ private static void updateInterfaceDefinitionOperations(Map<String, Object> interfaceAsMap,
+ InterfaceDefinition interfaceDefinition) {
+
+ Set<String> fieldNames = CommonUtil.getClassFieldNames(InterfaceDefinition.class);
+
+ for (Map.Entry<String, Object> entry : interfaceAsMap.entrySet()) {
+ Optional<OperationDefinition> operationDefinition =
+ createOperation(entry.getKey(), entry.getValue(), fieldNames);
+ operationDefinition
+ .ifPresent(operation -> interfaceDefinition.addOperation(entry.getKey(), operation));
+
+ }
+ }
+
public static void addSubstitutionNodeTypeRequirements(NodeType substitutionNodeType,
List<Map<String, RequirementDefinition>>
requirementsList,
import org.openecomp.sdc.tosca.datatypes.model.Constraint;
import org.openecomp.sdc.tosca.datatypes.model.Directive;
import org.openecomp.sdc.tosca.datatypes.model.Import;
+import org.openecomp.sdc.tosca.datatypes.model.InterfaceDefinition;
+import org.openecomp.sdc.tosca.datatypes.model.InterfaceType;
import org.openecomp.sdc.tosca.datatypes.model.NodeFilter;
import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
import org.openecomp.sdc.tosca.datatypes.model.NodeType;
+import org.openecomp.sdc.tosca.datatypes.model.OperationDefinition;
import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
public class ToscaModelTest {
+ private YamlUtil yamlUtil = new YamlUtil();
+ private static final String INTERFACE_ID = "inter_1";
+ private static final String NODE_TEMPLATE_ID = "firstNodeTemplate";
+ private static final String BASE_DIR = "/mock/model";
+ private static final String ST = "/serviceTemplate.yaml";
+ private static final String ST_WITH_INTERFACE = "/serviceTemplateWithInterface.yaml";
+ private static final String ST_WITH_OPERATIONS = "/serviceTemplateWithInterfaceAndOperation.yaml";
+ private static final String ST_WITH_INTERFACE_DEF =
+ "/serviceTemplateWithNodeTemplateInterface.yaml";
+
@Test
public void testServiceTemplateJavaToYaml() {
-
ServiceTemplate serviceTemplate = new ServiceTemplate();
Map<String, String> metadata = new HashMap<>();
metadata.put("Template_author", "OPENECOMP");
imports.add(importsMap);
serviceTemplate.setImports(imports);
+ OperationDefinition operationDefinition = new OperationDefinition();
+ operationDefinition.setDescription("test operation");
+ InterfaceType interfaceType = new InterfaceType();
+ interfaceType.setDerived_from("derived_from");
+ interfaceType.setDescription("desc");
+ interfaceType.addOperation("test", operationDefinition);
+ serviceTemplate.addInterfaceType("test_interface", interfaceType);
+
ArtifactType artifact = new ArtifactType();
artifact.setMime_type("application/java-archive");
ArrayList<String> ext = new ArrayList<>();
@Test
public void testYamlToServiceTemplateObj() throws IOException {
- try (InputStream yamlFile = new YamlUtil().loadYamlFileIs("/mock/model/serviceTemplate.yaml")) {
- ServiceTemplate serviceTemplateFromYaml =
- new YamlUtil().yamlToObject(yamlFile, ServiceTemplate.class);
- Assert.assertNotNull(serviceTemplateFromYaml);
- }
+ ServiceTemplate serviceTemplateFromYaml =
+ getServiceTemplate(BASE_DIR + ST);
+ Assert.assertNotNull(serviceTemplateFromYaml);
}
+ @Test
+ public void testYamlWithInterfaceToServiceTemplateObj() throws IOException {
+ ServiceTemplate serviceTemplateWithOperation =
+ getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
+ Assert.assertNotNull(serviceTemplateWithOperation);
+
+ InterfaceType expectedInterfaceType = getInterfaceType();
+
+ Map<String, InterfaceType> interfaceTypes =
+ DataModelUtil.getInterfaceTypes(serviceTemplateWithOperation);
+ Assert.assertEquals(1, interfaceTypes.size());
+ InterfaceType actualInterfaceType = interfaceTypes.get(INTERFACE_ID);
+ Assert.assertEquals(expectedInterfaceType, actualInterfaceType);
+ }
+
+ @Test
+ public void testAddOperationToInterface() throws IOException {
+ YamlUtil yamlUtil = new YamlUtil();
+ ServiceTemplate serviceTemplateWithInterface =
+ getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE);
+ ServiceTemplate serviceTemplateWithOperation =
+ getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
+
+ OperationDefinition operationDefinition = getOperationDefinition();
+
+ DataModelUtil
+ .addInterfaceOperation(serviceTemplateWithInterface, INTERFACE_ID, "start",
+ operationDefinition);
+ String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithOperation);
+ String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterface);
+ Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
+ }
+
+ @Test
+ public void testInterfaceTypeToObjConversion() throws IOException {
+ ServiceTemplate serviceTemplateWithInterface =
+ getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE);
+ ServiceTemplate serviceTemplateWithOperation =
+ getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
+ InterfaceType interfaceType = getInterfaceType();
+
+ Optional<Object> interfaceAsObj = DataModelUtil.convertInterfaceTypeToObj(interfaceType);
+ Assert.assertTrue(interfaceAsObj.isPresent());
+
+ Map<String, Object> interfaceTypes = new HashMap<>();
+ interfaceTypes.put(INTERFACE_ID, interfaceAsObj.get());
+ serviceTemplateWithInterface.setInterface_types(interfaceTypes);
+
+ String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithOperation);
+ String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterface);
+ Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
+ }
+
+ @Test
+ public void testObjToInterfaceTypeConversion() throws IOException, ReflectiveOperationException {
+ ServiceTemplate serviceTemplateWithOperation =
+ getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
+ Map<String, Object> interfaceTypes = serviceTemplateWithOperation.getInterface_types();
+ Object interfaceObj = interfaceTypes.get(INTERFACE_ID);
+ Optional<InterfaceType> actualInterfaceType =
+ DataModelUtil.convertObjToInterfaceType(INTERFACE_ID, interfaceObj);
+
+ Assert.assertTrue(actualInterfaceType.isPresent());
+ InterfaceType expectedInterfaceType = getInterfaceType();
+ Assert.assertEquals(expectedInterfaceType, actualInterfaceType.get());
+ }
+
+ @Test
+ public void testInterfaceDefinitionToObjConversion() throws IOException {
+ ServiceTemplate serviceTemplate =
+ getServiceTemplate(BASE_DIR + ST);
+ ServiceTemplate serviceTemplateWithInterfaceDef =
+ getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE_DEF);
+
+ NodeTemplate nodeTemplate =
+ DataModelUtil.getNodeTemplate(serviceTemplate, NODE_TEMPLATE_ID);
+ InterfaceDefinition interfaceDefinition = getInterfaceDefinition();
+ Optional<Object> interfaceObj = DataModelUtil.convertInterfaceDefinitionToObj(interfaceDefinition);
+
+ Assert.assertTrue(interfaceObj.isPresent());
+ Map<String, Object> interfaces = new HashMap<>();
+ interfaces.put(INTERFACE_ID, interfaceObj.get());
+ nodeTemplate.setInterfaces(interfaces);
+
+ String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterfaceDef);
+ String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplate);
+ Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
+ }
+
+ @Test
+ public void testObjToInterfaceDefinitionConversion()
+ throws IOException, ReflectiveOperationException {
+ ServiceTemplate serviceTemplateWithInterfaceDef =
+ getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE_DEF);
+ NodeTemplate nodeTemplateWithInterface =
+ DataModelUtil.getNodeTemplate(serviceTemplateWithInterfaceDef, NODE_TEMPLATE_ID);
+ Map<String, Object> interfaces = nodeTemplateWithInterface.getInterfaces();
+ Object interfaceObj = interfaces.get(INTERFACE_ID);
+ Optional<InterfaceDefinition> actualInterfaceDefinition =
+ DataModelUtil.convertObjToInterfaceDefinition(INTERFACE_ID, interfaceObj);
+
+ Assert.assertTrue(actualInterfaceDefinition.isPresent());
+
+ InterfaceDefinition expectedInterfaceDefinition = getInterfaceDefinition();
+ Assert.assertEquals(expectedInterfaceDefinition, actualInterfaceDefinition.get());
+ }
@Test
public void testYamlToServiceTemplateIncludingHeatExtend() throws IOException {
ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
try (InputStream yamlFile =
- toscaExtensionYamlUtil.loadYamlFileIs("/mock/model/serviceTemplateHeatExtend.yaml")) {
+ toscaExtensionYamlUtil.loadYamlFileIs(BASE_DIR + "/serviceTemplateHeatExtend.yaml")) {
ServiceTemplate serviceTemplateFromYaml =
- toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
+ toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
ParameterDefinitionExt parameterDefinitionExt =
- (ParameterDefinitionExt) serviceTemplateFromYaml.getTopology_template().getInputs()
- .get("inParam1");
+ (ParameterDefinitionExt) serviceTemplateFromYaml.getTopology_template().getInputs()
+ .get("inParam1");
Assert.assertNotNull(parameterDefinitionExt.getLabel());
String backToYamlString = toscaExtensionYamlUtil.objectToYaml(serviceTemplateFromYaml);
Assert.assertNotNull(backToYamlString);
}
}
+ private ServiceTemplate getServiceTemplate(String inputPath) throws IOException {
+ try (InputStream yamlFile = yamlUtil.loadYamlFileIs(inputPath)) {
+ return yamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
+ }
+ }
+
+ private InterfaceType getInterfaceType() {
+ OperationDefinition operationDefinition = getOperationDefinition();
+ InterfaceType interfaceType = new InterfaceType();
+ interfaceType.setDescription("test interface");
+ interfaceType.addOperation("start", operationDefinition);
+ return interfaceType;
+ }
+
+ private OperationDefinition getOperationDefinition() {
+ OperationDefinition operationDefinition = new OperationDefinition();
+ operationDefinition.setDescription("start operation");
+ operationDefinition.setImplementation("start.sh");
+ return operationDefinition;
+ }
+
+ private InterfaceDefinition getInterfaceDefinition() {
+ OperationDefinition operationDefinition = getOperationDefinition();
+ InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("test interface");
+ interfaceDefinition.addOperation("start", operationDefinition);
+ return interfaceDefinition;
+ }
+
}
entry_schema:
type: tosca.myType
node_templates:
- firatNodeTemplate:
+ firstNodeTemplate:
type: nodeTypeRef
directives:
- selectable
capability: capA
node: nodeA
relationship: relationB
- capabilities:
- cap1:
- properties:
- num_cpus: '{ get_input: cpus }'
- attributes:
- num_cpus: '66'
- node_filter:
- properties:
- test1:
- - equal: 1 MB
substitution_mappings:
node_type: myNodeType.node
capabilities:
--- /dev/null
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+metadata:
+ template_name: Test
+ template_author: OPENECOMP
+ template_version: 1.0.0
+description: testing desc tosca service template
+imports:
+- myfile1:
+ file: path1/path2/file1.yaml
+- myfile2:
+ file: path1/path2/file2.yaml
+artifact_types:
+ one_artifact:
+ mime_type: application/java-archive
+ file_ext:
+ - yaml
+ - xml
+interface_types:
+ inter_1:
+ description: test interface
+node_types:
+ compute_node_type:
+ derived_from: tosca.nodes.Root
+ version: 1.0.0
+ description: tosca compute test
+ properties:
+ cpu_num:
+ type: integer
+ description: Number of CPUs requested for a software node instance
+ required: true
+ default: 1
+ status: SUPPORTED
+ constraints:
+ - greater_or_equal: 5.0
+ - equal: 5
+ - greater_than: 6.02
+ - in_range:
+ - 0
+ - UNBOUNDED
+ attributes:
+ attDef1:
+ type: string
+ default: hi
+ status: SUPPORTED
+ requirements:
+ - re1:
+ capability: tosca.cap1
+ occurrences:
+ - 5
+ - 1
+ capabilities:
+ cap1:
+ type: tosca.cap
+ valid_source_types:
+ - node1
+ - node2
+ occurrences:
+ - 1
+ - UNBOUNDED
+topology_template:
+ description: topologi template descroption
+ inputs:
+ inParam1:
+ type: string
+ description: desc
+ required: false
+ default: my default val
+ constraints:
+ - greater_than: 6
+ - greater_or_equal: 9
+ entry_schema:
+ type: tosca.myType
+ node_templates:
+ firstNodeTemplate:
+ type: nodeTypeRef
+ directives:
+ - selectable
+ - substitutable
+ properties:
+ prop2: '{ get_input: my_mysql_rootpw }'
+ prop1: abcd
+ attributes:
+ att2: '{ get_input: my_mysql_rootpw }'
+ att1: att1Val
+ requirements:
+ - req1:
+ capability: capA
+ node: nodeA
+ relationship: relationB
+ node_filter:
+ properties:
+ propName1:
+ - greater_or_equal: 9
+ propName2:
+ - min_length: 1
+ - max_length: 2
+ occurrences:
+ - 1
+ - 2
+ - req2:
+ capability: capA
+ node: nodeA
+ relationship: relationB
+ substitution_mappings:
+ node_type: myNodeType.node
+ capabilities:
+ database_endpoint:
+ - database
+ - database_endpoint
--- /dev/null
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+metadata:
+ template_name: Test
+ template_author: OPENECOMP
+ template_version: 1.0.0
+description: testing desc tosca service template
+imports:
+- myfile1:
+ file: path1/path2/file1.yaml
+- myfile2:
+ file: path1/path2/file2.yaml
+artifact_types:
+ one_artifact:
+ mime_type: application/java-archive
+ file_ext:
+ - yaml
+ - xml
+interface_types:
+ inter_1:
+ description: test interface
+ start:
+ description: start operation
+ implementation: start.sh
+node_types:
+ compute_node_type:
+ derived_from: tosca.nodes.Root
+ version: 1.0.0
+ description: tosca compute test
+ properties:
+ cpu_num:
+ type: integer
+ description: Number of CPUs requested for a software node instance
+ required: true
+ default: 1
+ status: SUPPORTED
+ constraints:
+ - greater_or_equal: 5.0
+ - equal: 5
+ - greater_than: 6.02
+ - in_range:
+ - 0
+ - UNBOUNDED
+ attributes:
+ attDef1:
+ type: string
+ default: hi
+ status: SUPPORTED
+ requirements:
+ - re1:
+ capability: tosca.cap1
+ occurrences:
+ - 5
+ - 1
+ capabilities:
+ cap1:
+ type: tosca.cap
+ valid_source_types:
+ - node1
+ - node2
+ occurrences:
+ - 1
+ - UNBOUNDED
+topology_template:
+ description: topologi template descroption
+ inputs:
+ inParam1:
+ type: string
+ description: desc
+ required: false
+ default: my default val
+ constraints:
+ - greater_than: 6
+ - greater_or_equal: 9
+ entry_schema:
+ type: tosca.myType
+ node_templates:
+ firstNodeTemplate:
+ type: nodeTypeRef
+ directives:
+ - selectable
+ - substitutable
+ properties:
+ prop2: '{ get_input: my_mysql_rootpw }'
+ prop1: abcd
+ attributes:
+ att2: '{ get_input: my_mysql_rootpw }'
+ att1: att1Val
+ requirements:
+ - req1:
+ capability: capA
+ node: nodeA
+ relationship: relationB
+ node_filter:
+ properties:
+ propName1:
+ - greater_or_equal: 9
+ propName2:
+ - min_length: 1
+ - max_length: 2
+ occurrences:
+ - 1
+ - 2
+ - req2:
+ capability: capA
+ node: nodeA
+ relationship: relationB
+ substitution_mappings:
+ node_type: myNodeType.node
+ capabilities:
+ database_endpoint:
+ - database
+ - database_endpoint
--- /dev/null
+tosca_definitions_version: tosca_simple_yaml_1_0_0
+metadata:
+ template_name: Test
+ template_author: OPENECOMP
+ template_version: 1.0.0
+description: testing desc tosca service template
+imports:
+- myfile1:
+ file: path1/path2/file1.yaml
+- myfile2:
+ file: path1/path2/file2.yaml
+artifact_types:
+ one_artifact:
+ mime_type: application/java-archive
+ file_ext:
+ - yaml
+ - xml
+node_types:
+ compute_node_type:
+ derived_from: tosca.nodes.Root
+ version: 1.0.0
+ description: tosca compute test
+ properties:
+ cpu_num:
+ type: integer
+ description: Number of CPUs requested for a software node instance
+ required: true
+ default: 1
+ status: SUPPORTED
+ constraints:
+ - greater_or_equal: 5.0
+ - equal: 5
+ - greater_than: 6.02
+ - in_range:
+ - 0
+ - UNBOUNDED
+ attributes:
+ attDef1:
+ type: string
+ default: hi
+ status: SUPPORTED
+ requirements:
+ - re1:
+ capability: tosca.cap1
+ occurrences:
+ - 5
+ - 1
+ capabilities:
+ cap1:
+ type: tosca.cap
+ valid_source_types:
+ - node1
+ - node2
+ occurrences:
+ - 1
+ - UNBOUNDED
+topology_template:
+ description: topologi template descroption
+ inputs:
+ inParam1:
+ type: string
+ description: desc
+ required: false
+ default: my default val
+ constraints:
+ - greater_than: 6
+ - greater_or_equal: 9
+ entry_schema:
+ type: tosca.myType
+ node_templates:
+ firstNodeTemplate:
+ type: nodeTypeRef
+ directives:
+ - selectable
+ - substitutable
+ interfaces:
+ inter_1:
+ type: test interface
+ start:
+ description: start operation
+ implementation: start.sh
+ properties:
+ prop2: '{ get_input: my_mysql_rootpw }'
+ prop1: abcd
+ attributes:
+ att2: '{ get_input: my_mysql_rootpw }'
+ att1: att1Val
+ requirements:
+ - req1:
+ capability: capA
+ node: nodeA
+ relationship: relationB
+ node_filter:
+ properties:
+ propName1:
+ - greater_or_equal: 9
+ propName2:
+ - min_length: 1
+ - max_length: 2
+ occurrences:
+ - 1
+ - 2
+ - req2:
+ capability: capA
+ node: nodeA
+ relationship: relationB
+ substitution_mappings:
+ node_type: myNodeType.node
+ capabilities:
+ database_endpoint:
+ - database
+ - database_endpoint
Code Review / sdc.git / commitdiff