diff options
26 files changed, 3620 insertions, 0 deletions
diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/AAIExternalSystemInfoProvider.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/AAIExternalSystemInfoProvider.java new file mode 100644 index 00000000..f5656f75 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/AAIExternalSystemInfoProvider.java @@ -0,0 +1,120 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import org.onap.aai.domain.yang.v11.EsrSystemInfo; +import org.onap.aai.domain.yang.v11.EsrSystemInfoList; +import org.onap.aai.domain.yang.v11.EsrVnfm; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.GenericExternalSystemInfoProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vnfmdriver.model.VimInfo; +import org.onap.vnfmdriver.model.VnfmInfo; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.core.env.Environment; +import org.springframework.stereotype.Component; + +import static java.lang.String.format; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.CLOUD; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.ESR; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; +import static org.slf4j.LoggerFactory.getLogger; + +/** + * Responsible for providing information related to the VNFM from VF-C source + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +public class AAIExternalSystemInfoProvider extends GenericExternalSystemInfoProvider { + private static final String VNFM_URL = "/esr-vnfm-list/esr-vnfm/%s?depth=all"; + private static final String VIM_URL = "/cloud-regions/cloud-region/%s/%s/esr-system-info-list"; + private static Logger logger = getLogger(AAIExternalSystemInfoProvider.class); + private final AAIRestApiProvider aaiRestApiProvider; + + @Autowired + AAIExternalSystemInfoProvider(Environment environment, AAIRestApiProvider aaiRestApiProvider) { + super(environment); + this.aaiRestApiProvider = aaiRestApiProvider; + } + + @Override + public VnfmInfo queryVnfmInfoFromSource(String vnfmId) { + try { + return convertEsrToVnfmInfo(aaiRestApiProvider.get(logger, ESR, format(VNFM_URL, vnfmId), EsrVnfm.class)); + } catch (RuntimeException e) { + throw buildFatalFailure(logger, "Unable to query VNFM with " + vnfmId + " identifier from AAI", e); + } + } + + @Override + public VimInfo getVimInfo(String vimId) { + try { + return convertEsrToVim(getEsrSystemInfo(vimId), vimId); + } catch (RuntimeException e) { + throw buildFatalFailure(logger, "Unable to query VIM with " + vimId + " identifier from AAI", e); + } + } + + /** + * @param vimId the identifier of the VIM + * @return the VIM details + */ + public EsrSystemInfo getEsrSystemInfo(String vimId) { + String url = format(VIM_URL, getCloudOwner(vimId), getRegionName(vimId)); + return aaiRestApiProvider.get(logger, CLOUD, url, EsrSystemInfoList.class).getEsrSystemInfo().get(0); + } + + private VimInfo convertEsrToVim(EsrSystemInfo esrSystemInfo, String vimId) { + VimInfo vimInfo = new VimInfo(); + vimInfo.setDescription(esrSystemInfo.getSystemName()); + vimInfo.setName(esrSystemInfo.getSystemName()); + vimInfo.setPassword(esrSystemInfo.getPassword()); + vimInfo.setStatus(esrSystemInfo.getSystemStatus()); + vimInfo.setType(esrSystemInfo.getType()); + vimInfo.setUrl(esrSystemInfo.getServiceUrl()); + vimInfo.setVersion(esrSystemInfo.getVersion()); + if (esrSystemInfo.getSslCacert() == null) { + vimInfo.setSslInsecure("true"); + } else { + vimInfo.setSslInsecure("false"); + vimInfo.setSslCacert(esrSystemInfo.getSslCacert()); + } + vimInfo.setUserName(esrSystemInfo.getUserName()); + vimInfo.setVendor(esrSystemInfo.getVendor()); + vimInfo.setVimId(vimId); + return vimInfo; + } + + + private VnfmInfo convertEsrToVnfmInfo(EsrVnfm vnfmInAai) { + EsrSystemInfo esrSystemInfo = vnfmInAai.getEsrSystemInfoList().getEsrSystemInfo().get(0); + VnfmInfo vnfmInfo = new VnfmInfo(); + vnfmInfo.setPassword(esrSystemInfo.getPassword()); + vnfmInfo.setDescription(esrSystemInfo.getEsrSystemInfoId()); + vnfmInfo.setName(esrSystemInfo.getSystemName()); + vnfmInfo.setType(esrSystemInfo.getType()); + vnfmInfo.setUrl(esrSystemInfo.getServiceUrl()); + vnfmInfo.setVersion(esrSystemInfo.getVersion()); + vnfmInfo.setVimId(vnfmInAai.getVimId()); + vnfmInfo.setVendor(esrSystemInfo.getVendor()); + vnfmInfo.setUserName(esrSystemInfo.getUserName()); + vnfmInfo.setVnfmId(vnfmInAai.getVnfmId()); + return vnfmInfo; + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/AAIRestApiProvider.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/AAIRestApiProvider.java new file mode 100644 index 00000000..141ba847 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/AAIRestApiProvider.java @@ -0,0 +1,183 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import com.google.common.annotations.VisibleForTesting; +import org.onap.aai.restclient.client.Headers; +import org.onap.aai.restclient.client.OperationResult; +import org.onap.aai.restclient.client.RestClient; +import org.onap.aai.restclient.enums.RestAuthenticationMode; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.MsbApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Conditional; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Component; + +import javax.xml.bind.JAXBContext; +import java.io.ByteArrayOutputStream; +import java.io.StringReader; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; + +import static com.google.common.collect.Lists.newArrayList; +import static javax.ws.rs.core.MediaType.APPLICATION_XML_TYPE; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager.SERVICE_NAME; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure; +import static org.slf4j.LoggerFactory.getLogger; + +/** + * Responsible for providing access to AAI APIs. + * Handles authentication and mandatory parameters. + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +public class AAIRestApiProvider { + private static final String AAI_VERSION = "v11"; + private static Logger logger = getLogger(AAIRestApiProvider.class); + private final MsbApiProvider msbApiProvider; + @Value("${aaiUsername}") + private String aaiUsername; + @Value("${aaiPassword}") + private String aaiPassword; + + @Autowired + AAIRestApiProvider(MsbApiProvider msbApiProvider) { + this.msbApiProvider = msbApiProvider; + } + + /** + * @param logger the logger of the class that requests unmarshalling + * @param service the AAI service of the request + * @param url the URL of the request after the base URL (ex. /cloud-infrastructure/...) + * @param clazz the class of the result + * @param <T> the type of the result + * @return the result of the GET request + */ + public <T> T get(Logger logger, AAIService service, String url, Class<T> clazz) { + return expectSuccess(logger, buildClient().get(getBaseUrl(service.getServiceName()) + url, buildCommonHeaders(), APPLICATION_XML_TYPE), clazz, url); + } + + /** + * @param logger the logger of the class that requests unmarshalling + * @param service the AAI service of the request + * @param url the URL of the request after the base URL (ex. /cloud-infrastructure/...) + * @param payload the payload of the request (non serialized) + * @param clazz the class of the result + * @param <T> the type of the result + * @return the result of the PUT request + */ + public <T, S> T put(Logger logger, AAIService service, String url, S payload, Class<T> clazz) { + String marshalledContent = marshall(payload); + OperationResult result = buildClient().put(getBaseUrl(service.getServiceName()) + url, marshalledContent, buildCommonHeaders(), APPLICATION_XML_TYPE, APPLICATION_XML_TYPE); + return expectSuccess(logger, result, clazz, url); + } + + /** + * Execute a delete request on the given URL + * + * @param logger the logger of the class that requests unmarshalling + * @param service the AAI service of the request + * @param url the URL of the request after the base URL (ex. /cloud-infrastructure/...) + */ + public void delete(Logger logger, AAIService service, String url) { + buildClient().delete(getBaseUrl(service.getServiceName()) + url, buildCommonHeaders(), APPLICATION_XML_TYPE); + } + + /** + * @param serviceName the name of the AAI service on MSB + * @return the base URL of the service + */ + private String getBaseUrl(String serviceName) { + return msbApiProvider.getMicroServiceUrl(serviceName, AAI_VERSION); + } + + private <T> T expectSuccess(Logger logger, OperationResult result, Class<T> clazz, String url) { + if (!result.wasSuccessful()) { + if (result.getResultCode() == 404) { + logger.debug("The resource at " + url + " does not exists"); + throw new NoSuchElementException("The resource at " + url + " does not exists"); + } + throw buildFatalFailure(logger, "Bad response. Code: " + result.getResultCode() + " cause: " + result.getFailureCause()); + } + if (clazz.isAssignableFrom(Void.class)) { + return null; + } + return unmarshal(result.getResult(), clazz); + } + + private <T> T unmarshal(String content, Class<T> clazz) { + try { + return (T) JAXBContext.newInstance(clazz).createUnmarshaller().unmarshal(new StringReader(content)); + } catch (Exception e) { + throw buildFatalFailure(logger, "Unable to unmarshal content", e); + } + } + + private String marshall(Object object) { + try { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + JAXBContext.newInstance(object.getClass()).createMarshaller().marshal(object, bos); + return bos.toString(); + } catch (Exception e) { + throw buildFatalFailure(logger, "Unable to marshal content", e); + } + } + + /** + * @return the common mandatory headers for AAI requests + */ + private Map<String, List<String>> buildCommonHeaders() { + Map<String, List<String>> headers = new HashMap<>(); + headers.put(Headers.ACCEPT, newArrayList(MediaType.APPLICATION_XML_VALUE)); + headers.put(Headers.FROM_APP_ID, newArrayList(SERVICE_NAME)); + return headers; + } + + + private RestClient buildClient() { + return buildRawClient().basicAuthUsername(aaiUsername).basicAuthPassword(aaiPassword).authenticationMode(RestAuthenticationMode.SSL_BASIC); + } + + @VisibleForTesting + RestClient buildRawClient() { + return new RestClient(); + } + + public enum AAIService { + NETWORK { + String getServiceName() { + return "aai-network"; + } + }, + ESR { + String getServiceName() { + return "aai-externalSystem"; + } + }, + CLOUD { + String getServiceName() { + return "aai-cloudInfrastructure"; + } + }; + + abstract String getServiceName(); + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/GrantlessGrantManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/GrantlessGrantManager.java new file mode 100644 index 00000000..a113405a --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/GrantlessGrantManager.java @@ -0,0 +1,65 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import com.nokia.cbam.lcm.v32.model.VnfInfo; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IGrantManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vnfmdriver.model.GrantVNFResponseVim; +import org.onap.vnfmdriver.model.VnfHealRequest; +import org.onap.vnfmdriver.model.VnfScaleRequest; +import org.slf4j.Logger; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import static org.slf4j.LoggerFactory.getLogger; + +/** + * Responsible for handling granting before the execution of a VNF operation in case of direct integration + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +public class GrantlessGrantManager implements IGrantManager { + private static Logger logger = getLogger(GrantlessGrantManager.class); + + @Override + public void requestGrantForHeal(String vnfmId, String vnfId, String vimId, String onapCsarId, VnfHealRequest request, String jobId) { + noGrantRequested(); + } + + @Override + public void requestGrantForScale(String vnfmId, String vnfId, String vimId, String onapCsarId, VnfScaleRequest request, String jobId) { + noGrantRequested(); + } + + @Override + public void requestGrantForTerminate(String vnfmId, String vnfId, String vimId, String onapVnfdId, VnfInfo vnf, String jobId) { + noGrantRequested(); + } + + @Override + public GrantVNFResponseVim requestGrantForInstantiate(String vnfmId, String vnfId, String vimId, String onapVnfdId, String instantiationLevelId, String cbamVnfdContent, String jobId) { + noGrantRequested(); + GrantVNFResponseVim grantResponse = new GrantVNFResponseVim(); + grantResponse.setVimId(vimId); + return grantResponse; + } + + private void noGrantRequested() { + logger.info("No grant is requested in direct mode"); + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/SdcPackageProvider.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/SdcPackageProvider.java new file mode 100644 index 00000000..8a165478 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/SdcPackageProvider.java @@ -0,0 +1,105 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import org.apache.http.HttpEntity; +import org.apache.http.client.methods.CloseableHttpResponse; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.impl.client.CloseableHttpClient; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IPackageProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.MsbApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; +import org.yaml.snakeyaml.Yaml; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; + +import static com.google.common.io.ByteStreams.toByteArray; +import static java.lang.String.format; +import static org.apache.http.HttpHeaders.ACCEPT; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager.SERVICE_NAME; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager.getFileInZip; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager.getVnfdLocation; +import static org.slf4j.LoggerFactory.getLogger; +import static org.springframework.http.MediaType.APPLICATION_OCTET_STREAM_VALUE; + +/** + * Responsible for providing access to AAI APIs. + * Handles authentication and mandatory parameters. + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +public class SdcPackageProvider implements IPackageProvider { + private static final String SDC_MSB_NAME = "sdc"; + private static final String SDC_MSB_VERSION = "v1"; + private static final String GET_PACKAGE_URL = "%s/sdc/v1/catalog/resources/%s/toscaModel"; + private static Logger logger = getLogger(SdcPackageProvider.class); + private final MsbApiProvider msbApiProvider; + private final DriverProperties driverProperties; + @Value("${sdcUsername}") + private String sdcUsername; + @Value("${sdcPassword}") + private String sdcPassword; + + @Autowired + SdcPackageProvider(MsbApiProvider msbApiProvider, DriverProperties driverProperties) { + this.msbApiProvider = msbApiProvider; + this.driverProperties = driverProperties; + } + + @Override + public byte[] getPackage(String csarId) { + String baseUrl = msbApiProvider.getMicroServiceUrl(SDC_MSB_NAME, SDC_MSB_VERSION); + try { + CloseableHttpClient client = systemFunctions().getHttpClient(); + HttpGet httpget = new HttpGet(format(GET_PACKAGE_URL, baseUrl, csarId)); + httpget.setHeader(ACCEPT, APPLICATION_OCTET_STREAM_VALUE); + httpget.setHeader("X-ECOMP-InstanceID", driverProperties.getVnfmId()); + httpget.setHeader("X-FromAppId", SERVICE_NAME); + CloseableHttpResponse response = client.execute(httpget); + HttpEntity entity = response.getEntity(); + InputStream is = entity.getContent(); + byte[] bytes = toByteArray(is); + client.close(); + return bytes; + } catch (Exception e) { + throw buildFatalFailure(logger, "Unable to download " + csarId + " package from SDC", e); + } + } + + @Override + public String getCbamVnfdId(String csarId) { + byte[] onapPackage = getPackage(csarId); + try { + String vnfdLocation = getVnfdLocation(new ByteArrayInputStream(onapPackage)); + String onapVnfdContent = getFileInZip(new ByteArrayInputStream(onapPackage), vnfdLocation).toString(); + JsonObject root = new Gson().toJsonTree(new Yaml().load(onapVnfdContent)).getAsJsonObject(); + return childElement(child(root, "metadata"), "resourceVendorModelNumber").getAsString(); + } catch (Exception e) { + throw buildFatalFailure(logger, "Unable to extract CBAM VNFD id from ONAP package", e); + } + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/AAINotificationProcessor.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/AAINotificationProcessor.java new file mode 100644 index 00000000..ff2bde8a --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/AAINotificationProcessor.java @@ -0,0 +1,146 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.nokia.cbam.lcm.v32.model.AffectedVirtualLink; +import com.nokia.cbam.lcm.v32.model.OperationExecution; +import com.nokia.cbam.lcm.v32.model.VnfLifecycleChangeNotification; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.INotificationSender; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; + +import static com.google.common.collect.Iterables.filter; +import static com.google.common.collect.Iterables.tryFind; +import static com.nokia.cbam.lcm.v32.model.ChangeType.*; +import static com.nokia.cbam.lcm.v32.model.OperationStatus.STARTED; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.LInterfaceManager.buildUrl; +import static org.slf4j.LoggerFactory.getLogger; +import static org.springframework.util.StringUtils.isEmpty; + +/** + * Responsible for providing information related to the VNFM from VF-C source + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +public class AAINotificationProcessor implements INotificationSender { + private static Logger logger = getLogger(AAINotificationProcessor.class); + private final GenericVnfManager genericVnfManager; + private final L3NetworkManager l3NetworkManager; + private final LInterfaceManager lInterfaceManager; + private final VnfcManager vnfcManager; + private final VserverManager vserverManager; + + @Autowired + AAINotificationProcessor(GenericVnfManager genericVnfManager, L3NetworkManager l3NetworkManager, LInterfaceManager lInterfaceManager, VnfcManager vnfcManager, VserverManager vserverManager) { + this.genericVnfManager = genericVnfManager; + this.l3NetworkManager = l3NetworkManager; + this.lInterfaceManager = lInterfaceManager; + this.vnfcManager = vnfcManager; + this.vserverManager = vserverManager; + } + + @Override + public void processNotification(VnfLifecycleChangeNotification receivedNotification, OperationExecution operationExecution, Optional<ReportedAffectedConnectionPoints> affectedConnectionPoints, String vimId) { + boolean inMaintenance = STARTED.equals(receivedNotification.getStatus()); + genericVnfManager.createOrUpdate(receivedNotification.getVnfInstanceId(), inMaintenance); + addOrUpdateVls(receivedNotification, vimId); + addOrUpdateVnfcs(receivedNotification, vimId, inMaintenance); + processCps(receivedNotification, affectedConnectionPoints, vimId, inMaintenance); + removeVnfcs(receivedNotification, vimId); + removeVls(receivedNotification); + logger.info("Notification processed successfully"); + } + + private void removeVls(VnfLifecycleChangeNotification receivedNotification) { + for (AffectedVirtualLink removedVl : filter(receivedNotification.getAffectedVirtualLinks(), affectedVirtualLink -> affectedVirtualLink.getChangeType().equals(REMOVED))) { + l3NetworkManager.delete(receivedNotification.getVnfInstanceId(), removedVl); + } + } + + private void removeVnfcs(VnfLifecycleChangeNotification receivedNotification, String vimId) { + for (com.nokia.cbam.lcm.v32.model.AffectedVnfc removedVnfc : filter(receivedNotification.getAffectedVnfcs(), vnfc -> REMOVED.equals(vnfc.getChangeType()))) { + vnfcManager.delete(receivedNotification.getVnfInstanceId(), removedVnfc); + vserverManager.delete(vimId, removedVnfc); + } + } + + private void processCps(VnfLifecycleChangeNotification receivedNotification, Optional<ReportedAffectedConnectionPoints> affectedConnectionPoints, String vimId, boolean inMaintenance) { + if (affectedConnectionPoints.isPresent()) { + for (ReportedAffectedCp removedCp : collectCpsToBeDeleted(vimId, affectedConnectionPoints.get())) { + lInterfaceManager.delete(vimId, removedCp); + } + //these can only be added or modified because if something is in the post CPS it can not be removed + //since it is present after the operation + for (ReportedAffectedCp affectedCp : affectedConnectionPoints.get().getPost()) { + if (!isEmpty(affectedCp.getServerProviderId())) { + lInterfaceManager.update(receivedNotification.getVnfInstanceId(), vimId, affectedCp, inMaintenance); + } + else{ + logger.warn("The changed {} connection point is not linked to any server", affectedCp.getCpId()); + } + } + } + else{ + logger.warn("The changed connection points are not present in VNF with {} identifier", receivedNotification.getVnfInstanceId()); + } + } + + private void addOrUpdateVnfcs(VnfLifecycleChangeNotification receivedNotification, String vimId, boolean inMaintenance) { + for (com.nokia.cbam.lcm.v32.model.AffectedVnfc affectedVnfc : receivedNotification.getAffectedVnfcs()) { + if (affectedVnfc.getChangeType() == MODIFIED || affectedVnfc.getChangeType() == ADDED) { + vserverManager.update(vimId, receivedNotification.getVnfInstanceId(), affectedVnfc, receivedNotification.getAffectedVirtualStorages(), inMaintenance); + vnfcManager.update(vimId, VserverManager.getTenantId(affectedVnfc), receivedNotification.getVnfInstanceId(), affectedVnfc, inMaintenance); + } + } + } + + private void addOrUpdateVls(VnfLifecycleChangeNotification receivedNotification, String vimId) { + for (AffectedVirtualLink affectedVirtualLink : receivedNotification.getAffectedVirtualLinks()) { + if ((affectedVirtualLink.getChangeType() == MODIFIED) || (affectedVirtualLink.getChangeType() == ADDED)) { + l3NetworkManager.update(vimId, receivedNotification.getVnfInstanceId(), affectedVirtualLink); + } + } + } + + /** + * The ports that are present in the pre, but not present in the post are + * removed regardless of the "removed" flag being present in the pre, because + * that only signals the remove intention, but does not actually mean that + * the resource have been removed + */ + private Collection<ReportedAffectedCp> collectCpsToBeDeleted(String vimId, ReportedAffectedConnectionPoints cps) { + Set<ReportedAffectedCp> cpsToRemove = new HashSet<>(); + for (ReportedAffectedCp cpBeforeOperation : cps.getPre()) { + if (!isEmpty(cpBeforeOperation.getServerProviderId())) { + String originalResource = buildUrl(vimId, cpBeforeOperation); + if (!tryFind(cps.getPost(), cpAfterOperation -> originalResource.equals(buildUrl(vimId, cpAfterOperation))).isPresent()) { + cpsToRemove.add(cpBeforeOperation); + } + } + } + return cpsToRemove; + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/AbstractManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/AbstractManager.java new file mode 100644 index 00000000..c8008f38 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/AbstractManager.java @@ -0,0 +1,143 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.gson.Gson; +import org.onap.aai.domain.yang.v11.ObjectFactory; +import org.onap.aai.domain.yang.v11.Relationship; +import org.onap.aai.domain.yang.v11.RelationshipData; +import org.onap.aai.domain.yang.v11.RelationshipList; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.slf4j.Logger; + +import java.util.HashSet; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Set; + +import static com.google.common.collect.Iterables.find; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.SEPARATOR; + +/** + * Handles the common management of changing entities in AAI + */ +abstract class AbstractManager { + protected static final ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + protected final AAIRestApiProvider aaiRestApiProvider; + protected final CbamRestApiProvider cbamRestApiProvider; + protected final DriverProperties driverProperties; + + AbstractManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + this.aaiRestApiProvider = aaiRestApiProvider; + this.cbamRestApiProvider = cbamRestApiProvider; + this.driverProperties = driverProperties; + } + + /** + * @param key the key of the relationship + * @param value the value of the relationship + * @return the relationship + */ + protected static RelationshipData buildRelationshipData(String key, String value) { + RelationshipData data = new RelationshipData(); + data.setRelationshipKey(key); + data.setRelationshipValue(value); + return data; + } + + /** + * Extract mandatory value from the additional data on LCN resources + * + * @param additionalData the additional data + * @param key the key of the additional data + * @return the value of the additional data + */ + protected static String extractMandatoryValue(Object additionalData, String key) { + return new Gson().toJsonTree(additionalData).getAsJsonObject().get(key).getAsString(); + } + + /** + * Create or update the singleton relationship. Singleton means that relationships can only have a + * single {@link Relationship} with the given {@link Relationship#getRelatedTo} value + * + * @param relationships the list of relationships + * @param relationship the expected relationship + */ + protected static void addSingletonRelation(RelationshipList relationships, Relationship relationship) { + boolean found = false; + for (Relationship currentRelationShip : relationships.getRelationship()) { + if (relationship.getRelatedTo().equals(currentRelationShip.getRelatedTo())) { + found = true; + } + } + if (!found) { + relationships.getRelationship().add(relationship); + } else { + Relationship existingRelationShip = find(relationships.getRelationship(), currentRelationShip -> currentRelationShip.getRelatedTo().equals(relationship.getRelatedTo())); + existingRelationShip.getRelationshipData().clear(); + existingRelationShip.getRelationshipData().addAll(relationship.getRelationshipData()); + } + } + + /** + * Add the given relationship if it is already not part of the relationships + * + * @param relationships the relationships + * @param relationship the relationship to be added + */ + protected static void addMissingRelation(RelationshipList relationships, Relationship relationship) { + for (Relationship currentRelationShip : relationships.getRelationship()) { + if (currentRelationShip.getRelatedTo().equals(relationship.getRelatedTo()) + && compositeKeys(currentRelationShip.getRelationshipData()).equals(compositeKeys(relationship.getRelationshipData()))) { + return; + } + } + relationships.getRelationship().add(relationship); + } + + private static Set<String> compositeKeys(List<RelationshipData> data) { + Set<String> keys = new HashSet<>(); + for (RelationshipData relationshipData : data) { + keys.add(relationshipData.getRelationshipKey() + SEPARATOR + relationshipData.getRelationshipValue()); + } + return keys; + } + + /** + * @return the concrete logger to be used + */ + protected abstract Logger getLogger(); + + /** + * Creates or returns a REST resource instance + * + * @param service the type of the service + * @param url the URL of the resource without the service prefix + * @param newInstance the empty instance if the resource does not exists + * @param <T> the type of the resource + * @return the created or queried resource + */ + protected <T> T createOrGet(AAIRestApiProvider.AAIService service, String url, T newInstance) { + try { + return (T) aaiRestApiProvider.get(getLogger(), service, url, newInstance.getClass()); + } catch (NoSuchElementException e) { + getLogger().debug("The resource on " + url + " URL was not found in AAI", e); + return newInstance; + } + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/GenericVnfManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/GenericVnfManager.java new file mode 100644 index 00000000..959177c1 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/GenericVnfManager.java @@ -0,0 +1,114 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.nokia.cbam.lcm.v32.ApiException; +import com.nokia.cbam.lcm.v32.model.VnfInfo; +import org.onap.aai.domain.yang.v11.GenericVnf; +import org.onap.aai.domain.yang.v11.Relationship; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import java.util.NoSuchElementException; + +import static java.lang.String.format; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.NETWORK; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions; + +/** + * Responsible for managing the {@link GenericVnf} in AAI + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +class GenericVnfManager extends AbstractManager { + private static final String VNF_URL = "/generic-vnfs/generic-vnf/%s"; + private static final long MAX_MS_TO_WAIT_FOR_VNF_TO_APPEAR = 30 * 1000L; + private static Logger logger = org.slf4j.LoggerFactory.getLogger(GenericVnfManager.class); + + @Autowired + GenericVnfManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + super(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + static Relationship linkTo(String vnfId) { + Relationship relationship = new Relationship(); + relationship.setRelatedTo("generic-vnf"); + relationship.getRelationshipData().add(buildRelationshipData("generic-vnf.vnf-id", vnfId)); + return relationship; + } + + @Override + protected Logger getLogger() { + return logger; + } + + void createOrUpdate(String vnfId, boolean inMaintenance) { + try { + GenericVnf vnf = waitForVnfToAppearInAai(vnfId); + updateFields(vnf, vnfId, inMaintenance); + } catch (NoSuchElementException e) { + try { + logger.warn("The VNF with " + vnfId + " identifier did not appear in time", e); + updateFields(OBJECT_FACTORY.createGenericVnf(), vnfId, inMaintenance); + } catch (Exception e2) { + logger.warn("The VNF with " + vnfId + " identifier has been created since after the maximal wait for VNF to appear timeout", e2); + //the VNF might have been created since the last poll + updateFields(getExistingVnf(vnfId), vnfId, inMaintenance); + } + } + } + + GenericVnf getExistingVnf(String vnfId) { + return aaiRestApiProvider.get(logger, NETWORK, format(VNF_URL, vnfId), GenericVnf.class); + } + + private void updateFields(GenericVnf vnf, String vnfId, boolean inMaintenance) { + try { + VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(driverProperties.getVnfmId()).vnfsVnfInstanceIdGet(vnfId, CbamRestApiProvider.NOKIA_LCM_API_VERSION); + vnf.setVnfName(vnfInfo.getName()); + } catch (ApiException e) { + throw buildFatalFailure(logger, "Unable to query VNF with " + vnfId + " identifier from CBAM", e); + } + vnf.setVnfId(vnfId); + vnf.setInMaint(inMaintenance); + vnf.setVnfInstanceId(vnfId); + //FIXME whould be good to know if this parameter is relevant or not? (mandatory) + vnf.setVnfType("NokiaVNF"); + vnf.setIsClosedLoopDisabled(inMaintenance); + aaiRestApiProvider.put(logger, NETWORK, format(VNF_URL, vnf.getVnfId()), vnf, Void.class); + } + + private GenericVnf waitForVnfToAppearInAai(String vnfId) { + long timeoutInMs = systemFunctions().currentTimeMillis() + MAX_MS_TO_WAIT_FOR_VNF_TO_APPEAR; + while (timeoutInMs - systemFunctions().currentTimeMillis() > 0) { + try { + return aaiRestApiProvider.get(logger, NETWORK, format(VNF_URL, vnfId), GenericVnf.class); + } catch (NoSuchElementException e) { + logger.debug("Unable to get VNF with " + vnfId + " identifier", e); + } + systemFunctions().sleep(3 * 1000L); + } + throw new NoSuchElementException(); + } + +}
\ No newline at end of file diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/L3NetworkManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/L3NetworkManager.java new file mode 100644 index 00000000..6d2b42bc --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/L3NetworkManager.java @@ -0,0 +1,104 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.nokia.cbam.lcm.v32.model.AffectedVirtualLink; +import org.onap.aai.domain.yang.v11.L3Network; +import org.onap.aai.domain.yang.v11.Relationship; +import org.onap.aai.domain.yang.v11.RelationshipList; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import static java.lang.String.format; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.NETWORK; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.SEPARATOR; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; + +/** + * Responsible for managing the {@link L3Network} in AAI + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +class L3NetworkManager extends AbstractManager { + private static final String NETWORK_URL = "/l3-networks/l3-network/%s"; + private static Logger logger = org.slf4j.LoggerFactory.getLogger(L3NetworkManager.class); + + @Autowired + L3NetworkManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + super(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + @Override + protected Logger getLogger() { + return logger; + } + + void update(String vimId, String vnfId, AffectedVirtualLink affectedVirtualLink) { + L3Network l3Network = createOrGet(NETWORK, format(NETWORK_URL, buildNetworkId(vnfId, affectedVirtualLink)), OBJECT_FACTORY.createL3Network()); + updateNetworkFields(vimId, vnfId, affectedVirtualLink, l3Network); + } + + void delete(String vnfId, AffectedVirtualLink removedVl) { + aaiRestApiProvider.delete(logger, NETWORK, format(NETWORK_URL, buildNetworkId(vnfId, removedVl))); + } + + private void updateNetworkFields(String vimId, String vnfId, AffectedVirtualLink affectedVirtualLink, L3Network network) { + network.setNetworkId(buildNetworkId(vnfId, affectedVirtualLink)); + network.setNetworkName(extractMandatoryValue(affectedVirtualLink.getResource().getAdditionalData(), "name")); + network.setNeutronNetworkId(affectedVirtualLink.getResource().getResourceId()); + network.setIsBoundToVpn(false); + network.setIsExternalNetwork(false); + network.setIsProviderNetwork(false); + network.setIsSharedNetwork(false); + network.setOperationalStatus("active"); + network.setOrchestrationStatus("active"); + if (network.getRelationshipList() == null) { + network.setRelationshipList(new RelationshipList()); + } + addMissingRelation(network.getRelationshipList(), GenericVnfManager.linkTo(vnfId)); + addSingletonRelation(network.getRelationshipList(), getRegionLink(vimId)); + addSingletonRelation(network.getRelationshipList(), getTenantLink(vimId, extractMandatoryValue(affectedVirtualLink.getResource().getAdditionalData(), "tenantId"))); + aaiRestApiProvider.put(logger, NETWORK, format(NETWORK_URL, network.getNetworkId()), network, Void.class); + } + + private String buildNetworkId(String vnfId, AffectedVirtualLink affectedVirtualLink) { + return vnfId + SEPARATOR + affectedVirtualLink.getId(); + } + + private Relationship getRegionLink(String vimId) { + Relationship relationship = new Relationship(); + relationship.setRelatedTo("cloud-region"); + relationship.getRelationshipData().add(buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(vimId))); + relationship.getRelationshipData().add(buildRelationshipData("cloud-region.cloud-region-id", getRegionName(vimId))); + return relationship; + } + + private Relationship getTenantLink(String vimId, String tenantId) { + Relationship relationship = new Relationship(); + relationship.setRelatedTo("tenant"); + relationship.getRelationshipData().add(buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(vimId))); + relationship.getRelationshipData().add(buildRelationshipData("cloud-region.cloud-region-id", getRegionName(vimId))); + relationship.getRelationshipData().add(buildRelationshipData("tenant.tenant-id", tenantId)); + return relationship; + } +}
\ No newline at end of file diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/LInterfaceManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/LInterfaceManager.java new file mode 100644 index 00000000..229fe679 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/LInterfaceManager.java @@ -0,0 +1,101 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import org.onap.aai.domain.yang.v11.L3InterfaceIpv4AddressList; +import org.onap.aai.domain.yang.v11.L3InterfaceIpv6AddressList; +import org.onap.aai.domain.yang.v11.LInterface; +import org.onap.aai.domain.yang.v11.RelationshipList; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import static java.lang.String.format; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.CLOUD; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; + +/** + * Responsible for managing the {@link LInterface} in AAI + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +class LInterfaceManager extends AbstractManager { + private static Logger logger = org.slf4j.LoggerFactory.getLogger(LInterfaceManager.class); + + @Autowired + LInterfaceManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + super(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + static String buildUrl(String vimId, ReportedAffectedCp affectedCp) { + String cloudOwner = getCloudOwner(vimId); + String regionName = getRegionName(vimId); + String tenantId = affectedCp.getTenantId(); + String vServerId = affectedCp.getServerProviderId(); + String cpId = affectedCp.getCpId(); + return format("/cloud-regions/cloud-region/%s/%s/tenants/tenant/%s/vservers/vserver/%s/l-interfaces/l-interface/%s", cloudOwner, regionName, tenantId, vServerId, cpId); + } + + @Override + protected Logger getLogger() { + return logger; + } + + void update(String vnfId, String vimId, ReportedAffectedCp affectedCp, boolean inMaintenance) { + LInterface lInterface = createOrGet(CLOUD, buildUrl(vimId, affectedCp), OBJECT_FACTORY.createLInterface()); + updateFields(lInterface, affectedCp, vnfId, buildUrl(vimId, affectedCp), inMaintenance); + } + + void delete(String vimId, ReportedAffectedCp removedCp) { + aaiRestApiProvider.delete(logger, AAIRestApiProvider.AAIService.CLOUD, buildUrl(vimId, removedCp)); + } + + private void updateFields(LInterface logicalInterface, ReportedAffectedCp affectedCp, String vnfId, String url, boolean inMaintenance) { + logicalInterface.setInMaint(inMaintenance); + logicalInterface.setIsIpUnnumbered(false); + logicalInterface.setIsPortMirrored(false); + logicalInterface.setInterfaceName(affectedCp.getName()); + logicalInterface.setInterfaceId(affectedCp.getCpId()); + logicalInterface.setInterfaceRole(affectedCp.getCpdId()); + logicalInterface.setMacaddr(affectedCp.getMacAddress()); + logicalInterface.setProvStatus("active"); + if (affectedCp.getIpAddress() != null) { + if (affectedCp.getIpAddress().contains(":")) { + L3InterfaceIpv6AddressList ipv6Address = OBJECT_FACTORY.createL3InterfaceIpv6AddressList(); + ipv6Address.setL3InterfaceIpv6Address(affectedCp.getIpAddress()); + ipv6Address.setNeutronNetworkId(affectedCp.getNetworkProviderId()); + logicalInterface.getL3InterfaceIpv6AddressList().add(ipv6Address); + } else { + L3InterfaceIpv4AddressList ipv4Address = OBJECT_FACTORY.createL3InterfaceIpv4AddressList(); + ipv4Address.setL3InterfaceIpv4Address(affectedCp.getIpAddress()); + ipv4Address.setNeutronNetworkId(affectedCp.getNetworkProviderId()); + logicalInterface.getL3InterfaceIpv4AddressList().add(ipv4Address); + } + } + if (logicalInterface.getRelationshipList() == null) { + logicalInterface.setRelationshipList(new RelationshipList()); + } + addSingletonRelation(logicalInterface.getRelationshipList(), GenericVnfManager.linkTo(vnfId)); + aaiRestApiProvider.put(logger, CLOUD, url, logicalInterface, Void.class); + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/VnfcManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/VnfcManager.java new file mode 100644 index 00000000..976e283d --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/VnfcManager.java @@ -0,0 +1,90 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.common.base.Splitter; +import com.nokia.cbam.lcm.v32.model.AffectedVnfc; +import org.onap.aai.domain.yang.v11.RelationshipList; +import org.onap.aai.domain.yang.v11.Vnfc; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import static java.lang.String.format; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.NETWORK; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.SEPARATOR; + +/** + * Responsible for managing {@link Vnfc} in AAI + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +public class VnfcManager extends AbstractManager { + private static Logger logger = org.slf4j.LoggerFactory.getLogger(VnfcManager.class); + + @Autowired + VnfcManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + super(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + public static String buildUrl(String vnfId, String cbamVnfcId) { + return format("/vnfcs/vnfc/%s", buildId(vnfId, cbamVnfcId)); + } + + public static String getCbamVnfcId(String vnfcId){ + String vnfId = Splitter.on(CbamUtils.SEPARATOR).split(vnfcId).iterator().next(); + return vnfcId.replaceFirst(vnfId + SEPARATOR, ""); + } + + private static String buildId(String vnfId, String cbamVnfcId) { + return vnfId + SEPARATOR + cbamVnfcId; + } + + @Override + protected Logger getLogger() { + return logger; + } + + void delete(String vnfId, com.nokia.cbam.lcm.v32.model.AffectedVnfc cbamVnfc) { + aaiRestApiProvider.delete(logger, NETWORK, buildUrl(vnfId, cbamVnfc.getId())); + } + + void update(String vimId, String tenantId, String vnfId, com.nokia.cbam.lcm.v32.model.AffectedVnfc cbamVnfc, boolean inMaintenance) { + String url = buildUrl(vnfId, cbamVnfc.getId()); + Vnfc vnfc = createOrGet(NETWORK, url, OBJECT_FACTORY.createVnfc()); + updateFields(vimId, tenantId, vnfc, cbamVnfc, vnfId, url, inMaintenance); + } + + private void updateFields(String vimId, String tenantId, Vnfc aaiVnfc, com.nokia.cbam.lcm.v32.model.AffectedVnfc cbamVnfc, String vnfId, String url, boolean inMaintenance) { + aaiVnfc.setInMaint(inMaintenance); + aaiVnfc.setIsClosedLoopDisabled(inMaintenance); + //FIXME would be good to know what is this mandatory parameter + aaiVnfc.setNfcFunction(cbamVnfc.getId()); + //FIXME would be good to know what is this mandatory parameter + aaiVnfc.setNfcNamingCode(cbamVnfc.getId()); + aaiVnfc.setVnfcName(buildId(vnfId, cbamVnfc.getId())); + aaiVnfc.setRelationshipList(new RelationshipList()); + addSingletonRelation(aaiVnfc.getRelationshipList(), VserverManager.linkTo(vimId, tenantId, cbamVnfc.getComputeResource().getResourceId())); + addSingletonRelation(aaiVnfc.getRelationshipList(), GenericVnfManager.linkTo(vnfId)); + aaiRestApiProvider.put(logger, NETWORK, url, aaiVnfc, Void.class); + } +}
\ No newline at end of file diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/VserverManager.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/VserverManager.java new file mode 100644 index 00000000..cec779a4 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/VserverManager.java @@ -0,0 +1,132 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.nokia.cbam.lcm.v32.model.AffectedVirtualStorage; +import com.nokia.cbam.lcm.v32.model.AffectedVnfc; +import org.onap.aai.domain.yang.v11.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Conditional; +import org.springframework.stereotype.Component; + +import java.util.List; + +import static com.google.common.collect.Iterables.find; +import static java.lang.String.format; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.CLOUD; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.childElement; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; + +/** + * Responsible for managing {@link Vserver} in AAI + */ +@Component +@Conditional(value = Conditions.UseForDirect.class) +class VserverManager extends AbstractManager { + private static Logger logger = org.slf4j.LoggerFactory.getLogger(VserverManager.class); + + @Autowired + VserverManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + super(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + static Relationship linkTo(String vimId, String tenantId, String serverProviderId) { + Relationship relationship = new Relationship(); + relationship.setRelatedTo("vserver"); + relationship.getRelationshipData().add(buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(vimId))); + relationship.getRelationshipData().add(buildRelationshipData("cloud-region.cloud-region-id", getRegionName(vimId))); + relationship.getRelationshipData().add(buildRelationshipData("tenant.tenant-id", tenantId)); + relationship.getRelationshipData().add(buildRelationshipData("vserver.vserver-id", serverProviderId)); + return relationship; + } + + static String getTenantId(AffectedVnfc cbamVnfc) { + return extractMandatoryValue(cbamVnfc.getComputeResource().getAdditionalData(), "tenantId"); + } + + @Override + protected Logger getLogger() { + return logger; + } + + void update(String vimId, String vnfId, AffectedVnfc cbamVnfc, List<AffectedVirtualStorage> affectedVirtualStorages, boolean inMaintenance) { + String url = buildUrl(vimId, cbamVnfc); + Vserver vserver = createOrGet(CLOUD, url, OBJECT_FACTORY.createVserver()); + updateFields(vserver, cbamVnfc, vnfId, affectedVirtualStorages, url, inMaintenance); + } + + void delete(String vimId, com.nokia.cbam.lcm.v32.model.AffectedVnfc deletedVnfc) { + aaiRestApiProvider.delete(logger, CLOUD, buildUrl(vimId, deletedVnfc)); + } + + private String buildUrl(String vimId, AffectedVnfc cbamVnfc) { + String tenantId = getTenantId(cbamVnfc); + String cloudOwner = getCloudOwner(vimId); + String regionName = getRegionName(vimId); + return format("/cloud-regions/cloud-region/%s/%s/tenants/tenant/%s/vservers/vserver/%s", cloudOwner, regionName, tenantId, cbamVnfc.getComputeResource().getResourceId()); + } + + private void updateFields(Vserver server, AffectedVnfc cbamVnfc, String vnfId, List<AffectedVirtualStorage> affectedVirtualStorages, String url, boolean inMaintenance) { + server.setInMaint(inMaintenance); + server.setIsClosedLoopDisabled(inMaintenance); + JsonElement additionalData = new Gson().toJsonTree(cbamVnfc.getComputeResource().getAdditionalData()); + server.setVserverName(additionalData.getAsJsonObject().get("name").getAsString()); + server.setVserverId(cbamVnfc.getComputeResource().getResourceId()); + server.setProvStatus("active"); + server.setRelationshipList(new RelationshipList()); + server.setVserverId(cbamVnfc.getComputeResource().getResourceId()); + server.setVserverSelflink(extractSelfLink(cbamVnfc.getComputeResource().getAdditionalData())); + addSingletonRelation(server.getRelationshipList(), GenericVnfManager.linkTo(vnfId)); + if (server.getVolumes() == null) { + server.setVolumes(new Volumes()); + } + if (cbamVnfc.getStorageResourceIds() != null) { + for (String virtualStorageId : cbamVnfc.getStorageResourceIds()) { + Volume volume = new Volume(); + AffectedVirtualStorage affectedStorage = find(affectedVirtualStorages, storage -> virtualStorageId.equals(storage.getId())); + volume.setVolumeId(affectedStorage.getResource().getResourceId()); + server.getVolumes().getVolume().add(volume); + } + } else { + server.setVolumes(OBJECT_FACTORY.createVolumes()); + } + aaiRestApiProvider.put(logger, CLOUD, url, server, Void.class); + } + + private String extractSelfLink(Object additionalData) { + try { + JsonObject root = new Gson().toJsonTree(additionalData).getAsJsonObject(); + for (JsonElement link : childElement(root, "links").getAsJsonArray()) { + if (link.getAsJsonObject().has("rel") && "self".equals(link.getAsJsonObject().get("rel").getAsString())) { + return link.getAsJsonObject().get("href").getAsString(); + } + } + return "unknown"; + } catch (Exception e) { + logger.debug("Missing links in the server", e); + return "unknown"; + } + } +} diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/package-info.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/package-info.java new file mode 100644 index 00000000..7b1cca56 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/package-info.java @@ -0,0 +1,20 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Handles notification processing in case of direct SO integration + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; diff --git a/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/package-info.java b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/package-info.java new file mode 100644 index 00000000..39fc82d5 --- /dev/null +++ b/nokiav2/driver/src/main/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/package-info.java @@ -0,0 +1,20 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Handles information exchange with ONAP components directly instead of routing request through VF-C + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/ct/CTDirectReal.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/ct/CTDirectReal.java new file mode 100644 index 00000000..a428ee90 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/ct/CTDirectReal.java @@ -0,0 +1,100 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.ct; + +import com.google.gson.JsonObject; +import com.nokia.cbam.lcm.v32.model.*; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.NokiaSvnfmApplication; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIExternalSystemInfoProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.AAINotificationProcessor; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp; +import org.onap.vnfmdriver.model.VimInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.ArrayList; + +import static java.util.Optional.of; + +@RunWith(value = SpringRunner.class) +@SpringBootTest(classes = NokiaSvnfmApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) +@ActiveProfiles("direct") +public class CTDirectReal { + @Autowired + private AAIExternalSystemInfoProvider externalSystemInfoProvider; + @Autowired + private AAINotificationProcessor notificationProcessor; + + /** + * The following is not a real test, but only start the driver locally. + * It takes parameters from application-real.properties + */ + @Test + public void testBasicWorkflow() throws Exception { + VimInfo nokia_regionOne = externalSystemInfoProvider.getVimInfo("Nokia_RegionOne"); + + VnfLifecycleChangeNotification recievedNot = new VnfLifecycleChangeNotification(); + recievedNot.setVnfInstanceId("CBAM-d8deb02a7a51449dba576ac9eabb55b8"); + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + recievedNot.setAffectedVirtualLinks(new ArrayList<>()); + AffectedVirtualLink link = new AffectedVirtualLink(); + recievedNot.getAffectedVirtualLinks().add(link); + link.setId("vlid1"); + link.setChangeType(ChangeType.REMOVED); + link.setVirtualLinkDescId("vldId1"); + link.setResource(new ResourceHandle()); + link.getResource().setResourceId("netProviderId1"); + link.getResource().setAdditionalData(additionalData("name", "networkName")); + recievedNot.setAffectedVnfcs(new ArrayList<>()); + AffectedVnfc vnfc = new AffectedVnfc(); + vnfc.setId("myVnfcId1"); + vnfc.setChangeType(ChangeType.ADDED); + vnfc.setVduId("myVduId"); + vnfc.setStorageResourceIds(new ArrayList<>()); + vnfc.setComputeResource(new ResourceHandle()); + vnfc.getComputeResource().setResourceId("serverProvId1"); + JsonObject additionalData = additionalData("name", "serverName"); + additionalData.addProperty("tenantId", "de8fd0d1d5874503a47b920c10f4322a"); + vnfc.getComputeResource().setAdditionalData(additionalData); + recievedNot.getAffectedVnfcs().add(vnfc); + ReportedAffectedCp addedCp = new ReportedAffectedCp(); + addedCp.setCpId("cpId"); + addedCp.setIpAddress("1.2.3.4"); + addedCp.setMacAddress("a:b:c:d:e:f"); + addedCp.setNetworkProviderId("netProviderId1"); + addedCp.setServerProviderId("serverProvId1"); + addedCp.setProviderId("portId"); + addedCp.setTenantId("de8fd0d1d5874503a47b920c10f4322a"); + addedCp.setCpdId("cpdId"); + affectedConnectionPoints.getPost().add(addedCp); + notificationProcessor.processNotification(recievedNot, null, of(affectedConnectionPoints), "Nokia_RegionOne"); + Thread.sleep(10000000 * 1000L); + } + + JsonObject additionalData(String key, String value) { + JsonObject jsonObject = new JsonObject(); + jsonObject.addProperty(key, value); + return jsonObject; + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestAAIExternalSystemInfoProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestAAIExternalSystemInfoProvider.java new file mode 100644 index 00000000..c1da617e --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestAAIExternalSystemInfoProvider.java @@ -0,0 +1,189 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.onap.aai.domain.yang.v11.EsrSystemInfo; +import org.onap.aai.domain.yang.v11.EsrSystemInfoList; +import org.onap.aai.domain.yang.v11.EsrVnfm; +import org.onap.aai.domain.yang.v11.ObjectFactory; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.model.VimInfo; +import org.onap.vnfmdriver.model.VnfmInfo; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestAAIExternalSystemInfoProvider extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + private AAIExternalSystemInfoProvider aaiExternalSystemInfoProvider; + @Mock + private AAIRestApiProvider aaiRestApiProvider; + + @Before + public void init() { + aaiExternalSystemInfoProvider = new AAIExternalSystemInfoProvider(environment, aaiRestApiProvider); + setField(AAIExternalSystemInfoProvider.class, "logger", logger); + } + + /** + * test query VIM success scenario + */ + @Test + public void testVim() throws Exception { + EsrSystemInfoList vims = OBJECT_FACTORY.createEsrSystemInfoList(); + EsrSystemInfo vim = OBJECT_FACTORY.createEsrSystemInfo(); + vims.getEsrSystemInfo().add(vim); + vim.setPassword("myPassword"); + vim.setUserName("myUsername"); + vim.setServiceUrl("http://1.2.3.4:1234/a"); + vim.setVersion("v123"); + vim.setSystemStatus("active"); + vim.setSystemName("name"); + vim.setType("type"); + vim.setSslInsecure(true); + vim.setVendor("vendor"); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/esr-system-info-list", EsrSystemInfoList.class)).thenReturn(vims); + //when + VimInfo vimInfo = aaiExternalSystemInfoProvider.getVimInfo(VIM_ID); + assertEquals("myPassword", vimInfo.getPassword()); + assertEquals("true", vimInfo.getSslInsecure()); + assertEquals(null, vimInfo.getSslCacert()); + assertEquals("myUsername", vimInfo.getUserName()); + assertEquals("name", vimInfo.getDescription()); + assertEquals("name", vimInfo.getName()); + assertEquals("http://1.2.3.4:1234/a", vimInfo.getUrl()); + assertEquals("active", vimInfo.getStatus()); + assertEquals("type", vimInfo.getType()); + assertEquals("v123", vimInfo.getVersion()); + assertEquals(VIM_ID, vimInfo.getVimId()); + assertEquals(null, vimInfo.getCreateTime()); + + } + + /** + * test query VIM success scenario for SSL + */ + @Test + public void testVimSsl() throws Exception { + EsrSystemInfoList vims = OBJECT_FACTORY.createEsrSystemInfoList(); + EsrSystemInfo vim = OBJECT_FACTORY.createEsrSystemInfo(); + vims.getEsrSystemInfo().add(vim); + vim.setPassword("myPassword"); + vim.setUserName("myUsername"); + vim.setServiceUrl("https://1.2.3.4:1234/a"); + vim.setVersion("v123"); + vim.setSystemStatus("active"); + vim.setSystemName("name"); + vim.setType("type"); + vim.setSslInsecure(false); + vim.setSslCacert("cert"); + vim.setVendor("vendor"); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/esr-system-info-list", EsrSystemInfoList.class)).thenReturn(vims); + //when + VimInfo vimInfo = aaiExternalSystemInfoProvider.getVimInfo(VIM_ID); + assertEquals("myPassword", vimInfo.getPassword()); + assertEquals("false", vimInfo.getSslInsecure()); + assertEquals("cert", vimInfo.getSslCacert()); + assertEquals("myUsername", vimInfo.getUserName()); + assertEquals("name", vimInfo.getDescription()); + assertEquals("name", vimInfo.getName()); + assertEquals("https://1.2.3.4:1234/a", vimInfo.getUrl()); + assertEquals("active", vimInfo.getStatus()); + assertEquals("type", vimInfo.getType()); + assertEquals("v123", vimInfo.getVersion()); + assertEquals(VIM_ID, vimInfo.getVimId()); + assertEquals(null, vimInfo.getCreateTime()); + } + + /** + * unable to query VIM from AAI results in error + */ + @Test + public void testVimUnableToQuery() throws Exception { + RuntimeException expectedException = new RuntimeException(); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/esr-system-info-list", EsrSystemInfoList.class)).thenThrow(expectedException); + //when + try { + aaiExternalSystemInfoProvider.getVimInfo(VIM_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to query VIM with myCloudOwnerId_myRegionName identifier from AAI", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * test VNFM query success scenario + */ + @Test + public void testVnfmQuery() throws Exception { + EsrVnfm vnfm = OBJECT_FACTORY.createEsrVnfm(); + vnfm.setVimId(VIM_ID); + vnfm.setEsrSystemInfoList(OBJECT_FACTORY.createEsrSystemInfoList()); + EsrSystemInfo esrInfo = OBJECT_FACTORY.createEsrSystemInfo(); + vnfm.getEsrSystemInfoList().getEsrSystemInfo().add(esrInfo); + esrInfo.setPassword("myPassword"); + esrInfo.setUserName("myUsername"); + esrInfo.setServiceUrl("https://1.2.3.4:1234/a"); + esrInfo.setVersion("v123"); + esrInfo.setSystemStatus("active"); + esrInfo.setSystemName("name"); + esrInfo.setType("type"); + esrInfo.setSslInsecure(false); + esrInfo.setSslCacert("cert"); + esrInfo.setVendor("vendor"); + vnfm.setVnfmId(VNFM_ID); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.ESR, "/esr-vnfm-list/esr-vnfm/" + VNFM_ID + "?depth=all", EsrVnfm.class)).thenReturn(vnfm); + + //when + VnfmInfo actualVnfmInfo = aaiExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID); + //verify + assertEquals("myPassword", actualVnfmInfo.getPassword()); + assertEquals("https://1.2.3.4:1234/a", actualVnfmInfo.getUrl()); + assertEquals("myUsername", actualVnfmInfo.getUserName()); + assertEquals(null, actualVnfmInfo.getCreateTime()); + assertEquals(null, actualVnfmInfo.getDescription()); + assertEquals("name", actualVnfmInfo.getName()); + assertEquals("type", actualVnfmInfo.getType()); + assertEquals("vendor", actualVnfmInfo.getVendor()); + assertEquals("v123", actualVnfmInfo.getVersion()); + assertEquals(VIM_ID, actualVnfmInfo.getVimId()); + assertEquals(VNFM_ID, actualVnfmInfo.getVnfmId()); + } + + /** + * unable to query VNFM from AAI results in error + */ + @Test + public void testVnfmUnableToQuery() throws Exception { + RuntimeException expectedException = new RuntimeException(); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.ESR, "/esr-vnfm-list/esr-vnfm/" + VNFM_ID + "?depth=all", EsrVnfm.class)).thenThrow(expectedException); + //when + try { + aaiExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to query VNFM with " + VNFM_ID + " identifier from AAI", expectedException); + assertEquals(expectedException, e.getCause()); + } + } +}
\ No newline at end of file diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestAAIRestApiProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestAAIRestApiProvider.java new file mode 100644 index 00000000..953f7da0 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestAAIRestApiProvider.java @@ -0,0 +1,238 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aai.domain.yang.v11.GenericVnf; +import org.onap.aai.domain.yang.v11.L3Network; +import org.onap.aai.domain.yang.v11.ObjectFactory; +import org.onap.aai.restclient.client.OperationResult; +import org.onap.aai.restclient.client.RestClient; +import org.onap.aai.restclient.enums.RestAuthenticationMode; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import javax.xml.bind.JAXBContext; +import java.io.ByteArrayOutputStream; +import java.io.StringReader; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; + +import static com.google.common.collect.Lists.newArrayList; +import static java.util.Base64.getEncoder; +import static javax.ws.rs.core.MediaType.APPLICATION_XML_TYPE; +import static junit.framework.TestCase.*; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestAAIRestApiProvider extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + @Mock + private RestClient restClient; + private AAIRestApiProvider aaiRestApiProvider; + private ArgumentCaptor<Map> headers = ArgumentCaptor.forClass(Map.class); + private ArgumentCaptor<String> payload = ArgumentCaptor.forClass(String.class); + + private OperationResult result = new OperationResult(); + + public static String marshall(Object object) throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + JAXBContext.newInstance(object.getClass()).createMarshaller().marshal(object, bos); + return bos.toString(); + } + + public static <T> T unmarshal(String content, Class<T> clazz) { + try { + return (T) JAXBContext.newInstance(clazz).createUnmarshaller().unmarshal(new StringReader(content)); + } catch (Exception e) { + throw new RuntimeException(); + } + } + + @Before + public void init() { + //MockitoAnnotations.initMocks(this); + AAIRestApiProvider real = new AAIRestApiProvider(msbApiProvider); + setField(AAIRestApiProvider.class, "logger", logger); + setFieldWithPropertyAnnotation(real, "${aaiUsername}", "aaiUsername"); + setFieldWithPropertyAnnotation(real, "${aaiPassword}", "aaiPassword"); + aaiRestApiProvider = Mockito.spy(real); + when(aaiRestApiProvider.buildRawClient()).thenReturn(restClient); + when(restClient.basicAuthPassword("aaiPassword")).thenReturn(restClient); + when(restClient.basicAuthUsername("aaiUsername")).thenReturn(restClient); + when(restClient.authenticationMode(RestAuthenticationMode.SSL_BASIC)).thenReturn(restClient); + when(msbApiProvider.getMicroServiceUrl(AAIRestApiProvider.AAIService.CLOUD.getServiceName(), "v11")).thenReturn("x://1.2.3.4:4/a"); + result.setResultCode(201); + } + + /** + * test HTTP GET success scenario + */ + @Test + public void testGetSuccess() throws Exception { + GenericVnf vnf = OBJECT_FACTORY.createGenericVnf(); + vnf.setVnfId("myVnfId"); + when(restClient.get(eq("x://1.2.3.4:4/a/myurl"), headers.capture(), eq(APPLICATION_XML_TYPE))).thenReturn(result); + result.setResult(marshall(vnf)); + //when + GenericVnf actualVnf = aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", GenericVnf.class); + //verify + assertEquals(vnf.getVnfId(), actualVnf.getVnfId()); + assertHeaders(); + } + + /** + * HTTP GET on non existing resource results in {@link java.util.NoSuchElementException} + */ + @Test + public void testGetMissingResource() throws Exception { + when(restClient.get(eq("x://1.2.3.4:4/a/myurl"), headers.capture(), eq(APPLICATION_XML_TYPE))).thenReturn(result); + result.setResultCode(404); + //when + try { + aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", GenericVnf.class); + fail(); + } catch (NoSuchElementException e) { + verify(logger).debug("The resource at /myurl does not exists"); + assertEquals("The resource at /myurl does not exists", e.getMessage()); + } + } + + /** + * Non known HTTP response code is propagated + */ + @Test + public void testUnknownErroCode() throws Exception { + when(restClient.get(eq("x://1.2.3.4:4/a/myurl"), headers.capture(), eq(APPLICATION_XML_TYPE))).thenReturn(result); + result.setResultCode(502); + result.setFailureCause("myFail"); + //when + try { + aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", GenericVnf.class); + fail(); + } catch (RuntimeException e) { + verify(logger).error("Bad response. Code: 502 cause: myFail"); + assertEquals("Bad response. Code: 502 cause: myFail", e.getMessage()); + } + } + + /** + * response content is not used when not requesting result + */ + @Test + public void testNoResult() throws Exception { + when(restClient.get(eq("x://1.2.3.4:4/a/myurl"), headers.capture(), eq(APPLICATION_XML_TYPE))).thenReturn(result); + result.setResultCode(202); + //when + Void result = aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", Void.class); + //verify + assertNull(result); + } + + /** + * test HTTP PUT success scenario + */ + @Test + public void putSuccess() throws Exception { + when(restClient.put(eq("x://1.2.3.4:4/a/myurl"), payload.capture(), headers.capture(), eq(APPLICATION_XML_TYPE), eq(APPLICATION_XML_TYPE))).thenReturn(result); + GenericVnf request = OBJECT_FACTORY.createGenericVnf(); + request.setVnfId("myVnfId"); + L3Network response = OBJECT_FACTORY.createL3Network(); + response.setNetworkId("myNetworkId"); + result.setResult(marshall(response)); + //when + L3Network actualResponse = aaiRestApiProvider.put(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", request, L3Network.class); + //verify + GenericVnf actualValue = unmarshal(payload.getValue(), GenericVnf.class); + assertEquals("myVnfId", actualValue.getVnfId()); + assertEquals("myNetworkId", actualResponse.getNetworkId()); + assertHeaders(); + } + + /** + * test HTTP delete success scenario + */ + @Test + public void deleteSuccess() throws Exception { + when(restClient.delete(eq("x://1.2.3.4:4/a/myurl"), headers.capture(), eq(APPLICATION_XML_TYPE))).thenReturn(result); + //when + aaiRestApiProvider.delete(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl"); + //verify + assertHeaders(); + //the when above is the verify + } + + /** + * invalid request content results in error + */ + @Test + public void testInvalidInput() throws Exception { + when(restClient.put(eq("x://1.2.3.4:4/a/myurl"), payload.capture(), headers.capture(), eq(APPLICATION_XML_TYPE), eq(APPLICATION_XML_TYPE))).thenReturn(result); + //when + try { + aaiRestApiProvider.put(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", "Invalid content", L3Network.class); + //verify + fail(); + } catch (Exception e) { + assertEquals("Unable to marshal content", e.getMessage()); + verify(logger).error("Unable to marshal content", e.getCause()); + } + } + + /** + * invalid response content results in error + */ + @Test + public void testInvalidResponse() throws Exception { + when(restClient.put(eq("x://1.2.3.4:4/a/myurl"), payload.capture(), headers.capture(), eq(APPLICATION_XML_TYPE), eq(APPLICATION_XML_TYPE))).thenReturn(result); + GenericVnf request = OBJECT_FACTORY.createGenericVnf(); + request.setVnfId("myVnfId"); + result.setResult("invalid"); + //when + try { + aaiRestApiProvider.put(logger, AAIRestApiProvider.AAIService.CLOUD, "/myurl", request, L3Network.class); + //verify + fail(); + } catch (Exception e) { + assertEquals("Unable to unmarshal content", e.getMessage()); + verify(logger).error("Unable to unmarshal content", e.getCause()); + } + } + + /** + * test AAI service names in AAI + */ + @Test + public void testServiceNames() { + //the names have been base64-ed to prevent "smart" IDEs (idea) to refactor the tests too for the otherwise known fix constants in external systems + assertEquals("YWFpLWNsb3VkSW5mcmFzdHJ1Y3R1cmU=", getEncoder().encodeToString(AAIRestApiProvider.AAIService.CLOUD.getServiceName().getBytes())); + assertEquals("YWFpLW5ldHdvcms=", getEncoder().encodeToString(AAIRestApiProvider.AAIService.NETWORK.getServiceName().getBytes())); + assertEquals("YWFpLWV4dGVybmFsU3lzdGVt", getEncoder().encodeToString(AAIRestApiProvider.AAIService.ESR.getServiceName().getBytes())); + } + + private void assertHeaders() { + Map<String, List<String>> actualHeaders = headers.getValue(); + assertEquals(2, actualHeaders.size()); + assertEquals(newArrayList("NokiaSVNFM"), actualHeaders.get("X-FromAppId")); + assertEquals(newArrayList("application/xml"), actualHeaders.get("Accept")); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestGrantlessGrantManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestGrantlessGrantManager.java new file mode 100644 index 00000000..ad9b7fc8 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestGrantlessGrantManager.java @@ -0,0 +1,80 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import org.junit.Before; +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.model.GrantVNFResponseVim; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Mockito.verify; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestGrantlessGrantManager extends TestBase { + private GrantlessGrantManager grantlessGrantManager; + + @Before + public void init() { + grantlessGrantManager = new GrantlessGrantManager(); + setField(GrantlessGrantManager.class, "logger", logger); + } + + /** + * grant is only logged for healing + */ + @Test + public void testGrantForHeal() throws Exception { + //when + grantlessGrantManager.requestGrantForHeal(null, null, null, null, null, null); + //verify + verify(logger).info("No grant is requested in direct mode"); + } + + /** + * grant is only logged for instantiation + */ + @Test + public void testGrantForInstantiate() throws Exception { + //when + GrantVNFResponseVim grant = grantlessGrantManager.requestGrantForInstantiate(null, null, VIM_ID, null, null, null, null); + //verify + verify(logger).info("No grant is requested in direct mode"); + assertEquals(VIM_ID, grant.getVimId()); + } + + /** + * grant is only logged for scaling + */ + @Test + public void testGrantForScaling() throws Exception { + //when + grantlessGrantManager.requestGrantForScale(null, null, null, null, null, null); + //verify + verify(logger).info("No grant is requested in direct mode"); + } + + /** + * grant is only logged for termination + */ + @Test + public void testGrantForTerminate() throws Exception { + //when + grantlessGrantManager.requestGrantForTerminate(null, null, null, null, null, null); + //verify + verify(logger).info("No grant is requested in direct mode"); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestSdcPackageProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestSdcPackageProvider.java new file mode 100644 index 00000000..199f7255 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/TestSdcPackageProvider.java @@ -0,0 +1,130 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct; + +import org.apache.http.client.methods.HttpGet; +import org.junit.Before; +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.apache.http.HttpHeaders.ACCEPT; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager.SERVICE_NAME; +import static org.springframework.http.MediaType.APPLICATION_OCTET_STREAM_VALUE; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestSdcPackageProvider extends TestBase { + private SdcPackageProvider sdcPackageProvider; + + @Before + public void init() { + sdcPackageProvider = new SdcPackageProvider(msbApiProvider, driverProperties); + setField(SdcPackageProvider.class, "logger", logger); + setFieldWithPropertyAnnotation(sdcPackageProvider, "${sdcUsername}", "sdcUsername"); + setFieldWithPropertyAnnotation(sdcPackageProvider, "${sdcPassword}", "sdcPassword"); + when(msbApiProvider.getMicroServiceUrl("sdc", "v1")).thenReturn("https://1.2.3.4:456/g"); + } + + /** + * test package download from SDC + */ + @Test + public void testPackageDownload() throws Exception { + when(entity.getContent()).thenReturn(new ByteArrayInputStream("test".getBytes())); + //when + byte[] result = sdcPackageProvider.getPackage("csarId"); + //verify + assertEquals("test", new String("test")); + HttpGet httpGet = (HttpGet) request.getValue(); + assertEquals(VNFM_ID, httpGet.getFirstHeader("X-ECOMP-InstanceID").getValue()); + assertEquals(SERVICE_NAME, httpGet.getFirstHeader("X-FromAppId").getValue()); + assertEquals(APPLICATION_OCTET_STREAM_VALUE, httpGet.getFirstHeader(ACCEPT).getValue()); + assertEquals("https://1.2.3.4:456/g/sdc/v1/catalog/resources/csarId/toscaModel", httpGet.getURI().toASCIIString()); + } + + /** + * failure to download package from SDC is propagated + */ + @Test + public void testFailedPackageDownload() throws Exception { + IOException expectedException = new IOException(); + when(httpClient.execute(any())).thenThrow(expectedException); + try { + sdcPackageProvider.getPackage("csarId"); + fail(); + } catch (Exception e) { + assertEquals("Unable to download csarId package from SDC", e.getMessage()); + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to download csarId package from SDC", expectedException); + } + } + + /** + * get VNFD from ONAP package + */ + @Test + public void testGetVnfd() throws Exception { + byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar"); + when(entity.getContent()).thenReturn(new ByteArrayInputStream(onapPackageContent)); + //when + String cbamVnfdId = sdcPackageProvider.getCbamVnfdId("csarId"); + //verify + assertEquals("Nokia~SimpleDual_scalable~1.0~1.0", cbamVnfdId); + } + + /** + * unable to download package from SDC during get CBAM VNFD id + */ + @Test + public void testUnableToDownloadPackageDuringVnfdIdGet() throws Exception { + IOException expectedException = new IOException(); + when(httpClient.execute(any())).thenThrow(expectedException); + try { + sdcPackageProvider.getCbamVnfdId("csarId"); + fail(); + } catch (Exception e) { + assertEquals("Unable to download csarId package from SDC", e.getMessage()); + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to download csarId package from SDC", expectedException); + } + } + + /** + * invalid VNF package results in error + */ + @Test + public void testInvalidVNFDContent() throws Exception { + byte[] onapPackageContent = "invalidZip".getBytes(); + when(entity.getContent()).thenReturn(new ByteArrayInputStream(onapPackageContent)); + try { + sdcPackageProvider.getCbamVnfdId("csarId"); + fail(); + } catch (Exception e) { + assertEquals("Unable to extract CBAM VNFD id from ONAP package", e.getMessage()); + verify(logger).error(eq("Unable to extract CBAM VNFD id from ONAP package"), any(NoSuchElementException.class)); + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestAAINotificationProcessor.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestAAINotificationProcessor.java new file mode 100644 index 00000000..bc8f7835 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestAAINotificationProcessor.java @@ -0,0 +1,253 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.gson.JsonObject; +import com.nokia.cbam.lcm.v32.model.*; +import org.jetbrains.annotations.NotNull; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp; + +import java.util.ArrayList; +import java.util.UUID; + +import static com.nokia.cbam.lcm.v32.model.ChangeType.*; +import static java.util.Optional.empty; +import static java.util.Optional.of; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestAAINotificationProcessor extends TestBase { + @Mock + private GenericVnfManager genericVnfManager; + @Mock + private L3NetworkManager l3NetworkManager; + @Mock + private LInterfaceManager lInterfaceManager; + @Mock + private VnfcManager vnfcManager; + @Mock + private VserverManager vserverManager; + private AAINotificationProcessor aaiNotificationProcessor; + + @Before + public void init() { + aaiNotificationProcessor = new AAINotificationProcessor(genericVnfManager, l3NetworkManager, lInterfaceManager, vnfcManager, vserverManager); + setField(AAINotificationProcessor.class, "logger", logger); + } + + /** + * test objects are manipulated in correct order in AAA + * (other is dependency between the objects though relations) + */ + @Test + public void testObjectManipulationOrder() throws Exception { + VnfLifecycleChangeNotification recievenNotification = new VnfLifecycleChangeNotification(); + recievenNotification.setAffectedVnfcs(new ArrayList<>()); + recievenNotification.setAffectedVirtualLinks(new ArrayList<>()); + ArrayList<AffectedVirtualStorage> affectedVirtualStorages = new ArrayList<>(); + recievenNotification.setAffectedVirtualStorages(affectedVirtualStorages); + recievenNotification.setVnfInstanceId(VNF_ID); + recievenNotification.setStatus(OperationStatus.STARTED); + AffectedVirtualLink addedLink = buildVl(recievenNotification, ADDED); + AffectedVirtualLink removedLink = buildVl(recievenNotification, REMOVED); + AffectedVirtualLink modifiedLink = buildVl(recievenNotification, MODIFIED); + AffectedVnfc addedVnfc = buildVnfc(recievenNotification, ADDED, "tenantId1"); + AffectedVnfc removedVnfc = buildVnfc(recievenNotification, REMOVED, "tenantId2"); + AffectedVnfc modifedVnfc = buildVnfc(recievenNotification, MODIFIED, "tenantId3"); + boolean inMaintenance = true; + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + + ReportedAffectedCp removedCp = buildCp(); + removedCp.setServerProviderId("serverId"); + affectedConnectionPoints.getPre().add(removedCp); + + ReportedAffectedCp removedCpWithoutServer = buildCp(); + removedCpWithoutServer.setServerProviderId(null); + affectedConnectionPoints.getPre().add(removedCpWithoutServer); + + ReportedAffectedCp addedCp = buildCp(); + addedCp.setServerProviderId("serverId"); + affectedConnectionPoints.getPost().add(addedCp); + //when + aaiNotificationProcessor.processNotification(recievenNotification, null, of(affectedConnectionPoints), VIM_ID); + //verify + InOrder inOrder = Mockito.inOrder(genericVnfManager, l3NetworkManager, lInterfaceManager, vnfcManager, vserverManager); + inOrder.verify(l3NetworkManager).update(VIM_ID, VNF_ID, addedLink); + inOrder.verify(l3NetworkManager).update(VIM_ID, VNF_ID, modifiedLink); + inOrder.verify(vserverManager).update(VIM_ID, VNF_ID, addedVnfc, affectedVirtualStorages, inMaintenance); + inOrder.verify(vnfcManager).update(VIM_ID, "tenantId1", VNF_ID, addedVnfc, inMaintenance); + inOrder.verify(vserverManager).update(VIM_ID, VNF_ID, modifedVnfc, affectedVirtualStorages, inMaintenance); + inOrder.verify(vnfcManager).update(VIM_ID, "tenantId3", VNF_ID, modifedVnfc, inMaintenance); + inOrder.verify(lInterfaceManager).delete(VIM_ID, removedCp); + inOrder.verify(lInterfaceManager).update(VNF_ID, VIM_ID, addedCp, inMaintenance); + inOrder.verify(vnfcManager).delete(VNF_ID, removedVnfc); + inOrder.verify(vserverManager).delete(VIM_ID, removedVnfc); + inOrder.verify(l3NetworkManager).delete(VNF_ID, removedLink); + verify(lInterfaceManager, never()).update(VNF_ID, VIM_ID, removedCpWithoutServer, inMaintenance); + verify(lInterfaceManager, never()).delete(VIM_ID, removedCpWithoutServer); + } + + /** + * - unchanged CP is updated + * - changed CP is updated + */ + @Test + public void testCps() throws Exception { + VnfLifecycleChangeNotification recievenNotification = new VnfLifecycleChangeNotification(); + recievenNotification.setAffectedVnfcs(new ArrayList<>()); + recievenNotification.setAffectedVirtualLinks(new ArrayList<>()); + recievenNotification.setVnfInstanceId(VNF_ID); + recievenNotification.setStatus(OperationStatus.STARTED); + ArrayList<AffectedVirtualStorage> affectedVirtualStorages = new ArrayList<>(); + recievenNotification.setAffectedVirtualStorages(affectedVirtualStorages); + boolean inMaintenance = true; + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + + ReportedAffectedCp unchangedCp = buildCp(); + unchangedCp.setCpId("unchanged"); + affectedConnectionPoints.getPre().add(unchangedCp); + affectedConnectionPoints.getPost().add(unchangedCp); + + ReportedAffectedCp changedCpBefore = buildCp(); + changedCpBefore.setCpId("changedBefore"); + ReportedAffectedCp changedCpAfter = buildCp(); + changedCpAfter.setCpId("changedAfter"); + changedCpAfter.setCpId(changedCpBefore.getCpId()); + affectedConnectionPoints.getPre().add(changedCpBefore); + affectedConnectionPoints.getPost().add(changedCpAfter); + + //when + aaiNotificationProcessor.processNotification(recievenNotification, null, of(affectedConnectionPoints), VIM_ID); + //verify + verify(lInterfaceManager).update(VNF_ID, VIM_ID, unchangedCp, inMaintenance); + verify(lInterfaceManager, never()).update(VNF_ID, VIM_ID, changedCpBefore, inMaintenance); + verify(lInterfaceManager).update(VNF_ID, VIM_ID, changedCpAfter, inMaintenance); + } + + /** + * the end notification calls resource managers with not in maintenance state + */ + @Test + public void testEndNotification() throws Exception { + VnfLifecycleChangeNotification recievenNotification = new VnfLifecycleChangeNotification(); + recievenNotification.setAffectedVnfcs(new ArrayList<>()); + recievenNotification.setAffectedVirtualLinks(new ArrayList<>()); + ArrayList<AffectedVirtualStorage> affectedVirtualStorages = new ArrayList<>(); + recievenNotification.setAffectedVirtualStorages(affectedVirtualStorages); + recievenNotification.setVnfInstanceId(VNF_ID); + recievenNotification.setStatus(OperationStatus.FINISHED); + AffectedVirtualLink addedLink = buildVl(recievenNotification, ADDED); + AffectedVirtualLink removedLink = buildVl(recievenNotification, REMOVED); + AffectedVirtualLink modifiedLink = buildVl(recievenNotification, MODIFIED); + AffectedVnfc addedVnfc = buildVnfc(recievenNotification, ADDED, "tenantId1"); + AffectedVnfc removedVnfc = buildVnfc(recievenNotification, REMOVED, "tenantId2"); + AffectedVnfc modifedVnfc = buildVnfc(recievenNotification, MODIFIED, "tenantId3"); + boolean inMaintenance = false; + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + + ReportedAffectedCp removedCp = buildCp(); + removedCp.setServerProviderId("serverId"); + affectedConnectionPoints.getPre().add(removedCp); + + ReportedAffectedCp removedCpWithoutServer = buildCp(); + removedCpWithoutServer.setServerProviderId(null); + affectedConnectionPoints.getPre().add(removedCpWithoutServer); + + ReportedAffectedCp addedCp = buildCp(); + addedCp.setServerProviderId("serverId"); + affectedConnectionPoints.getPost().add(addedCp); + + ReportedAffectedCp cpWithoutServer = buildCp(); + cpWithoutServer.setServerProviderId(null); + affectedConnectionPoints.getPost().add(cpWithoutServer); + + //when + aaiNotificationProcessor.processNotification(recievenNotification, null, of(affectedConnectionPoints), VIM_ID); + //verify + InOrder inOrder = Mockito.inOrder(genericVnfManager, l3NetworkManager, lInterfaceManager, vnfcManager, vserverManager); + inOrder.verify(l3NetworkManager).update(VIM_ID, VNF_ID, addedLink); + inOrder.verify(l3NetworkManager).update(VIM_ID, VNF_ID, modifiedLink); + inOrder.verify(vserverManager).update(VIM_ID, VNF_ID, addedVnfc, affectedVirtualStorages, inMaintenance); + inOrder.verify(vnfcManager).update(VIM_ID, "tenantId1", VNF_ID, addedVnfc, inMaintenance); + inOrder.verify(vserverManager).update(VIM_ID, VNF_ID, modifedVnfc, affectedVirtualStorages, inMaintenance); + inOrder.verify(vnfcManager).update(VIM_ID, "tenantId3", VNF_ID, modifedVnfc, inMaintenance); + inOrder.verify(lInterfaceManager).delete(VIM_ID, removedCp); + inOrder.verify(lInterfaceManager).update(VNF_ID, VIM_ID, addedCp, inMaintenance); + inOrder.verify(vnfcManager).delete(VNF_ID, removedVnfc); + inOrder.verify(vserverManager).delete(VIM_ID, removedVnfc); + inOrder.verify(l3NetworkManager).delete(VNF_ID, removedLink); + verify(lInterfaceManager, never()).update(VNF_ID, VIM_ID, removedCpWithoutServer, inMaintenance); + verify(lInterfaceManager, never()).delete(VIM_ID, removedCpWithoutServer); + verify(logger).warn("The changed {} connection point is not linked to any server", cpWithoutServer.getCpId()); + } + + + + /** + * if changes connection points are not present a warning is logged + */ + @Test + public void testMissingChangedConnectionPoints() throws Exception { + VnfLifecycleChangeNotification recievenNotification = new VnfLifecycleChangeNotification(); + recievenNotification.setAffectedVnfcs(new ArrayList<>()); + recievenNotification.setAffectedVirtualLinks(new ArrayList<>()); + recievenNotification.setVnfInstanceId(VNF_ID); + //when + aaiNotificationProcessor.processNotification(recievenNotification, null, empty(), VIM_ID); + //verify + verify(logger).warn("The changed connection points are not present in VNF with {} identifier", VNF_ID); + } + + @NotNull + private ReportedAffectedCp buildCp() { + ReportedAffectedCp cp = new ReportedAffectedCp(); + cp.setServerProviderId(UUID.randomUUID().toString()); + cp.setName(UUID.randomUUID().toString()); + cp.setEcpdId(UUID.randomUUID().toString()); + cp.setMacAddress(UUID.randomUUID().toString()); + cp.setNetworkProviderId(UUID.randomUUID().toString()); + cp.setCpdId(UUID.randomUUID().toString()); + cp.setCpId(UUID.randomUUID().toString()); + cp.setTenantId(UUID.randomUUID().toString()); + return cp; + } + + private AffectedVirtualLink buildVl(VnfLifecycleChangeNotification recievenNotification, ChangeType changeType) { + AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + affectedVirtualLink.setChangeType(changeType); + recievenNotification.getAffectedVirtualLinks().add(affectedVirtualLink); + return affectedVirtualLink; + } + + private AffectedVnfc buildVnfc(VnfLifecycleChangeNotification recievenNotification, ChangeType changeType, String tenantId) { + AffectedVnfc addedVnfc = new AffectedVnfc(); + addedVnfc.setChangeType(changeType); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("tenantId", tenantId); + addedVnfc.setComputeResource(new ResourceHandle()); + addedVnfc.getComputeResource().setAdditionalData(additionalData); + recievenNotification.getAffectedVnfcs().add(addedVnfc); + return addedVnfc; + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestAbstractManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestAbstractManager.java new file mode 100644 index 00000000..2495daf1 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestAbstractManager.java @@ -0,0 +1,230 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.gson.JsonObject; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.onap.aai.domain.yang.v11.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.slf4j.Logger; + +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Mockito.when; + +public class TestAbstractManager extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + @Mock + private AAIRestApiProvider aaiRestApiProvider; + private DummyManager dummyManager; + + @Before + public void init() { + dummyManager = new DummyManager(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + /** + * if the REST resource does not exists the provided instance is used + */ + @Test + public void testIfResourceDoesNotExists() throws Exception { + GenericVnf newInstance = OBJECT_FACTORY.createGenericVnf(); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "url", GenericVnf.class)).thenThrow(new NoSuchElementException()); + //when + GenericVnf actualInstance = dummyManager.createOrGet(AAIRestApiProvider.AAIService.CLOUD, "url", newInstance); + //verify + assertEquals(newInstance, actualInstance); + } + + /** + * if the REST resource exists it is not recreated + */ + @Test + public void testIfResourceExists() throws Exception { + GenericVnf newInstance = OBJECT_FACTORY.createGenericVnf(); + GenericVnf existingInstance = OBJECT_FACTORY.createGenericVnf(); + existingInstance.setVnfId("id"); + when(aaiRestApiProvider.get(logger, AAIRestApiProvider.AAIService.CLOUD, "url", GenericVnf.class)).thenReturn(existingInstance); + //when + GenericVnf actualInstance = dummyManager.createOrGet(AAIRestApiProvider.AAIService.CLOUD, "url", newInstance); + //verify + assertEquals(existingInstance, actualInstance); + } + + @Test + public void testBuildRelationshipData() { + RelationshipData relationshipData = AbstractManager.buildRelationshipData("key", "value"); + assertEquals("key", relationshipData.getRelationshipKey()); + assertEquals("value", relationshipData.getRelationshipValue()); + } + + @Test + public void testExtractMandatoryValue() { + JsonObject object = new JsonObject(); + object.addProperty("key", "value"); + assertEquals("value", AbstractManager.extractMandatoryValue(object, "key")); + } + + /** + * the same relation is replaced + */ + @Test + public void testAddSingletonRelationForExisting() { + RelationshipList relations = OBJECT_FACTORY.createRelationshipList(); + Relationship relation = OBJECT_FACTORY.createRelationship(); + relation.setRelatedTo("unknownRelation"); + relations.getRelationship().add(relation); + Relationship sameRelation = OBJECT_FACTORY.createRelationship(); + sameRelation.setRelatedTo("relatedTo"); + relations.getRelationship().add(sameRelation); + RelationshipData data = OBJECT_FACTORY.createRelationshipData(); + data.setRelationshipValue("v"); + data.setRelationshipKey("k"); + sameRelation.getRelationshipData().add(data); + + Relationship newRelation = OBJECT_FACTORY.createRelationship(); + newRelation.setRelatedTo("relatedTo"); + RelationshipData data2 = OBJECT_FACTORY.createRelationshipData(); + data2.setRelationshipValue("v2"); + data2.setRelationshipKey("k2"); + newRelation.getRelationshipData().add(data2); + + //when + AbstractManager.addSingletonRelation(relations, newRelation); + //verify + + assertEquals(2, relations.getRelationship().size()); + assertEquals(1, relations.getRelationship().get(1).getRelationshipData().size()); + assertEquals("k2", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipKey()); + assertEquals("v2", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipValue()); + } + + /** + * the missing relation is created + */ + @Test + public void testAddSingletonRelation() { + RelationshipList relations = OBJECT_FACTORY.createRelationshipList(); + Relationship relation = OBJECT_FACTORY.createRelationship(); + relation.setRelatedTo("unknownRelation"); + relations.getRelationship().add(relation); + + Relationship newRelation = OBJECT_FACTORY.createRelationship(); + newRelation.setRelatedTo("relatedTo"); + RelationshipData data2 = OBJECT_FACTORY.createRelationshipData(); + data2.setRelationshipValue("v2"); + data2.setRelationshipKey("k2"); + newRelation.getRelationshipData().add(data2); + + //when + AbstractManager.addSingletonRelation(relations, newRelation); + //verify + assertEquals(2, relations.getRelationship().size()); + assertEquals(1, relations.getRelationship().get(1).getRelationshipData().size()); + assertEquals("k2", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipKey()); + assertEquals("v2", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipValue()); + } + + /** + * the same relation is replaced + */ + @Test + public void testAddMissingRelationForExisting() { + RelationshipList relations = OBJECT_FACTORY.createRelationshipList(); + Relationship relation = OBJECT_FACTORY.createRelationship(); + relation.setRelatedTo("unknownRelation"); + relations.getRelationship().add(relation); + Relationship sameRelation = OBJECT_FACTORY.createRelationship(); + sameRelation.setRelatedTo("relatedTo"); + relations.getRelationship().add(sameRelation); + RelationshipData data = OBJECT_FACTORY.createRelationshipData(); + data.setRelationshipValue("v"); + data.setRelationshipKey("k"); + sameRelation.getRelationshipData().add(data); + + Relationship newRelation = OBJECT_FACTORY.createRelationship(); + newRelation.setRelatedTo("relatedTo"); + RelationshipData data2 = OBJECT_FACTORY.createRelationshipData(); + data2.setRelationshipValue("v2"); + data2.setRelationshipKey("k2"); + newRelation.getRelationshipData().add(data2); + + //when + AbstractManager.addMissingRelation(relations, newRelation); + //verify + + assertEquals(3, relations.getRelationship().size()); + assertEquals(1, relations.getRelationship().get(1).getRelationshipData().size()); + assertEquals("k", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipKey()); + assertEquals("v", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipValue()); + assertEquals("k2", relations.getRelationship().get(2).getRelationshipData().get(0).getRelationshipKey()); + assertEquals("v2", relations.getRelationship().get(2).getRelationshipData().get(0).getRelationshipValue()); + } + + /** + * adding the same relation is not duplicated + */ + @Test + public void testAddMissingRelation() { + RelationshipList relations = OBJECT_FACTORY.createRelationshipList(); + Relationship relation = OBJECT_FACTORY.createRelationship(); + relation.setRelatedTo("unknownRelation"); + relations.getRelationship().add(relation); + + Relationship sameRelation = OBJECT_FACTORY.createRelationship(); + sameRelation.setRelatedTo("relatedTo"); + relations.getRelationship().add(sameRelation); + RelationshipData data = OBJECT_FACTORY.createRelationshipData(); + data.setRelationshipValue("v"); + data.setRelationshipKey("k"); + sameRelation.getRelationshipData().add(data); + + Relationship newRelation = OBJECT_FACTORY.createRelationship(); + newRelation.setRelatedTo("relatedTo"); + RelationshipData data2 = OBJECT_FACTORY.createRelationshipData(); + data2.setRelationshipValue("v"); + data2.setRelationshipKey("k"); + newRelation.getRelationshipData().add(data2); + + //when + AbstractManager.addMissingRelation(relations, newRelation); + //verify + assertEquals(2, relations.getRelationship().size()); + assertEquals(1, relations.getRelationship().get(1).getRelationshipData().size()); + assertEquals("k", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipKey()); + assertEquals("v", relations.getRelationship().get(1).getRelationshipData().get(0).getRelationshipValue()); + } + + class DummyManager extends AbstractManager { + + DummyManager(AAIRestApiProvider aaiRestApiProvider, CbamRestApiProvider cbamRestApiProvider, DriverProperties driverProperties) { + super(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + } + + @Override + protected Logger getLogger() { + return logger; + } + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestGenericVnfManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestGenericVnfManager.java new file mode 100644 index 00000000..861966f3 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestGenericVnfManager.java @@ -0,0 +1,250 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.nokia.cbam.lcm.v32.ApiException; +import com.nokia.cbam.lcm.v32.model.VnfInfo; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.aai.domain.yang.v11.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.util.HashSet; +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.concurrent.atomic.AtomicLong; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.NETWORK; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestGenericVnfManager extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + private ArgumentCaptor<GenericVnf> payload = ArgumentCaptor.forClass(GenericVnf.class); + + @Mock + private AAIRestApiProvider aaiRestApiProvider; + private GenericVnfManager genericVnfManager; + private VnfInfo vnfInfo = new VnfInfo(); + + static void assertRelation(RelationshipList relationShips, String relatedTo, RelationshipData... data) { + for (Relationship relationship : relationShips.getRelationship()) { + if (relationship.getRelatedTo().equals(relatedTo)) { + assertEquals(data.length, relationship.getRelationshipData().size()); + int i = 0; + for (RelationshipData c : data) { + assertEquals(c.getRelationshipKey(), relationship.getRelationshipData().get(i).getRelationshipKey()); + assertEquals(c.getRelationshipValue(), relationship.getRelationshipData().get(i).getRelationshipValue()); + i++; + } + return; + } + } + fail(); + } + + @Before + public void init() { + genericVnfManager = new GenericVnfManager(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + setField(GenericVnfManager.class, "logger", logger); + AtomicLong currentTime = new AtomicLong(0L); + when(systemFunctions.currentTimeMillis()).thenAnswer(new Answer<Long>() { + @Override + public Long answer(InvocationOnMock invocation) throws Throwable { + return currentTime.get(); + } + }); + Mockito.doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + currentTime.addAndGet((Long) invocation.getArguments()[0] + 1); + return null; + } + }).when(systemFunctions).sleep(anyLong()); + } + + /** + * retrieving an existing VNF + */ + @Test + public void testGetExistingVnf() throws Exception { + GenericVnf aaiVnf = OBJECT_FACTORY.createGenericVnf(); + when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenReturn(aaiVnf); + //when + GenericVnf vnf = genericVnfManager.getExistingVnf(VNF_ID); + //verify + assertEquals(aaiVnf, vnf); + } + + /** + * if the VNF does not exist it is created + */ + @Test + public void createNonExistingVnf() throws Exception { + GenericVnf vnfInAaai = OBJECT_FACTORY.createGenericVnf(); + Set<GenericVnf> vnfs = new HashSet<>(); + when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenAnswer((Answer<GenericVnf>) invocation -> { + if (vnfs.size() == 0) { + throw new NoSuchElementException(); + } + return vnfs.iterator().next(); + }); + when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenAnswer(invocation -> { + vnfs.add(vnfInAaai); + return null; + }); + vnfInfo.setName("vnfName"); + //when + genericVnfManager.createOrUpdate(VNF_ID, true); + //verify + GenericVnf vnfSentToAai = payload.getValue(); + assertEquals(VNF_ID, vnfSentToAai.getVnfId()); + assertEquals(VNF_ID, vnfSentToAai.getVnfInstanceId()); + assertEquals("NokiaVNF", vnfSentToAai.getVnfType()); + assertEquals(true, vnfSentToAai.isInMaint()); + assertEquals(true, vnfSentToAai.isIsClosedLoopDisabled()); + assertEquals("vnfName", vnfSentToAai.getVnfName()); + verify(systemFunctions, times(10)).sleep(3000); + verify(aaiRestApiProvider, times(10)).get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class); + } + + /** + * if the VNF exist it is updated + */ + @Test + public void testUpdateExistingVnf() throws Exception { + GenericVnf vnfInAaai = OBJECT_FACTORY.createGenericVnf(); + vnfInAaai.setResourceVersion("v1"); + when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenReturn(vnfInAaai); + when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenReturn(null); + vnfInfo.setName("vnfName"); + //when + genericVnfManager.createOrUpdate(VNF_ID, true); + //verify + GenericVnf vnfSentToAai = payload.getValue(); + assertEquals(VNF_ID, vnfSentToAai.getVnfId()); + assertEquals(VNF_ID, vnfSentToAai.getVnfInstanceId()); + assertEquals("NokiaVNF", vnfSentToAai.getVnfType()); + assertEquals(true, vnfSentToAai.isInMaint()); + assertEquals(true, vnfSentToAai.isIsClosedLoopDisabled()); + assertEquals("vnfName", vnfSentToAai.getVnfName()); + verify(systemFunctions, never()).sleep(anyLong()); + verify(aaiRestApiProvider, times(1)).get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class); + } + + /** + * error is propagated if unable to query VNF from CBAM + */ + @Test + public void testUnableToQueryVnfFromCBAM() throws Exception { + GenericVnf vnfInAaai = OBJECT_FACTORY.createGenericVnf(); + vnfInAaai.setResourceVersion("v1"); + when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenReturn(vnfInAaai); + ApiException expectedException = new ApiException(); + when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenAnswer(invocation -> { + vnfInAaai.setResourceVersion("v2"); + return null; + }); + vnfInfo.setName("vnfName"); + //when + try { + genericVnfManager.createOrUpdate(VNF_ID, true); + } catch (Exception e) { + verify(logger).error("Unable to query VNF with myVnfId identifier from CBAM", expectedException); + assertEquals("Unable to query VNF with myVnfId identifier from CBAM", e.getMessage()); + } + } + + /** + * if the VNF is created after the last attempt to query VNF, but before the + * the driver creates the VNF it is not created but updated + */ + @Test + public void testConcurency1() throws Exception { + GenericVnf vnfInAaai = OBJECT_FACTORY.createGenericVnf(); + vnfInAaai.setResourceVersion("v3"); + Set<Integer> queryCount = new HashSet<>(); + when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenAnswer((Answer<GenericVnf>) invocation -> { + queryCount.add(queryCount.size()); + if (queryCount.size() >= 11) { + return vnfInAaai; + } + throw new NoSuchElementException(); + }); + when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + RuntimeException runtimeException = new RuntimeException(); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenAnswer(invocation -> { + GenericVnf vnfSentToAAi = (GenericVnf) invocation.getArguments()[3]; + if (vnfSentToAAi.getResourceVersion() == null) { + throw runtimeException; + } + return null; + }); + vnfInfo.setName("vnfName"); + //when + genericVnfManager.createOrUpdate(VNF_ID, true); + //verify + GenericVnf vnfSentToAai = payload.getValue(); + assertEquals(VNF_ID, vnfSentToAai.getVnfId()); + assertEquals(VNF_ID, vnfSentToAai.getVnfInstanceId()); + assertEquals("NokiaVNF", vnfSentToAai.getVnfType()); + assertEquals(true, vnfSentToAai.isInMaint()); + assertEquals(true, vnfSentToAai.isIsClosedLoopDisabled()); + assertEquals("vnfName", vnfSentToAai.getVnfName()); + assertEquals("v3", vnfSentToAai.getResourceVersion()); + verify(systemFunctions, times(10)).sleep(3000); + verify(aaiRestApiProvider, times(11)).get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class); + verify(aaiRestApiProvider, times(2)).put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), anyString(), eq(Void.class)); + verify(logger).warn(eq("The VNF with myVnfId identifier did not appear in time"), any(NoSuchElementException.class)); + verify(logger).warn("The VNF with myVnfId identifier has been created since after the maximal wait for VNF to appear timeout", runtimeException); + } + + /** + * test how entities can refer to a VNF + */ + @Test + public void testRelations() { + //when + Relationship relationship = GenericVnfManager.linkTo(VNF_ID); + //verify + assertEquals("generic-vnf", relationship.getRelatedTo()); + assertEquals(1, relationship.getRelationshipData().size()); + assertEquals("generic-vnf.vnf-id", relationship.getRelationshipData().get(0).getRelationshipKey()); + assertEquals(VNF_ID, relationship.getRelationshipData().get(0).getRelationshipValue()); + } + + /** + * test inheritence + */ + @Test + public void testInheritence() { + assertEquals(logger, genericVnfManager.getLogger()); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestL3NetworkManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestL3NetworkManager.java new file mode 100644 index 00000000..159d6e63 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestL3NetworkManager.java @@ -0,0 +1,143 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.gson.JsonObject; +import com.nokia.cbam.lcm.v32.model.AffectedVirtualLink; +import com.nokia.cbam.lcm.v32.model.ResourceHandle; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.onap.aai.domain.yang.v11.L3Network; +import org.onap.aai.domain.yang.v11.ObjectFactory; +import org.onap.aai.domain.yang.v11.RelationshipList; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertFalse; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.NETWORK; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.AbstractManager.buildRelationshipData; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.TestGenericVnfManager.assertRelation; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestL3NetworkManager extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + private ArgumentCaptor<L3Network> payload = ArgumentCaptor.forClass(L3Network.class); + private AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + @Mock + private AAIRestApiProvider aaiRestApiProvider; + private L3NetworkManager l3NetworkManager; + + @Before + public void init() { + l3NetworkManager = new L3NetworkManager(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + setField(L3NetworkManager.class, "logger", logger); + } + + /** + * test L3 network creation + */ + @Test + public void testUpdate() throws Exception { + affectedVirtualLink.setId("vlId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "netName"); + additionalData.addProperty("tenantId", "myTenantId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setAdditionalData(additionalData); + affectedVirtualLink.getResource().setResourceId("netProviderId"); + when(aaiRestApiProvider.get(logger, NETWORK, "/l3-networks/l3-network/myVnfId_vlId", L3Network.class)).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/l3-networks/l3-network/myVnfId_vlId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + l3NetworkManager.update(VIM_ID, VNF_ID, affectedVirtualLink); + //verify + assertEquals("myVnfId_vlId", payload.getValue().getNetworkId()); + assertEquals("netName", payload.getValue().getNetworkName()); + assertEquals("netProviderId", payload.getValue().getNeutronNetworkId()); + assertFalse(payload.getValue().isIsBoundToVpn()); + assertFalse(payload.getValue().isIsProviderNetwork()); + assertFalse(payload.getValue().isIsSharedNetwork()); + assertFalse(payload.getValue().isIsExternalNetwork()); + assertEquals("active", payload.getValue().getOperationalStatus()); + assertRelation(payload.getValue().getRelationshipList(), "cloud-region", buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID))); + assertRelation(payload.getValue().getRelationshipList(), "tenant", buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID)), buildRelationshipData("tenant.tenant-id", "myTenantId")); + assertRelation(payload.getValue().getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + } + + /** + * Test existing resource update + */ + @Test + public void testExistingUpdate() throws Exception { + affectedVirtualLink.setId("vlId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "netName"); + additionalData.addProperty("tenantId", "myTenantId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setAdditionalData(additionalData); + affectedVirtualLink.getResource().setResourceId("netProviderId"); + L3Network l3Network = OBJECT_FACTORY.createL3Network(); + l3Network.setResourceVersion("v3"); + l3Network.setRelationshipList(new RelationshipList()); + when(aaiRestApiProvider.get(logger, NETWORK, "/l3-networks/l3-network/myVnfId_vlId", L3Network.class)).thenReturn(l3Network); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/l3-networks/l3-network/myVnfId_vlId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + l3NetworkManager.update(VIM_ID, VNF_ID, affectedVirtualLink); + //verify + assertEquals("myVnfId_vlId", payload.getValue().getNetworkId()); + assertEquals("netName", payload.getValue().getNetworkName()); + assertEquals("netProviderId", payload.getValue().getNeutronNetworkId()); + assertFalse(payload.getValue().isIsBoundToVpn()); + assertFalse(payload.getValue().isIsProviderNetwork()); + assertFalse(payload.getValue().isIsSharedNetwork()); + assertFalse(payload.getValue().isIsExternalNetwork()); + assertEquals("active", payload.getValue().getOperationalStatus()); + assertEquals("v3", payload.getValue().getResourceVersion()); + assertRelation(payload.getValue().getRelationshipList(), "cloud-region", buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID))); + assertRelation(payload.getValue().getRelationshipList(), "tenant", buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID)), buildRelationshipData("tenant.tenant-id", "myTenantId")); + assertRelation(payload.getValue().getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + } + /** + * test L3 network deletion + */ + @Test + public void testDelete() throws Exception { + affectedVirtualLink.setId("vlId"); + //when + l3NetworkManager.delete(VNF_ID, affectedVirtualLink); + //verify + verify(aaiRestApiProvider).delete(logger, NETWORK, "/l3-networks/l3-network/myVnfId_vlId"); + } + + /** + * test inheritence + */ + @Test + public void testInheritence() { + assertEquals(logger, l3NetworkManager.getLogger()); + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestLInterfaceManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestLInterfaceManager.java new file mode 100644 index 00000000..ef9f569e --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestLInterfaceManager.java @@ -0,0 +1,230 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.onap.aai.domain.yang.v11.LInterface; +import org.onap.aai.domain.yang.v11.ObjectFactory; +import org.onap.aai.domain.yang.v11.RelationshipList; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp; + +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.CLOUD; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.AbstractManager.buildRelationshipData; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.TestGenericVnfManager.assertRelation; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestLInterfaceManager extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + private ArgumentCaptor<LInterface> payload = ArgumentCaptor.forClass(LInterface.class); + + @Mock + private AAIRestApiProvider aaiRestApiProvider; + private LInterfaceManager lInterfaceManager; + + @Before + public void init() { + lInterfaceManager = new LInterfaceManager(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + setField(LInterfaceManager.class, "logger", logger); + } + + /** + * test update success scenario + */ + @Test + public void testUpdate() throws Exception { + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setCpdId("cpdId"); + affectedCp.setTenantId("myTenantId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setMacAddress("mac"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setEcpdId("ecpdId"); + affectedCp.setName("name"); + affectedCp.setCpId("cpId"); + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), eq(LInterface.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + lInterfaceManager.update(VNF_ID, VIM_ID, affectedCp, true); + //verify + LInterface actualInterface = payload.getValue(); + assertEquals(true, actualInterface.isInMaint()); + assertEquals(false, actualInterface.isIsIpUnnumbered()); + assertEquals(false, actualInterface.isIsPortMirrored()); + assertEquals("name", actualInterface.getInterfaceName()); + assertEquals("cpId", actualInterface.getInterfaceId()); + assertEquals("cpdId", actualInterface.getInterfaceRole()); + assertEquals("mac", actualInterface.getMacaddr()); + assertEquals("active", actualInterface.getProvStatus()); + assertEquals(1, actualInterface.getL3InterfaceIpv4AddressList().size()); + assertEquals(0, actualInterface.getL3InterfaceIpv6AddressList().size()); + assertEquals("networkProviderId", actualInterface.getL3InterfaceIpv4AddressList().get(0).getNeutronNetworkId()); + assertEquals("1.2.3.4", actualInterface.getL3InterfaceIpv4AddressList().get(0).getL3InterfaceIpv4Address()); + assertRelation(actualInterface.getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + } + + /** + * test update success scenario without IP + */ + @Test + public void testUpdateWithoutIp() throws Exception { + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setCpdId("cpdId"); + affectedCp.setTenantId("myTenantId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setMacAddress("mac"); + affectedCp.setEcpdId("ecpdId"); + affectedCp.setName("name"); + affectedCp.setCpId("cpId"); + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), eq(LInterface.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + lInterfaceManager.update(VNF_ID, VIM_ID, affectedCp, true); + //verify + LInterface actualInterface = payload.getValue(); + assertEquals(true, actualInterface.isInMaint()); + assertEquals(false, actualInterface.isIsIpUnnumbered()); + assertEquals(false, actualInterface.isIsPortMirrored()); + assertEquals("name", actualInterface.getInterfaceName()); + assertEquals("cpId", actualInterface.getInterfaceId()); + assertEquals("cpdId", actualInterface.getInterfaceRole()); + assertEquals("mac", actualInterface.getMacaddr()); + assertEquals("active", actualInterface.getProvStatus()); + assertEquals(0, actualInterface.getL3InterfaceIpv6AddressList().size()); + assertEquals(0, actualInterface.getL3InterfaceIpv4AddressList().size()); + assertRelation(actualInterface.getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + } + + /** + * test update success scenario + */ + @Test + public void testExistingUpdate() throws Exception { + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setCpdId("cpdId"); + affectedCp.setTenantId("myTenantId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setMacAddress("mac"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setEcpdId("ecpdId"); + affectedCp.setName("name"); + affectedCp.setCpId("cpId"); + LInterface lInterface = OBJECT_FACTORY.createLInterface(); + lInterface.setResourceVersion("v3"); + lInterface.setRelationshipList(new RelationshipList()); + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), eq(LInterface.class))).thenReturn(lInterface); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + lInterfaceManager.update(VNF_ID, VIM_ID, affectedCp, true); + //verify + LInterface actualInterface = payload.getValue(); + assertEquals(true, actualInterface.isInMaint()); + assertEquals(false, actualInterface.isIsIpUnnumbered()); + assertEquals(false, actualInterface.isIsPortMirrored()); + assertEquals("name", actualInterface.getInterfaceName()); + assertEquals("cpId", actualInterface.getInterfaceId()); + assertEquals("cpdId", actualInterface.getInterfaceRole()); + assertEquals("mac", actualInterface.getMacaddr()); + assertEquals("active", actualInterface.getProvStatus()); + assertEquals(1, actualInterface.getL3InterfaceIpv4AddressList().size()); + assertEquals(0, actualInterface.getL3InterfaceIpv6AddressList().size()); + assertEquals("networkProviderId", actualInterface.getL3InterfaceIpv4AddressList().get(0).getNeutronNetworkId()); + assertEquals("1.2.3.4", actualInterface.getL3InterfaceIpv4AddressList().get(0).getL3InterfaceIpv4Address()); + assertEquals("v3", lInterface.getResourceVersion()); + assertRelation(actualInterface.getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + } + + /** + * test update success scenario for IPv6 address + */ + @Test + public void testUpdateForIpv6() throws Exception { + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setCpdId("cpdId"); + affectedCp.setTenantId("myTenantId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setMacAddress("mac"); + affectedCp.setIpAddress("::"); + affectedCp.setEcpdId("ecpdId"); + affectedCp.setName("name"); + affectedCp.setCpId("cpId"); + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), eq(LInterface.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq("/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + lInterfaceManager.update(VNF_ID, VIM_ID, affectedCp, false); + //verify + LInterface actualInterface = payload.getValue(); + assertEquals(false, actualInterface.isInMaint()); + assertEquals(false, actualInterface.isIsIpUnnumbered()); + assertEquals(false, actualInterface.isIsPortMirrored()); + assertEquals("name", actualInterface.getInterfaceName()); + assertEquals("cpId", actualInterface.getInterfaceId()); + assertEquals("cpdId", actualInterface.getInterfaceRole()); + assertEquals("mac", actualInterface.getMacaddr()); + assertEquals("active", actualInterface.getProvStatus()); + assertEquals(0, actualInterface.getL3InterfaceIpv4AddressList().size()); + assertEquals(1, actualInterface.getL3InterfaceIpv6AddressList().size()); + assertEquals("networkProviderId", actualInterface.getL3InterfaceIpv6AddressList().get(0).getNeutronNetworkId()); + assertEquals("::", actualInterface.getL3InterfaceIpv6AddressList().get(0).getL3InterfaceIpv6Address()); + assertRelation(actualInterface.getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + } + + /** + * test L3 network deletion + */ + @Test + public void testDelete() throws Exception { + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setCpId("cpId"); + affectedCp.setCpdId("cpdId"); + affectedCp.setTenantId("myTenantId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setNetworkProviderId("networkProviderId"); + //when + lInterfaceManager.delete(VIM_ID, affectedCp); + //verify + verify(aaiRestApiProvider).delete(logger, CLOUD, "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId/l-interfaces/l-interface/cpId"); + } + + /** + * test inheritence + */ + @Test + public void testInheritence() { + assertEquals(logger, lInterfaceManager.getLogger()); + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestVnfcManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestVnfcManager.java new file mode 100644 index 00000000..87a1149b --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestVnfcManager.java @@ -0,0 +1,108 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.nokia.cbam.lcm.v32.model.AffectedVnfc; +import com.nokia.cbam.lcm.v32.model.ResourceHandle; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.onap.aai.domain.yang.v11.ObjectFactory; +import org.onap.aai.domain.yang.v11.Vnfc; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.NETWORK; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.AbstractManager.buildRelationshipData; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.TestGenericVnfManager.assertRelation; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestVnfcManager extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + private ArgumentCaptor<Vnfc> payload = ArgumentCaptor.forClass(Vnfc.class); + + @Mock + private AAIRestApiProvider aaiRestApiProvider; + private VnfcManager vnfcManager; + + @Before + public void init() { + vnfcManager = new VnfcManager(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + setField(VnfcManager.class, "logger", logger); + } + + /** + * test update + */ + @Test + public void testUpdate() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.setId("vnfcId"); + when(aaiRestApiProvider.get(eq(logger), eq(NETWORK), eq("/vnfcs/vnfc/myVnfId_vnfcId"), eq(Vnfc.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/vnfcs/vnfc/myVnfId_vnfcId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + vnfcManager.update(VIM_ID, "myTenantPrivderId", VNF_ID, affectedVnfc, true); + //verify + Vnfc vnfc = payload.getValue(); + assertEquals("myVnfId_vnfcId", vnfc.getVnfcName()); + assertEquals("vnfcId", vnfc.getNfcFunction()); + assertEquals("vnfcId", vnfc.getNfcNamingCode()); + assertRelation(payload.getValue().getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID)); + + assertRelation(vnfc.getRelationshipList(), "vserver", + buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), + buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID)), + buildRelationshipData("tenant.tenant-id", "myTenantPrivderId"), + buildRelationshipData("vserver.vserver-id", "serverProviderId")); + } + + /** + * test delete + */ + @Test + public void testDelete() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.setId("vnfcId"); + when(aaiRestApiProvider.get(eq(logger), eq(NETWORK), eq("/vnfcs/vnfc/myVnfId_vnfcId"), eq(Vnfc.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/vnfcs/vnfc/myVnfId_vnfcId"), payload.capture(), eq(Void.class))).thenReturn(null); + //when + vnfcManager.delete(VNF_ID, affectedVnfc); + //verify + aaiRestApiProvider.delete(logger, NETWORK, "/vnfcs/vnfc/myVnfId_vnfcId"); + } + + /** + * test inheritence + */ + @Test + public void testInheritence() { + assertEquals(logger, vnfcManager.getLogger()); + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestVserverManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestVserverManager.java new file mode 100644 index 00000000..bb5d1d3d --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/direct/notification/TestVserverManager.java @@ -0,0 +1,253 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.nokia.cbam.lcm.v32.model.AffectedVirtualStorage; +import com.nokia.cbam.lcm.v32.model.AffectedVnfc; +import com.nokia.cbam.lcm.v32.model.ResourceHandle; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.onap.aai.domain.yang.v11.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.util.ArrayList; +import java.util.List; +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider.AAIService.CLOUD; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.AbstractManager.buildRelationshipData; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.TestGenericVnfManager.assertRelation; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getCloudOwner; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager.getRegionName; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestVserverManager extends TestBase { + private ObjectFactory OBJECT_FACTORY = new ObjectFactory(); + private ArgumentCaptor<Vserver> payload = ArgumentCaptor.forClass(Vserver.class); + + @Mock + private AAIRestApiProvider aaiRestApiProvider; + private VserverManager vserverManager; + + @Before + public void init() { + vserverManager = new VserverManager(aaiRestApiProvider, cbamRestApiProvider, driverProperties); + setField(VserverManager.class, "logger", logger); + } + + /** + * test update + */ + @Test + public void testUpdate() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "serverName"); + additionalData.addProperty("tenantId", "myTenantId"); + JsonArray links = new JsonArray(); + links.add(new JsonObject()); + JsonObject nonRelSelfink = new JsonObject(); + nonRelSelfink.addProperty("rel", "self2"); + nonRelSelfink.addProperty("href", "url"); + links.add(nonRelSelfink); + + JsonObject link = new JsonObject(); + link.addProperty("rel", "self"); + link.addProperty("href", "url"); + links.add(link); + additionalData.add("links", links); + affectedVnfc.getComputeResource().setAdditionalData(additionalData); + affectedVnfc.setId("vnfcId"); + List<AffectedVirtualStorage> affectedStorages = new ArrayList<>(); + affectedStorages.add(new AffectedVirtualStorage()); + affectedStorages.get(0).setId("sId"); + affectedStorages.get(0).setResource(new ResourceHandle()); + affectedStorages.get(0).getResource().setResourceId("storageProviderId"); + affectedVnfc.setStorageResourceIds(new ArrayList<>()); + affectedVnfc.getStorageResourceIds().add("sId"); + + String url = "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId"; + + Vserver existingVserver = OBJECT_FACTORY.createVserver(); + existingVserver.setVolumes(new Volumes()); + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq(url), eq(Vserver.class))).thenReturn(existingVserver); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq(url), payload.capture(), eq(Void.class))).thenReturn(null); + //when + vserverManager.update(VIM_ID, VNF_ID, affectedVnfc, affectedStorages, true); + //verify + Vserver vserver = payload.getValue(); + assertEquals("serverProviderId", vserver.getVserverId()); + assertEquals("active", vserver.getProvStatus()); + assertEquals("serverName", vserver.getVserverName()); + assertEquals("url", vserver.getVserverSelflink()); + assertEquals(1, vserver.getVolumes().getVolume().size()); + assertEquals("storageProviderId", vserver.getVolumes().getVolume().get(0).getVolumeId()); + } + + /** + * test missing links + */ + @Test + public void testUpdateEmptyLinks() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "serverName"); + additionalData.addProperty("tenantId", "myTenantId"); + JsonArray links = new JsonArray(); + additionalData.add("links", links); + affectedVnfc.getComputeResource().setAdditionalData(additionalData); + affectedVnfc.setId("vnfcId"); + List<AffectedVirtualStorage> affectedStorages = new ArrayList<>(); + affectedStorages.add(new AffectedVirtualStorage()); + affectedStorages.get(0).setId("sId"); + affectedStorages.get(0).setResource(new ResourceHandle()); + affectedStorages.get(0).getResource().setResourceId("storageProviderId"); + affectedVnfc.setStorageResourceIds(new ArrayList<>()); + affectedVnfc.getStorageResourceIds().add("sId"); + + String url = "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId"; + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq(url), eq(Vserver.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq(url), payload.capture(), eq(Void.class))).thenReturn(null); + //when + vserverManager.update(VIM_ID, VNF_ID, affectedVnfc, affectedStorages, true); + //verify + Vserver vserver = payload.getValue(); + assertEquals("serverProviderId", vserver.getVserverId()); + assertEquals("active", vserver.getProvStatus()); + assertEquals("serverName", vserver.getVserverName()); + assertEquals("unknown", vserver.getVserverSelflink()); + assertEquals(1, vserver.getVolumes().getVolume().size()); + assertEquals("storageProviderId", vserver.getVolumes().getVolume().get(0).getVolumeId()); + } + + /** + * test update when links is not present on vServer + */ + @Test + public void testUpdateWithNoLinks() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "serverName"); + additionalData.addProperty("tenantId", "myTenantId"); + affectedVnfc.getComputeResource().setAdditionalData(additionalData); + affectedVnfc.setId("vnfcId"); + List<AffectedVirtualStorage> affectedStorages = new ArrayList<>(); + affectedStorages.add(new AffectedVirtualStorage()); + affectedStorages.get(0).setId("sId"); + affectedStorages.get(0).setResource(new ResourceHandle()); + affectedStorages.get(0).getResource().setResourceId("storageProviderId"); + affectedVnfc.setStorageResourceIds(new ArrayList<>()); + affectedVnfc.getStorageResourceIds().add("sId"); + + String url = "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId"; + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq(url), eq(Vserver.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq(url), payload.capture(), eq(Void.class))).thenReturn(null); + //when + vserverManager.update(VIM_ID, VNF_ID, affectedVnfc, affectedStorages, true); + //verify + Vserver vserver = payload.getValue(); + assertEquals("serverProviderId", vserver.getVserverId()); + assertEquals("active", vserver.getProvStatus()); + assertEquals("serverName", vserver.getVserverName()); + assertEquals("unknown", vserver.getVserverSelflink()); + assertEquals(1, vserver.getVolumes().getVolume().size()); + assertEquals("storageProviderId", vserver.getVolumes().getVolume().get(0).getVolumeId()); + } + + /** + * test update when removing volumes + */ + @Test + public void testUpdateWithRemovingVolumes() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "serverName"); + additionalData.addProperty("tenantId", "myTenantId"); + affectedVnfc.getComputeResource().setAdditionalData(additionalData); + affectedVnfc.setId("vnfcId"); + List<AffectedVirtualStorage> affectedStorages = new ArrayList<>(); + String url = "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId"; + when(aaiRestApiProvider.get(eq(logger), eq(CLOUD), eq(url), eq(Vserver.class))).thenThrow(new NoSuchElementException()); + when(aaiRestApiProvider.put(eq(logger), eq(CLOUD), eq(url), payload.capture(), eq(Void.class))).thenReturn(null); + //when + vserverManager.update(VIM_ID, VNF_ID, affectedVnfc, affectedStorages, true); + //verify + Vserver vserver = payload.getValue(); + assertEquals("serverProviderId", vserver.getVserverId()); + assertEquals("active", vserver.getProvStatus()); + assertEquals("serverName", vserver.getVserverName()); + assertEquals("unknown", vserver.getVserverSelflink()); + assertEquals(0, vserver.getVolumes().getVolume().size()); + } + + /** + * test delete + */ + @Test + public void testDelete() throws Exception { + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + JsonObject additionalData = new JsonObject(); + additionalData.addProperty("name", "serverName"); + additionalData.addProperty("tenantId", "myTenantId"); + affectedVnfc.getComputeResource().setAdditionalData(additionalData); + affectedVnfc.setId("vnfcId"); + //when + vserverManager.delete(VIM_ID, affectedVnfc); + //verify + String url = "/cloud-regions/cloud-region/myCloudOwnerId/myRegionName/tenants/tenant/myTenantId/vservers/vserver/serverProviderId"; + aaiRestApiProvider.delete(logger, CLOUD, url); + } + + @Test + public void testLinks() { + Relationship relationship = VserverManager.linkTo(VIM_ID, "myTenantPrivderId", "serverProviderId"); + RelationshipList relationships = new RelationshipList(); + relationships.getRelationship().add(relationship); + assertRelation(relationships, "vserver", + buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), + buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID)), + buildRelationshipData("tenant.tenant-id", "myTenantPrivderId"), + buildRelationshipData("vserver.vserver-id", "serverProviderId")); + } + + /** + * test inheritence + */ + @Test + public void testInheritence() { + assertEquals(logger, vserverManager.getLogger()); + } + + +} diff --git a/nokiav2/driver/src/test/resources/application-direct.properties b/nokiav2/driver/src/test/resources/application-direct.properties new file mode 100644 index 00000000..f933db94 --- /dev/null +++ b/nokiav2/driver/src/test/resources/application-direct.properties @@ -0,0 +1,73 @@ +############################################################################### +# Copyright 2016, Nokia Corporation +# +# 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. +# See the License for the specific language governing permissions and +# limitations under the License. +############################################################################### +server.error.whitelabel.enabled=false +############################################################################### +# Beginning of mandatory properties # +############################################################################### +# The TCP port of the server +server.port=8089 +# the base path of the server +server.context-path= +# the IP address to which the server binds to +server.address=127.0.0.1 +# the IP address of the server reported to the micro service bus +driverMsbExternalIp=10.41.63.151 +# the IP address of the server reported to the VNFM +driverVnfmExternalIp=10.41.63.151 +# the IP address of the message bus +messageBusIp=msb.api.simpledemo.onap.org +# the TCP port of the message bus +messageBusPort=80 +# the URL of the CBAM catalog service +cbamCatalogUrl=https://10.41.63.149:443/api/catalog/adapter +# the URL of the CBAM LCN service +cbamLcnUrl=https://10.41.63.149:443/vnfm/lcn/v3 +# the URL of the CBAM authentication service +cbamKeyCloakBaseUrl=https://10.41.63.149:443/auth +# skip hostname verification during SSL on CBAM LCN, LCM and authorization interface +skipHostnameVerification=true +# skip certificate verification during SSL on CBAM LCN, LCM and authorization interface +skipCertificateVerification=true +# the collection of trusted certificates for SSL on CBAM LCN, LCM and authorization interface +# in PEM format encoded in BASE64 to a single line +trustedCertificates= +# the username to be used for requesting a token on CBAM authorization interface +cbamUsername=onap +# the password to be used for requesting a token on CBAM authorization interface +cbamPassword=Admin@123 +# the identifier of the VNFM in A&AI core system registry +vnfmId=7c267318-2a6a-4d47-b039-a7cce5fea38b +aaiUsername=AAI +aaiPassword=AAI +sdcUsername=SDC +sdcPassword=SDC + +############################################################################### +# End of mandatory properties for driver # +############################################################################### +ipMap=10.0.14.1->msb.api.simpledemo.onap.org,172.17.0.15->msb.api.simpledemo.onap.org,10.0.1.1->aai.api.simpledemo.onap.org +vnfmInfoCacheEvictionInMs=600000 + +## for logging begin ## +com.fasterxml.jackson.core=jackson-databind +#logging.file=${catalina.base}/logs/vfcadaptor.log +logging.level.org.springframework=INFO +logging.level.org.hibernate=OFF +logging.level.org.springframework.web=DEBUG +## for logging end ## + +spring.http.multipart.max-file-size=50000KB +spring.http.multipart.max-request-size=50000KB |