import org.onap.aaiclient.client.aai.entities.Relationships;
import org.onap.aaiclient.client.aai.entities.uri.AAIResourceUri;
import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
+import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder;
import org.onap.aaiclient.client.graphinventory.entities.uri.Depth;
import org.onap.aaiclient.client.graphinventory.exceptions.BulkProcessFailed;
import org.onap.logging.filter.base.ErrorCode;
}
}
lIf.setL2Multicasting(isL2Multicast);
+
+ transaction.createIfNotExists(AAIUriFactory.createResourceUri(AAIObjectType.L_INTERFACE, cloudOwner,
+ cloudRegionId, tenantId, port.getDeviceId(), lIf.getInterfaceName()), Optional.of(lIf));
+
updateLInterfaceIps(port, lIf);
if (cloudOwner.equals(env.getProperty("mso.cloudOwner.included", ""))) {
updateLInterfaceVlan(port, lIf);
}
- // Update l-interface to the vserver
- transaction.create(AAIUriFactory.createResourceUri(AAIObjectType.L_INTERFACE, cloudOwner, cloudRegionId,
- tenantId, port.getDeviceId(), lIf.getInterfaceName()), lIf);
-
updateSriovPfToPserver(port, lIf);
}
}
vlan.setInMaint(false);
vlan.setIsIpUnnumbered(false);
vlan.setIsPrivate(false);
- Vlans vlans = new Vlans();
- List<Vlan> vlanList = vlans.getVlan();
- vlanList.add(vlan);
- lIf.setVlans(vlans);
+
+ transaction
+ .createIfNotExists(
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.cloudInfrastructure()
+ .cloudRegion(cloudOwner, cloudRegionId).tenant(tenantId).vserver(port.getDeviceId())
+ .lInterface(lIf.getInterfaceName()).vlan(vlan.getVlanInterface())),
+ Optional.of(vlan));
}
- // Build sriov-vf to the l-interface
+
if (port.getvNicType() != null && port.getvNicType().equalsIgnoreCase(HeatBridgeConstants.OS_SRIOV_PORT_TYPE)) {
- SriovVfs sriovVfs = new SriovVfs();
- // JAXB does not generate setters for list, however getter ensures its creation.
- // Thus, all list manipulations must be made on live list.
- List<SriovVf> sriovVfList = sriovVfs.getSriovVf();
SriovVf sriovVf = new SriovVf();
sriovVf.setPciId(port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString());
sriovVf.setNeutronNetworkId(port.getNetworkId());
sriovVf.setVfVlanFilter("0");
sriovVf.setVfVlanAntiSpoofCheck(false);
sriovVf.setVfMacAntiSpoofCheck(false);
- sriovVfList.add(sriovVf);
- lIf.setSriovVfs(sriovVfs);
+ transaction
+ .createIfNotExists(
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.cloudInfrastructure()
+ .cloudRegion(cloudOwner, cloudRegionId).tenant(tenantId).vserver(port.getDeviceId())
+ .lInterface(lIf.getInterfaceName()).sriovVf(sriovVf.getPciId())),
+ Optional.of(sriovVf));
}
}
AAIResourceUri sriovPfUri = AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_PF,
pserverHostName, matchingPifName.get(), sriovPf.getPfPciId());
- transaction.create(sriovPfUri, sriovPf);
+ if (!resourcesClient.exists(sriovPfUri)) {
+ transaction.create(sriovPfUri, sriovPf);
- AAIResourceUri sriovVfUri = AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_VF,
- cloudOwner, cloudRegionId, tenantId, port.getDeviceId(), lIf.getInterfaceName(),
- port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString());
+ AAIResourceUri sriovVfUri = AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_VF,
+ cloudOwner, cloudRegionId, tenantId, port.getDeviceId(), lIf.getInterfaceName(),
+ port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString());
- transaction.connect(sriovPfUri, sriovVfUri);
+ transaction.connect(sriovPfUri, sriovVfUri);
+ }
}
}
} catch (WebApplicationException e) {
}
private void updateLInterfaceIps(final Port port, final LInterface lIf) {
- List<L3InterfaceIpv4AddressList> lInterfaceIps = lIf.getL3InterfaceIpv4AddressList();
for (IP ip : port.getFixedIps()) {
String ipAddress = ip.getIpAddress();
if (InetAddressValidator.getInstance().isValidInet4Address(ipAddress)) {
lInterfaceIp.setNeutronNetworkId(port.getNetworkId());
lInterfaceIp.setNeutronSubnetId(ip.getSubnetId());
lInterfaceIp.setL3InterfaceIpv4PrefixLength(Long.parseLong(cidr.getNetworkPrefixLength().toString()));
- lInterfaceIps.add(lInterfaceIp);
+
+ transaction.createIfNotExists(
+ AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.cloudInfrastructure()
+ .cloudRegion(cloudOwner, cloudRegionId).tenant(tenantId).vserver(port.getDeviceId())
+ .lInterface(lIf.getInterfaceName()).l3InterfaceIpv4AddressList(ipAddress)),
+ Optional.of(lInterfaceIp));
}
}
}
heatbridge.buildAddVserverLInterfacesToAaiAction(stackResources, Arrays.asList("1", "2"), "CloudOwner");
// Assert
- verify(transaction, times(5)).create(any(AAIResourceUri.class), any(LInterface.class));
+ verify(transaction, times(15)).createIfNotExists(any(AAIResourceUri.class), any(Optional.class));
verify(osClient, times(5)).getPortById(anyString());
verify(osClient, times(10)).getNetworkById(anyString());
}
heatbridge.buildAddVserverLInterfacesToAaiAction(stackResources, Arrays.asList("1", "2"), "CloudOwner");
// Assert
- verify(transaction, times(5)).create(any(AAIResourceUri.class), any(LInterface.class));
+ verify(transaction, times(5)).createIfNotExists(any(AAIResourceUri.class), any(Optional.class));
verify(osClient, times(5)).getPortById(anyString());
verify(osClient, times(5)).getNetworkById(anyString());
}
@Component
public class ApplicationControllerClient {
-
@Autowired
public Environment env;
controllerType = DEFAULT_CONTROLLER_TYPE;
}
controllerType = controllerType.toUpperCase();
+
return AppcClientServiceFactoryProvider.getFactory(AppcLifeCycleManagerServiceFactory.class)
.createLifeCycleManagerStateful(new ApplicationContext(), getLCMProperties(controllerType));
} catch (AppcClientException e) {
}
public Status vnfCommand(Action action, String requestId, String vnfId, Optional<String> vserverId,
- Optional<String> request, String controllerType, ApplicationControllerCallback listener)
+ Optional<String> request, String controllerType, ApplicationControllerCallback listener, String requestorId)
throws ApplicationControllerOrchestratorException {
this.setControllerType(controllerType);
Status status;
payload = new Payload(request.get());
}
- status = runCommand(action, actionIdentifiers, payload, requestId, listener);
+ status = runCommand(action, actionIdentifiers, payload, requestId, listener, requestorId);
if (appCSupport.getCategoryOf(status).equals(StatusCategory.ERROR)) {
throw new ApplicationControllerOrchestratorException(status.getMessage(), status.getCode());
} else {
public Status runCommand(Action action, org.onap.appc.client.lcm.model.ActionIdentifiers actionIdentifiers,
- org.onap.appc.client.lcm.model.Payload payload, String requestID, ApplicationControllerCallback listener)
- throws ApplicationControllerOrchestratorException {
+ org.onap.appc.client.lcm.model.Payload payload, String requestID, ApplicationControllerCallback listener,
+ String requestorId) throws ApplicationControllerOrchestratorException {
Status status;
Object requestObject;
- requestObject = createRequest(action, actionIdentifiers, payload, requestID);
+ requestObject = createRequest(action, actionIdentifiers, payload, requestID, requestorId);
appCSupport.logLCMMessage(requestObject);
LifeCycleManagerStateful client = getAppCClient();
Method lcmMethod = appCSupport.getAPIMethod(action.name(), client, true);
return properties;
}
- public Object createRequest(Action action, ActionIdentifiers identifier, Payload payload, String requestId) {
+ public Object createRequest(Action action, ActionIdentifiers identifier, Payload payload, String requestId,
+ String requestorId) {
Object requestObject = appCSupport.getInput(action.name());
try {
- CommonHeader commonHeader = buildCommonHeader(requestId);
+ CommonHeader commonHeader = buildCommonHeader(requestId, requestorId);
requestObject.getClass().getDeclaredMethod("setCommonHeader", CommonHeader.class).invoke(requestObject,
commonHeader);
requestObject.getClass().getDeclaredMethod("setAction", Action.class).invoke(requestObject, action);
return requestObject;
}
- private CommonHeader buildCommonHeader(String requestId) {
+ private CommonHeader buildCommonHeader(String requestId, String requestorId) {
CommonHeader commonHeader = new CommonHeader();
commonHeader.setApiVer(API_VER);
commonHeader.setOriginatorId(ORIGINATOR_ID);
commonHeader.setRequestId(requestId == null ? UUID.randomUUID().toString() : requestId);
commonHeader.setSubRequestId(UUID.randomUUID().toString());
+ commonHeader.setXOnapRequestorid(requestorId);
Flags flags = new Flags();
String flagsMode = "NORMAL";
Mode mode = Mode.valueOf(flagsMode);
status = appcClient.vnfCommand(request.getAction(), msoRequestId,
request.getApplicationControllerVnf().getVnfId(), vserverId, payload, request.getControllerType(),
- listener);
+ listener, request.getRequestorId());
return status;
}
@Before
public void setup() {
request = new ApplicationControllerTaskRequest();
+ request.setRequestorId("testRequestorId");
request.setBookName("testBookName");
request.setControllerType("testControllerType");
request.setFileParameters("testFileParams");
request.setNewSoftwareVersion("2.0");
request.setExistingSoftwareVersion("1.0");
request.setOperationsTimeout("30");
+ request.setRequestorId("testRequestorId");
Map<String, String> reqConfigParams = new HashMap<>();
reqConfigParams.put("name1", "value1");
reqConfigParams.put("name2", "value2");
Mockito.when(applicationControllerClient.vnfCommand(Action.HealthCheck, "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(Action.HealthCheck, "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), Optional.empty(),
- "testControllerType", listener)).thenReturn(new Status());
+ "testControllerType", listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), Optional.empty(),
- "testControllerType", listener);
+ "testControllerType", listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener)).thenReturn(new Status());
+ listener, "testRequestorId")).thenReturn(new Status());
Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
- listener);
+ listener, "testRequestorId");
}
@Test
String identityUrl = execution.getVariable("identityUrl");
appcTaskRequest.setIdentityUrl(identityUrl);
+ String requestorId = gBBInput.getRequestContext().getRequestorId();
+ appcTaskRequest.setRequestorId(requestorId);
+
if (gBBInput.getRequestContext().getRequestParameters() != null) {
String payload = gBBInput.getRequestContext().getRequestParameters().getPayload();
if (payload == null) {
private void fillRequiredAppcExecutionFields() {
RequestContext context = new RequestContext();
context.setMsoRequestId("TEST-MSO-ID");
+ context.setRequestorId("testRequestorId");
execution.setVariable("aicIdentity", "AIC-TEST");
execution.setVariable("vmIdList", "VM-ID-LIST-TEST");
execution.setVariable("vserverIdList", "VSERVER-ID-LIST");
"{\"request_parameters\":{\"host_ip_address\":\"10.10.10.10\"},\"configuration_parameters\":{\"name1\":\"value1\",\"name2\":\"value2\"}}");
context.setRequestParameters(requestParameters);
context.setMsoRequestId("TEST-MSO-ID");
+ context.setRequestorId("testRequestorId");
execution.setVariable("aicIdentity", "AIC-TEST");
execution.setVariable("vmIdList", "VM-ID-LIST-TEST");
execution.setVariable("vserverIdList", "VSERVER-ID-LIST");
"ApplicationControllerTaskRequest": {
"controllerType": "TEST-CONTROLLER-NAME",
"action": "Lock",
+ "requestorId": "testRequestorId",
"identityUrl": "IDENTITY-URL-TEST",
"applicationControllerVnf": {
"vnfId": "TEST-VNF-ID",
"ApplicationControllerTaskRequest": {
"controllerType": "APPC",
"action": "ConfigModify",
+ "requestorId": "testRequestorId",
"identityUrl": "IDENTITY-URL-TEST",
"applicationControllerVnf": {
"vnfId": "TEST-VNF-ID",
private static final long serialVersionUID = -3150320542857627682L;
private Action action;
+ private String requestorId;
private String controllerType;
private String identityUrl;
private String operationsTimeout;
this.newSoftwareVersion = newSoftwareVersion;
}
+ public String getRequestorId() {
+ return requestorId;
+ }
+
+ public void setRequestorId(String requestorId) {
+ this.requestorId = requestorId;
+ }
+
}
package org.onap.aaiclient.client.aai;
import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
import javax.ws.rs.NotFoundException;
import javax.ws.rs.core.UriBuilder;
-import org.onap.so.client.RestClient;
import org.onap.aaiclient.client.graphinventory.GraphInventoryClient;
import org.onap.aaiclient.client.graphinventory.exceptions.GraphInventoryUriComputationException;
+import org.onap.so.client.RestClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
protected AAIVersion version;
protected AAIClient() {
- super(AAIProperties.class);
+ super(AAIProperties.class, new HashMap<String, String>());
}
protected AAIClient(AAIVersion version) {
- super(AAIProperties.class);
+ super(AAIProperties.class, new HashMap<String, String>());
+ this.version = version;
+ }
+
+ protected AAIClient(Map<String, String> additionalHeaders) {
+ super(AAIProperties.class, additionalHeaders);
+ }
+
+ protected AAIClient(AAIVersion version, Map<String, String> additionalHeaders) {
+ super(AAIProperties.class, additionalHeaders);
this.version = version;
}
protected RestClient createClient(URI uri) {
try {
- return new AAIRestClient(getRestProperties(), constructPath(uri));
+ return new AAIRestClient(getRestProperties(), constructPath(uri), additionalHeaders);
} catch (GraphInventoryUriComputationException | NotFoundException e) {
logger.debug("failed to construct A&AI uri", e);
throw e;
import org.onap.aaiclient.client.graphinventory.GraphInventoryQueryClient;
import org.onap.aaiclient.client.graphinventory.entities.DSLQuery;
import org.onap.aaiclient.client.graphinventory.entities.uri.GraphInventoryUri;
+import com.google.common.collect.ImmutableMap;
public class AAIDSLQueryClient
extends GraphInventoryQueryClient<AAIDSLQueryClient, DSLQuery, AAIResultWrapper, AAIObjectType> {
public AAIDSLQueryClient() {
- super(new AAIClient());
+ super(new AAIClient(ImmutableMap.of("X-DslApiVersion", "V2")));
}
public AAIDSLQueryClient(AAIVersion version) {
- super(new AAIClient(version));
+ super(new AAIClient(version, ImmutableMap.of("X-DslApiVersion", "V2")));
}
@Override
public AAIObjectType createType(String name, String uri) {
return new AAIFluentTypeReverseLookup().fromName(name, uri);
}
-
}
import java.net.URI;
import java.util.Map;
import java.util.Optional;
-import org.onap.so.client.ResponseExceptionMapper;
import org.onap.aaiclient.client.graphinventory.GraphInventoryPatchConverter;
import org.onap.aaiclient.client.graphinventory.GraphInventoryRestClient;
import org.onap.logging.filter.base.ONAPComponents;
+import org.onap.so.client.ResponseExceptionMapper;
public class AAIRestClient extends GraphInventoryRestClient {
private final AAIProperties aaiProperties;
+ private final Map<String, String> additionalHeaders;
- protected AAIRestClient(AAIProperties props, URI uri) {
+ protected AAIRestClient(AAIProperties props, URI uri, Map<String, String> additionalHeaders) {
super(props, uri);
this.aaiProperties = props;
+ this.additionalHeaders = additionalHeaders;
}
@Override
protected void initializeHeaderMap(Map<String, String> headerMap) {
headerMap.put("X-FromAppId", aaiProperties.getSystemName());
headerMap.put("X-TransactionId", requestId);
+ headerMap.putAll(additionalHeaders);
String auth = aaiProperties.getAuth();
String key = aaiProperties.getKey();
package org.onap.aaiclient.client.graphinventory;
import java.net.URI;
+import java.util.Map;
+import org.onap.aaiclient.client.graphinventory.entities.uri.GraphInventoryUri;
+import org.onap.aaiclient.client.graphinventory.entities.uri.HttpAwareUri;
import org.onap.so.client.RestClient;
import org.onap.so.client.RestProperties;
import org.onap.so.client.RestPropertiesLoader;
-import org.onap.aaiclient.client.graphinventory.entities.uri.GraphInventoryUri;
-import org.onap.aaiclient.client.graphinventory.entities.uri.HttpAwareUri;
+import com.google.common.collect.ImmutableMap;
public abstract class GraphInventoryClient {
private RestProperties props;
+ protected final Map<String, String> additionalHeaders;
- protected GraphInventoryClient(Class<? extends RestProperties> propertiesClass) {
+ protected GraphInventoryClient(Class<? extends RestProperties> propertiesClass,
+ Map<String, String> additionalHeaders) {
RestProperties props = RestPropertiesLoader.getInstance().getNewImpl(propertiesClass);
this.props = props;
+ this.additionalHeaders = additionalHeaders;
}
protected abstract URI constructPath(URI uri);
public abstract GraphInventoryVersion getVersion();
public abstract String getGraphDBName();
+
+ public Map<String, String> getAdditionalHeaders() {
+ return ImmutableMap.copyOf(this.additionalHeaders);
+ }
}
}
return clone;
}
+
+ public GraphInventoryClient getClient() {
+ return this.client;
+ }
}
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
import java.util.List;
+import java.util.stream.Collectors;
import org.onap.aaiclient.client.aai.entities.QueryStep;
import org.onap.aaiclient.client.graphinventory.GraphInventoryObjectName;
public abstract class DSLNodeBase<T extends DSLNodeBase<?>> implements QueryStep {
protected final String nodeName;
+ protected final Collection<String> fields;
protected final List<DSLNodeKey> nodeKeys;
protected final StringBuilder query;
protected boolean output = false;
this.nodeName = "";
this.nodeKeys = new ArrayList<>();
this.query = new StringBuilder();
+ this.fields = new LinkedHashSet<>();
}
this.nodeName = name.typeName();
this.nodeKeys = new ArrayList<>();
this.query = new StringBuilder();
+ this.fields = new LinkedHashSet<>();
query.append(nodeName);
}
this.nodeName = name.typeName();
this.nodeKeys = Arrays.asList(key);
this.query = new StringBuilder();
+ this.fields = new LinkedHashSet<>();
query.append(nodeName);
}
this.nodeName = copy.nodeName;
this.nodeKeys = copy.nodeKeys;
this.query = new StringBuilder(copy.query);
+ this.fields = copy.fields;
this.output = copy.output;
}
return new DSLOutputNode(this);
}
+ public DSLOutputNode output(String... fields) {
+ this.output = true;
+ this.fields.addAll(Arrays.asList(fields));
+ return new DSLOutputNode(this);
+ }
+
public T and(DSLNodeKey... key) {
this.nodeKeys.addAll(Arrays.asList(key));
public String build() {
StringBuilder result = new StringBuilder(query);
if (output) {
- result.append("*");
+ if (fields.isEmpty()) {
+ result.append("*");
+ } else {
+ String items =
+ fields.stream().map(item -> String.format("'%s'", item)).collect(Collectors.joining(", "));
+ result.append("{").append(items).append("}");
+ }
}
for (DSLNodeKey key : nodeKeys) {
result.append(key.build());
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.function.Consumer;
import java.util.stream.Collectors;
import org.onap.aaiclient.client.aai.entities.QueryStep;
import org.onap.aaiclient.client.graphinventory.GraphInventoryObjectName;
}
public DSLQueryBuilder<S, Node> output() {
+ callOnLambda(item -> item.output());
+ return (DSLQueryBuilder<S, Node>) this;
+ }
+
+ public DSLQueryBuilder<S, Node> output(String... fields) {
+ callOnLambda(item -> item.output(fields));
+ return (DSLQueryBuilder<S, Node>) this;
+ }
+
+ protected void callOnLambda(Consumer<DSLNodeBase> consumer) {
+
Object obj = steps.get(steps.size() - 1);
if (obj instanceof DSLNodeBase) {
((DSLNodeBase) steps.get(steps.size() - 1)).output();
try {
o = f.get(obj);
if (o instanceof DSLQueryBuilder && ((DSLQueryBuilder) o).steps.get(0) instanceof DSLNodeBase) {
- ((DSLNodeBase) ((DSLQueryBuilder) o).steps.get(0)).output();
+ consumer.accept(((DSLNodeBase) ((DSLQueryBuilder) o).steps.get(0)));
}
} catch (IllegalArgumentException | IllegalAccessException e) {
}
break;
}
}
- return (DSLQueryBuilder<S, Node>) this;
}
@SafeVarargs
--- /dev/null
+package org.onap.aaiclient.client.aai;
+
+import static org.junit.Assert.assertEquals;
+import java.net.URISyntaxException;
+import org.junit.Test;
+
+public class AAIDSLQueryClientTest {
+
+
+
+ @Test
+ public void verifyHeadersTest() throws URISyntaxException {
+
+ AAIDSLQueryClient client = new AAIDSLQueryClient();
+ assertEquals("V2", client.getClient().getAdditionalHeaders().get("X-DslApiVersion"));
+ }
+}
package org.onap.aaiclient.client.aai;
+import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
+import static com.github.tomakehurst.wiremock.client.WireMock.equalTo;
+import static com.github.tomakehurst.wiremock.client.WireMock.get;
+import static com.github.tomakehurst.wiremock.client.WireMock.getRequestedFor;
+import static com.github.tomakehurst.wiremock.client.WireMock.matching;
+import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
+import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;
import static org.hamcrest.CoreMatchers.containsString;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import java.net.URI;
import java.net.URISyntaxException;
+import java.util.HashMap;
import javax.ws.rs.core.Response;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.onap.so.client.RestClientSSL;
+import org.onap.aaiclient.client.defaultproperties.DefaultAAIPropertiesImpl;
import org.onap.aaiclient.client.graphinventory.GraphInventoryPatchConverter;
import org.onap.aaiclient.client.graphinventory.exceptions.GraphInventoryPatchDepthExceededException;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.github.tomakehurst.wiremock.junit.WireMockRule;
+import com.google.common.collect.ImmutableMap;
@RunWith(MockitoJUnitRunner.class)
public class AAIRestClientTest {
@Rule
public ExpectedException thrown = ExpectedException.none();
+ @Rule
+ public WireMockRule wireMockRule = new WireMockRule(wireMockConfig().dynamicPort());
+
@Test
public void failPatchOnComplexObject() throws URISyntaxException {
- AAIRestClient client = new AAIRestClient(props, new URI(""));
+ AAIRestClient client = new AAIRestClient(props, new URI(""), new HashMap<String, String>());
this.thrown.expect(GraphInventoryPatchDepthExceededException.class);
this.thrown.expectMessage(containsString("Object exceeds allowed depth for update action"));
client.patch(
@Test
public void verifyPatchValidation() throws URISyntaxException {
- AAIRestClient client = new AAIRestClient(props, new URI(""));
+ AAIRestClient client = new AAIRestClient(props, new URI(""), new HashMap<String, String>());
AAIRestClient spy = spy(client);
GraphInventoryPatchConverter patchValidatorMock = mock(GraphInventoryPatchConverter.class);
doReturn(patchValidatorMock).when(spy).getPatchConverter();
spy.patch(payload);
verify(patchValidatorMock, times(1)).convertPatchFormat(eq((Object) payload));
}
+
+ @Test
+ public void verifyAdditionalHeadersTest() throws URISyntaxException {
+ AAIRestClient client = new AAIRestClient(new DefaultAAIPropertiesImpl(wireMockRule.port()), new URI("/test"),
+ ImmutableMap.of("test", "value"));
+ wireMockRule.stubFor(get(urlPathEqualTo("/test")).willReturn(aResponse().withStatus(200)));
+ client.get();
+ wireMockRule.verify(getRequestedFor(urlPathEqualTo("/test")).withHeader("X-FromAppId", equalTo("MSO"))
+ .withHeader("X-TransactionId", matching(".*")).withHeader("test", equalTo("value")));
+ }
}
"generic-vnf*('vnf-id', 'vnfId') > " + "[ pserver* > complex*, " + "vserver > pserver* > complex* ]",
builder.build().get());
}
+
+ @Test
+ public void selectOutputFilterTest() {
+ DSLQueryBuilder<Output, Output> builder =
+ TraversalBuilder.traversal(new DSLStartNode(AAIObjectType.CLOUD_REGION, __.key("cloud-owner", "att-nc"))
+ .output("cloud-region-id", "a", "b"));
+ builder.to(__.node(AAIObjectType.PSERVER)).output("x", "y", "z");
+
+ assertEquals("cloud-region{'cloud-region-id', 'a', 'b'}('cloud-owner', 'att-nc') > pserver{'x', 'y', 'z'}",
+ builder.build().toString());
+ }
}
<format.skipValidate>false</format.skipValidate>
<format.skipExecute>true</format.skipExecute>
<io.fabric8.version>0.33.0</io.fabric8.version>
- <appc.client.version>1.7.1</appc.client.version>
+ <appc.client.version>1.8.0-SNAPSHOT</appc.client.version>
<bowman.client.version>0.8.0</bowman.client.version>
<aaf.cadi.version>2.1.15</aaf.cadi.version>
</properties>
Code Review / so.git / commitdiff