public TopologyTemplate searchTopologyTemplateByName(String name) {
Map<String, String[]> filters =
MapUtil.newHashMap(new String[] {"name"}, new String[][] {new String[] {name}});
GetMultipleDataResult<TopologyTemplate> result =
alienDAO.find(TopologyTemplate.class, filters, Integer.MAX_VALUE);
if (result.getTotalResults() > 0) {
return result.getData()[0];
}
return null;
}
private Deployment getActiveDeployment() {
Deployment deployment = null;
GetMultipleDataResult<Deployment> dataResult =
dao.search(
Deployment.class,
null,
MapUtil.newHashMap(
new String[] {"cloudId", "endDate"},
new String[][] {new String[] {cloudId}, new String[] {null}}),
1);
if (dataResult.getData() != null && dataResult.getData().length > 0) {
deployment = dataResult.getData()[0];
}
return deployment;
}
/**
* Get events for a specific deployment from an environment
*
* @param applicationEnvironmentId The environment we want to get events from
* @param from The initial position of the events to get (based on time desc sorting)
* @param size The number of events to get.
* @return A result that contains all events.
*/
public GetMultipleDataResult<?> getDeploymentEvents(
String applicationEnvironmentId, int from, int size) {
Deployment deployment = deploymentService.getActiveDeploymentOrFail(applicationEnvironmentId);
String index = alienMonitorDao.getIndexForType(AbstractMonitorEvent.class);
QueryHelper.SearchQueryHelperBuilder searchQueryHelperBuilder =
queryHelper
.buildSearchQuery(index)
.types(
PaaSDeploymentStatusMonitorEvent.class,
PaaSInstanceStateMonitorEvent.class,
PaaSMessageMonitorEvent.class,
PaaSInstancePersistentResourceMonitorEvent.class)
.filters(
MapUtil.newHashMap(
new String[] {"deploymentId"},
new String[][] {new String[] {deployment.getId()}}))
.fieldSort("_timestamp", true);
return alienMonitorDao.search(searchQueryHelperBuilder, from, size);
}
@SuppressWarnings("unchecked")
@Test
public void testNodeType() throws FileNotFoundException, ParsingException {
Mockito.reset(repositorySearchService);
IndexedNodeType mockedResult = Mockito.mock(IndexedNodeType.class);
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedNodeType.class),
Mockito.eq("tosca.nodes.SoftwareComponent"),
Mockito.any(List.class)))
.thenReturn(mockedResult);
Mockito.when(mockedResult.getDerivedFrom()).thenReturn(Lists.newArrayList("tosca.nodes.Root"));
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedNodeType.class),
Mockito.eq("tosca.nodes.Root"),
Mockito.any(List.class)))
.thenReturn(mockedResult);
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedNodeType.class),
Mockito.eq("tosca.nodes.Compute"),
Mockito.any(List.class)))
.thenReturn(mockedResult);
IndexedCapabilityType mockedCapabilityResult = Mockito.mock(IndexedCapabilityType.class);
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedCapabilityType.class),
Mockito.eq("mytypes.mycapabilities.MyCapabilityTypeName"),
Mockito.any(List.class)))
.thenReturn(mockedCapabilityResult);
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedCapabilityType.class),
Mockito.eq("mytypes.mycapabilities.MyCapabilityTypeName"),
Mockito.any(List.class)))
.thenReturn(mockedCapabilityResult);
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedCapabilityType.class),
Mockito.eq("tosca.capabilities.Endpoint"),
Mockito.any(List.class)))
.thenReturn(mockedCapabilityResult);
IndexedRelationshipType hostedOn = new IndexedRelationshipType();
Mockito.when(
repositorySearchService.getElementInDependencies(
Mockito.eq(IndexedRelationshipType.class),
Mockito.eq("tosca.relationships.HostedOn"),
Mockito.any(List.class)))
.thenReturn(hostedOn);
ParsingResult<ArchiveRoot> parsingResult =
parser.parseFile(Paths.get(getRootDirectory(), "tosca-node-type.yml"));
assertNoBlocker(parsingResult);
ArchiveRoot archiveRoot = parsingResult.getResult();
Assert.assertNotNull(archiveRoot.getArchive());
Assert.assertEquals(getToscaVersion(), archiveRoot.getArchive().getToscaDefinitionsVersion());
Assert.assertEquals(1, archiveRoot.getNodeTypes().size());
// check node type.
Entry<String, IndexedNodeType> entry = archiveRoot.getNodeTypes().entrySet().iterator().next();
Assert.assertEquals("my_company.my_types.MyAppNodeType", entry.getKey());
IndexedNodeType nodeType = entry.getValue();
Assert.assertEquals(
Lists.newArrayList("tosca.nodes.SoftwareComponent", "tosca.nodes.Root"),
nodeType.getDerivedFrom());
Assert.assertEquals("My company’s custom applicaton", nodeType.getDescription());
// validate properties parsing
Assert.assertEquals(4, nodeType.getProperties().size());
PropertyDefinition def1 = new PropertyDefinition();
def1.setType("string");
def1.setDefault(new ScalarPropertyValue("default"));
def1.setDescription("application password");
List<PropertyConstraint> constraints = Lists.newArrayList();
constraints.add(new MinLengthConstraint(6));
constraints.add(new MaxLengthConstraint(10));
def1.setConstraints(constraints);
PropertyDefinition def2 = new PropertyDefinition();
def2.setType("integer");
def2.setDescription("application port number");
PropertyDefinition def3 = new PropertyDefinition();
def3.setType("scalar-unit.size");
def3.setDefault(new ScalarPropertyValue("1 GB"));
LessThanConstraint ltConstraint = new LessThanConstraint();
ltConstraint.setLessThan("1 TB");
constraints = Lists.<PropertyConstraint>newArrayList(ltConstraint);
def3.setConstraints(constraints);
PropertyDefinition def4 = new PropertyDefinition();
def4.setType("scalar-unit.time");
def4.setDefault(new ScalarPropertyValue("1 d"));
GreaterThanConstraint gtConstraint = new GreaterThanConstraint();
gtConstraint.setGreaterThan("1 h");
constraints = Lists.<PropertyConstraint>newArrayList(gtConstraint);
def4.setConstraints(constraints);
Assert.assertEquals(
MapUtil.newHashMap(
new String[] {"my_app_password", "my_app_duration", "my_app_size", "my_app_port"},
new PropertyDefinition[] {def1, def4, def3, def2}),
nodeType.getProperties());
// check requirements
Assert.assertEquals(2, nodeType.getRequirements().size());
RequirementDefinition rd0 = nodeType.getRequirements().get(0);
Assert.assertEquals("host", rd0.getId());
Assert.assertEquals(1, rd0.getLowerBound());
Assert.assertEquals(1, rd0.getUpperBound());
RequirementDefinition rd1 = nodeType.getRequirements().get(1);
Assert.assertEquals("other", rd1.getId());
Assert.assertEquals(0, rd1.getLowerBound());
Assert.assertEquals(Integer.MAX_VALUE, rd1.getUpperBound());
// validate attributes parsing
// nodeType.getAttributes()
// nodeType.getInterfaces()
// nodeType.getCapabilities()
// nodeType.get
}
