diff options
Diffstat (limited to 'adapters/mso-vnf-adapter/src')
19 files changed, 5553 insertions, 0 deletions
diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/BpelRestClient.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/BpelRestClient.java new file mode 100644 index 0000000000..e76aa40304 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/BpelRestClient.java @@ -0,0 +1,304 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import java.io.IOException; +import java.util.Set; +import java.util.TreeSet; + +import javax.xml.bind.DatatypeConverter; + +import org.apache.http.HttpEntity; +import org.apache.http.client.config.RequestConfig; +import org.apache.http.client.methods.CloseableHttpResponse; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.entity.ContentType; +import org.apache.http.entity.StringEntity; +import org.apache.http.impl.client.CloseableHttpClient; +import org.apache.http.impl.client.HttpClients; +import org.apache.http.util.EntityUtils; + +import org.openecomp.mso.logger.MessageEnum; +import org.openecomp.mso.logger.MsoLogger; +import org.openecomp.mso.properties.MsoJavaProperties; +import org.openecomp.mso.properties.MsoPropertiesException; +import org.openecomp.mso.properties.MsoPropertiesFactory; + +/** + * This is the class that is used to POST replies from the MSO adapters to the BPEL engine. + * It can be configured via property file, or modified using the member methods. + * The properties to use are: + * org.openecomp.mso.adapters.vnf.bpelauth encrypted authorization string to send to BEPL engine + * org.openecomp.mso.adapters.vnf.sockettimeout socket timeout value + * org.openecomp.mso.adapters.vnf.connecttimeout connect timeout value + * org.openecomp.mso.adapters.vnf.retrycount number of times to retry failed connections + * org.openecomp.mso.adapters.vnf.retryinterval interval (in seconds) between retries + * org.openecomp.mso.adapters.vnf.retrylist list of response codes that will trigger a retry (the special code + * 900 means "connection was not established") + */ +public class BpelRestClient { + public static final String MSO_PROP_VNF_ADAPTER = "MSO_PROP_VNF_ADAPTER"; + private static final String PROPERTY_DOMAIN = "org.openecomp.mso.adapters.vnf"; + private static final String BPEL_AUTH_PROPERTY = PROPERTY_DOMAIN+".bpelauth"; + private static final String SOCKET_TIMEOUT_PROPERTY = PROPERTY_DOMAIN+".sockettimeout"; + private static final String CONN_TIMEOUT_PROPERTY = PROPERTY_DOMAIN+".connecttimeout"; + private static final String RETRY_COUNT_PROPERTY = PROPERTY_DOMAIN+".retrycount"; + private static final String RETRY_INTERVAL_PROPERTY = PROPERTY_DOMAIN+".retryinterval"; + private static final String RETRY_LIST_PROPERTY = PROPERTY_DOMAIN+".retrylist"; + private static final String ENCRYPTION_KEY = "aa3871669d893c7fb8abbcda31b88b4f"; + private static final MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA); + + /** Default socket timeout (in seconds) */ + public static final int DEFAULT_SOCKET_TIMEOUT = 5; + /** Default connect timeout (in seconds) */ + public static final int DEFAULT_CONNECT_TIMEOUT = 5; + /** By default, retry up to five times */ + public static final int DEFAULT_RETRY_COUNT = 5; + /** Default interval to wait between retries (in seconds), negative means use backoff algorithm */ + public static final int DEFAULT_RETRY_INTERVAL = -15; + /** Default list of response codes to trigger a retry */ + public static final String DEFAULT_RETRY_LIST = "408,429,500,502,503,504,900"; // 900 is "connection failed" + /** Default credentials */ + public static final String DEFAULT_CREDENTIALS = ""; + + // Properties of the BPEL client -- all are configurable + private int socketTimeout; + private int connectTimeout; + private int retryCount; + private int retryInterval; + private Set<Integer> retryList; + private String credentials; + + // last response from BPEL engine + private int lastResponseCode; + private String lastResponse; + + /** + * Create a client to send results to the BPEL engine, using configuration from the + * MSO_PROP_VNF_ADAPTER properties. + */ + public BpelRestClient() { + socketTimeout = DEFAULT_SOCKET_TIMEOUT; + connectTimeout = DEFAULT_CONNECT_TIMEOUT; + retryCount = DEFAULT_RETRY_COUNT; + retryInterval = DEFAULT_RETRY_INTERVAL; + setRetryList(DEFAULT_RETRY_LIST); + credentials = DEFAULT_CREDENTIALS; + lastResponseCode = 0; + lastResponse = ""; + + try { + MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory(); + MsoJavaProperties jp = msoPropertiesFactory.getMsoJavaProperties (MSO_PROP_VNF_ADAPTER); + socketTimeout = jp.getIntProperty(SOCKET_TIMEOUT_PROPERTY, DEFAULT_SOCKET_TIMEOUT); + connectTimeout = jp.getIntProperty(CONN_TIMEOUT_PROPERTY, DEFAULT_CONNECT_TIMEOUT); + retryCount = jp.getIntProperty(RETRY_COUNT_PROPERTY, DEFAULT_RETRY_COUNT); + retryInterval = jp.getIntProperty(RETRY_INTERVAL_PROPERTY, DEFAULT_RETRY_INTERVAL); + setRetryList(jp.getProperty(RETRY_LIST_PROPERTY, DEFAULT_RETRY_LIST)); + credentials = jp.getEncryptedProperty(BPEL_AUTH_PROPERTY, DEFAULT_CREDENTIALS, ENCRYPTION_KEY); + } catch (MsoPropertiesException e) { + String error = "Unable to get properties:" + MSO_PROP_VNF_ADAPTER; + LOGGER.error (MessageEnum.RA_CONFIG_EXC, error, "Camunda", "", MsoLogger.ErrorCode.AvailabilityError, "MsoPropertiesException - Unable to get properties", e); + } + } + + public int getSocketTimeout() { + return socketTimeout; + } + + public void setSocketTimeout(int socketTimeout) { + this.socketTimeout = socketTimeout; + } + + public int getConnectTimeout() { + return connectTimeout; + } + + public void setConnectTimeout(int connectTimeout) { + this.connectTimeout = connectTimeout; + } + + public int getRetryCount() { + return retryCount; + } + + public void setRetryCount(int retryCount) { + if (retryCount < 0) + retryCount = DEFAULT_RETRY_COUNT; + this.retryCount = retryCount; + } + + public int getRetryInterval() { + return retryInterval; + } + + public void setRetryInterval(int retryInterval) { + this.retryInterval = retryInterval; + } + + public String getCredentials() { + return credentials; + } + + public void setCredentials(String credentials) { + this.credentials = credentials; + } + + public String getRetryList() { + if (retryList.size() == 0) + return ""; + String t = retryList.toString(); + return t.substring(1, t.length()-1); + } + + public void setRetryList(String retryList) { + Set<Integer> s = new TreeSet<Integer>(); + for (String t : retryList.split("[, ]")) { + try { + s.add(Integer.parseInt(t)); + } catch (NumberFormatException x) { + // ignore + } + } + this.retryList = s; + } + + public int getLastResponseCode() { + return lastResponseCode; + } + + public String getLastResponse() { + return lastResponse; + } + + /** + * Post a response to the URL of the BPEL engine. As long as the response code is one of those in + * the retryList, the post will be retried up to "retrycount" times with an interval (in seconds) + * of "retryInterval". If retryInterval is negative, then each successive retry interval will be + * double the previous one. + * @param toBpelStr the content (XML or JSON) to post + * @param bpelUrl the URL to post to + * @param isxml true if the content is XML, otherwise assumed to be JSON + * @return true if the post succeeded, false if all retries failed + */ + public boolean bpelPost(final String toBpelStr, final String bpelUrl, final boolean isxml) { + debug("Sending response to BPEL: " + toBpelStr); + int totalretries = 0; + int retryint = retryInterval; + while (true) { + sendOne(toBpelStr, bpelUrl, isxml); + // Note: really should handle response code 415 by switching between content types if needed + if (!retryList.contains(lastResponseCode)) { + debug("Got response code: " + lastResponseCode + ": returning."); + return true; + } + if (totalretries >= retryCount) { + debug("Retried " + totalretries + " times, giving up."); + LOGGER.error(MessageEnum.RA_SEND_VNF_NOTIF_ERR, "Could not deliver response to BPEL after "+totalretries+" tries: "+toBpelStr, "Camunda", "", MsoLogger.ErrorCode.BusinessProcesssError, "Could not deliver response to BPEL"); + return false; + } + totalretries++; + int sleepinterval = retryint; + if (retryint < 0) { + // if retry interval is negative double the retry on each pass + sleepinterval = -retryint; + retryint *= 2; + } + debug("Sleeping for " + sleepinterval + " seconds."); + try { + Thread.sleep(sleepinterval * 1000L); + } catch (InterruptedException e) { + // ignore + } + } + } + private void debug(String m) { + LOGGER.debug(m); +// System.err.println(m); + } + private void sendOne(final String toBpelStr, final String bpelUrl, final boolean isxml) { + LOGGER.debug("Sending to BPEL server: "+bpelUrl); + LOGGER.debug("Content is: "+toBpelStr); + + //POST + HttpPost post = new HttpPost(bpelUrl); + if (credentials != null && !credentials.isEmpty()) + post.addHeader("Authorization", "Basic " + DatatypeConverter.printBase64Binary(credentials.getBytes())); + + //ContentType + ContentType ctype = isxml ? ContentType.APPLICATION_XML : ContentType.APPLICATION_JSON; + post.setEntity(new StringEntity(toBpelStr, ctype)); + + //Timeouts + RequestConfig requestConfig = RequestConfig + .custom() + .setSocketTimeout(socketTimeout * 1000) + .setConnectTimeout(connectTimeout * 1000) + .build(); + post.setConfig(requestConfig); + + //Client 4.3+ + //Execute & GetResponse + try (CloseableHttpClient client = HttpClients.createDefault(); + CloseableHttpResponse response = client.execute(post)) { + if (response != null) { + lastResponseCode = response.getStatusLine().getStatusCode(); + HttpEntity entity = response.getEntity(); + lastResponse = (entity != null) ? EntityUtils.toString(entity) : ""; + } else { + lastResponseCode = 900; + lastResponse = ""; + } + } catch (Exception e) { + String error = "Error sending Bpel notification:" + toBpelStr; + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, error, "Camunda", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - Error sending Bpel notification", e); + lastResponseCode = 900; + lastResponse = ""; + } + LOGGER.debug("Response code from BPEL server: "+lastResponseCode); + LOGGER.debug("Response body is: "+lastResponse); + } + + public static void main(String[] a) throws MsoPropertiesException { + final String bpelengine = "http://mtmac1.research.att.com:8080/catch.jsp"; + final String propfile = "/tmp/mso.vnf.properties"; + // "/Users/eby/src/mso.rest/mso/packages/mso-config-centralized/mso-po-adapter-config/mso.vnf.properties" + final String xml = + "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" + + "<updateVolumeGroupResponse><volumeGroupId>1464013300723</volumeGroupId><volumeGroupOutputs>" + + "<entry><key>clyde</key><value>10</value></entry>" + + "<entry><key>wayne</key><value>99</value></entry>" + + "<entry><key>mickey</key><value>7</value></entry>" + + "</volumeGroupOutputs></updateVolumeGroupResponse>"; + + MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory(); + msoPropertiesFactory.initializeMsoProperties (MSO_PROP_VNF_ADAPTER, propfile); + + BpelRestClient bc = new BpelRestClient(); + System.out.println(bc.getRetryList()); + System.out.println(bc.getCredentials()); // poAvos:Domain2.0! + + bc.bpelPost(xml, bpelengine, true); + System.out.println("respcode = "+bc.getLastResponseCode()); + System.out.println("resp = "+bc.getLastResponse()); + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/HealthCheckHandler.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/HealthCheckHandler.java new file mode 100644 index 0000000000..108baf3444 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/HealthCheckHandler.java @@ -0,0 +1,66 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import javax.ws.rs.GET; +import javax.ws.rs.HEAD; +import javax.ws.rs.Path; +import javax.ws.rs.Produces; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; + +import org.openecomp.mso.logger.MsoLogger; +import org.openecomp.mso.HealthCheckUtils; +import org.openecomp.mso.utils.UUIDChecker; + + +@Path("/") +public class HealthCheckHandler { + + private static MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.RA); + private static final String MSO_PROP_VNF_ADAPTER = "MSO_PROP_VNF_ADAPTER"; + + @HEAD + @GET + @Path("/healthcheck") + @Produces(MediaType.TEXT_HTML) + public Response healthcheck (@QueryParam("requestId") String requestId) { + long startTime = System.currentTimeMillis (); + MsoLogger.setServiceName ("Healthcheck"); + UUIDChecker.verifyOldUUID(requestId, msoLogger); + HealthCheckUtils healthCheck = new HealthCheckUtils (); + if (!healthCheck.siteStatusCheck(msoLogger, startTime)) { + return HealthCheckUtils.HEALTH_CHECK_NOK_RESPONSE; + } + + if (!healthCheck.configFileCheck(msoLogger, startTime, MSO_PROP_VNF_ADAPTER)) { + return HealthCheckUtils.NOT_STARTED_RESPONSE; + } + + if (!healthCheck.catalogDBCheck (msoLogger, startTime)) { + return HealthCheckUtils.NOT_STARTED_RESPONSE; + } + msoLogger.debug("healthcheck - Successful"); + return HealthCheckUtils.HEALTH_CHECK_RESPONSE; + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapter.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapter.java new file mode 100644 index 0000000000..95d8ee23a0 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapter.java @@ -0,0 +1,142 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import javax.jws.WebMethod; +import javax.jws.WebParam; +import javax.jws.WebParam.Mode; +import javax.jws.WebService; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.ws.Holder; + +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.openstack.beans.VnfRollback; +import org.openecomp.mso.adapters.vnf.exceptions.VnfAlreadyExists; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; +import org.openecomp.mso.entity.MsoRequest; + +import java.util.Map; + +@WebService (name="VnfAdapter", targetNamespace="http://com.att.mso/vnf") +public interface MsoVnfAdapter +{ + /** + * This is the "Create VNF" Web Service Endpoint definition. + */ + @WebMethod + public void createVnf (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfType") @XmlElement(required=true) String vnfType, + @WebParam(name="vnfVersion") @XmlElement(required=false) String vnfVersion, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="requestType") @XmlElement(required=false) String requestType, + @WebParam(name="volumeGroupHeatStackId") @XmlElement(required=false) String volumeGroupHeatStackId, + @WebParam(name="inputs") Map<String,String> inputs, + @WebParam(name="failIfExists") Boolean failIfExists, + @WebParam(name="backout") Boolean backout, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="vnfId", mode=Mode.OUT) Holder<String> vnfId, + @WebParam(name="outputs", mode=Mode.OUT) Holder<Map<String,String>> outputs, + @WebParam(name="rollback", mode=Mode.OUT) Holder<VnfRollback> rollback ) + throws VnfException, VnfAlreadyExists; + + @WebMethod + public void updateVnf (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfType") @XmlElement(required=true) String vnfType, + @WebParam(name="vnfVersion") @XmlElement(required=false) String vnfVersion, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="requestType") @XmlElement(required=false) String requestType, + @WebParam(name="volumeGroupHeatStackId") @XmlElement(required=false) String volumeGroupHeatStackId, + @WebParam(name="inputs") Map<String,String> inputs, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="outputs", mode=Mode.OUT) Holder<Map<String,String>> outputs, + @WebParam(name="rollback", mode=Mode.OUT) Holder<VnfRollback> rollback ) + throws VnfException; + + @WebMethod + public void queryVnf (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="vnfExists", mode=Mode.OUT) Holder<Boolean> vnfExists, + @WebParam(name="vnfId", mode=Mode.OUT) Holder<String> vnfId, + @WebParam(name="status", mode=Mode.OUT) Holder<VnfStatus> status, + @WebParam(name="outputs", mode=Mode.OUT) Holder<Map<String,String>> outputs ) + throws VnfException; + + @WebMethod + public void deleteVnf (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="request") MsoRequest msoRequest) + throws VnfException; + + + @WebMethod + public void rollbackVnf (@WebParam(name="rollback") @XmlElement(required=true) VnfRollback rollback) + throws VnfException; + + @WebMethod + public void createVfModule (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfType") @XmlElement(required=true) String vnfType, + @WebParam(name="vnfVersion") @XmlElement(required=false) String vnfVersion, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="requestType") @XmlElement(required=false) String requestType, + @WebParam(name="volumeGroupHeatStackId") @XmlElement(required=false) String volumeGroupHeatStackId, + @WebParam(name="baseVfHeatStackId") @XmlElement(required=false) String baseVfHeatStackId, + @WebParam(name="inputs") Map<String,String> inputs, + @WebParam(name="failIfExists") Boolean failIfExists, + @WebParam(name="backout") Boolean backout, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="vnfId", mode=Mode.OUT) Holder<String> vnfId, + @WebParam(name="outputs", mode=Mode.OUT) Holder<Map<String,String>> outputs, + @WebParam(name="rollback", mode=Mode.OUT) Holder<VnfRollback> rollback ) + throws VnfException, VnfAlreadyExists; + + @WebMethod + public void deleteVfModule (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vfName") @XmlElement(required=true) String vfName, + @WebParam(name="request") MsoRequest msoRequest) + throws VnfException; + + @WebMethod + public void updateVfModule (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfType") @XmlElement(required=true) String vnfType, + @WebParam(name="vnfVersion") @XmlElement(required=false) String vnfVersion, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="requestType") @XmlElement(required=false) String requestType, + @WebParam(name="volumeGroupHeatStackId") @XmlElement(required=false) String volumeGroupHeatStackId, + @WebParam(name="baseVfHeatStackId") @XmlElement(required=false) String baseVfHeatStackId, + @WebParam(name="vfModuleStackId") @XmlElement(required=false) String vfModuleStackId, + @WebParam(name="inputs") Map<String,String> inputs, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="outputs", mode=Mode.OUT) Holder<Map<String,String>> outputs, + @WebParam(name="rollback", mode=Mode.OUT) Holder<VnfRollback> rollback ) + throws VnfException; + + @WebMethod + public void healthCheck (); +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterAsync.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterAsync.java new file mode 100644 index 0000000000..d58e9ee6a8 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterAsync.java @@ -0,0 +1,103 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import javax.jws.Oneway; +import javax.jws.WebMethod; +import javax.jws.WebParam; +import javax.jws.WebService; +import javax.xml.bind.annotation.XmlElement; + +import org.openecomp.mso.entity.MsoRequest; +import org.openecomp.mso.openstack.beans.VnfRollback; +import java.util.Map; + +/** + * This webservice defines the Asynchronous versions of VNF adapter calls. + * The notification messages for final responses are documented elsewhere + * (by the client service WSDL). + * + */ +@WebService (name="VnfAdapterAsync", targetNamespace="http://com.att.mso/vnfA") +public interface MsoVnfAdapterAsync +{ + /** + * This is the "Create VNF" Web Service Endpoint definition. + */ + @WebMethod + @Oneway + public void createVnfA (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfType") @XmlElement(required=true) String vnfType, + @WebParam(name="vnfVersion") @XmlElement(required=false) String vnfVersion, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="requestType") @XmlElement(required=false) String requestType, + @WebParam(name="volumeGroupHeatStackId") @XmlElement(required=false) String volumeGroupHeatStackId, + @WebParam(name="inputs") Map<String,String> inputs, + @WebParam(name="failIfExists") Boolean failIfExists, + @WebParam(name="backout") Boolean backout, + @WebParam(name="messageId") @XmlElement(required=true) String messageId, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="notificationUrl") @XmlElement(required=true) String notificationUrl ); + + @WebMethod + @Oneway + public void updateVnfA (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfType") @XmlElement(required=true) String vnfType, + @WebParam(name="vnfVersion") @XmlElement(required=false) String vnfVersion, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="requestType") @XmlElement(required=false) String requestType, + @WebParam(name="volumeGroupHeatStackId") @XmlElement(required=false) String volumeGroupHeatStackId, + @WebParam(name="inputs") Map<String,String> inputs, + @WebParam(name="messageId") @XmlElement(required=true) String messageId, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="notificationUrl") @XmlElement(required=true) String notificationUrl ); + + @WebMethod + @Oneway + public void queryVnfA (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="messageId") @XmlElement(required=true) String messageId, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="notificationUrl") @XmlElement(required=true) String notificationUrl ); + + @WebMethod + @Oneway + public void deleteVnfA (@WebParam(name="cloudSiteId") @XmlElement(required=true) String cloudSiteId, + @WebParam(name="tenantId") @XmlElement(required=true) String tenantId, + @WebParam(name="vnfName") @XmlElement(required=true) String vnfName, + @WebParam(name="messageId") @XmlElement(required=true) String messageId, + @WebParam(name="request") MsoRequest msoRequest, + @WebParam(name="notificationUrl") @XmlElement(required=true) String notificationUrl ); + + @WebMethod + @Oneway + public void rollbackVnfA (@WebParam(name="rollback") @XmlElement(required=true) VnfRollback rollback, + @WebParam(name="messageId") @XmlElement(required=true) String messageId, + @WebParam(name="notificationUrl") @XmlElement(required=true) String notificationUrl ); + + + @WebMethod + public void healthCheckA (); +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterAsyncImpl.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterAsyncImpl.java new file mode 100644 index 0000000000..c192eb6063 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterAsyncImpl.java @@ -0,0 +1,652 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import java.net.MalformedURLException; +import java.net.URL; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.jws.WebService; +import javax.xml.bind.DatatypeConverter; +import javax.xml.namespace.QName; +import javax.xml.ws.BindingProvider; +import javax.xml.ws.Holder; +import javax.xml.ws.handler.MessageContext; + +import org.openecomp.mso.adapters.vnf.async.client.CreateVnfNotification; +import org.openecomp.mso.adapters.vnf.async.client.QueryVnfNotification; +import org.openecomp.mso.adapters.vnf.async.client.UpdateVnfNotification; +import org.openecomp.mso.adapters.vnf.async.client.VnfAdapterNotify; +import org.openecomp.mso.adapters.vnf.async.client.VnfAdapterNotify_Service; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; +import org.openecomp.mso.cloud.CloudConfigFactory; +import org.openecomp.mso.entity.MsoRequest; +import org.openecomp.mso.logger.MessageEnum; +import org.openecomp.mso.logger.MsoAlarmLogger; +import org.openecomp.mso.logger.MsoLogger; +import org.openecomp.mso.properties.MsoPropertiesFactory; +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.openstack.beans.VnfRollback; + +@WebService(serviceName = "VnfAdapterAsync", endpointInterface = "org.openecomp.mso.adapters.vnf.MsoVnfAdapterAsync", targetNamespace = "http://com.att.mso/vnfA") +public class MsoVnfAdapterAsyncImpl implements MsoVnfAdapterAsync { + + MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory(); + + CloudConfigFactory cloudConfigFactory=new CloudConfigFactory(); + + public static final String MSO_PROP_VNF_ADAPTER="MSO_PROP_VNF_ADAPTER"; + private static MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA); + private static MsoAlarmLogger alarmLogger = new MsoAlarmLogger (); + private static final String BPEL_AUTH_PROP = "org.openecomp.mso.adapters.vnf.bpelauth"; + private static final String ENCRYPTION_KEY = "aa3871669d893c7fb8abbcda31b88b4f"; + + /** + * Health Check web method. Does nothing but return to show the adapter is deployed. + */ + @Override + public void healthCheckA () { + LOGGER.debug ("Health check call in VNF Adapter"); + } + + /** + * This is the asynchronous "Create VNF" web service implementation. + * It will create a new VNF of the requested type in the specified cloud + * and tenant. The tenant must exist before this service is called. + * + * If a VNF with the same name already exists, this can be considered a + * success or failure, depending on the value of the 'failIfExists' parameter. + * + * All VNF types will be defined in the MSO catalog. The caller must request + * one of these pre-defined types or an error will be returned. Within the + * catalog, each VNF type references (among other things) a Heat template + * which is used to deploy the required VNF artifacts (VMs, networks, etc.) + * to the cloud. + * + * Depending on the Heat template, a variable set of input parameters will + * be defined, some of which are required. The caller is responsible to + * pass the necessary input data for the VNF or an error will be thrown. + * + * The method sends an asynchronous response to the notification URL when + * processing completes. The createAsyncResponse contains the vnfId (the + * canonical name of the stack), a Map of VNF output attributes, and a + * VnfRollback object. This last object can be passed as-is to the + * rollbackVnf operation to undo everything that was created for the VNF. + * This is useful if a VNF is successfully created but the orchestrator + * fails on a subsequent operation. + * + * Note: this method is implemented by calling the synchronous web method + * and translating the response to an asynchronous notification. + * + * @param cloudSiteId CLLI code of the cloud site in which to create the VNF + * @param tenantId Openstack tenant identifier + * @param vnfType VNF type key, should match a VNF definition in catalog DB + * @param vnfName Name to be assigned to the new VNF + * @param inputs Map of key=value inputs for VNF stack creation + * @param failIfExists Flag whether already existing VNF should be considered + * a success or failure + * @param msoRequest Request tracking information for logs + * @param notificationURL the target URL for asynchronous response + */ + @Override + public void createVnfA (String cloudSiteId, + String tenantId, + String vnfType, + String vnfVersion, + String vnfName, + String requestType, + String volumeGroupHeatStackId, + Map <String, String> inputs, + Boolean failIfExists, + Boolean backout, + String messageId, + MsoRequest msoRequest, + String notificationUrl) { + String error; + String serviceName = "CreateVnfA"; + MsoLogger.setLogContext (msoRequest); + MsoLogger.setServiceName (serviceName); + LOGGER.info (MessageEnum.RA_ASYNC_CREATE_VNF, vnfName, vnfType, cloudSiteId, tenantId, "", "createVnfA"); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + // Use the synchronous method to perform the actual Create + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory, cloudConfigFactory); + + // Synchronous Web Service Outputs + Holder <String> vnfId = new Holder <String> (); + Holder <Map <String, String>> outputs = new Holder <Map <String, String>> (); + Holder <VnfRollback> vnfRollback = new Holder <VnfRollback> (); + + try { + vnfAdapter.createVnf (cloudSiteId, + tenantId, + vnfType, + vnfVersion, + vnfName, + requestType, + volumeGroupHeatStackId, + inputs, + failIfExists, + backout, + msoRequest, + vnfId, + outputs, + vnfRollback); + MsoLogger.setServiceName (serviceName); + } catch (VnfException e) { + MsoLogger.setServiceName (serviceName); + LOGGER.error (MessageEnum.RA_CREATE_VNF_ERR, vnfName, cloudSiteId, tenantId, "", "createVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "VnfException in createVnfA", e); + org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory exCat = null; + String eMsg = null; + try { + eMsg = e.getFaultInfo ().getMessage (); + exCat = org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory.fromValue (e.getFaultInfo () + .getCategory () + .name ()); + } catch (Exception e1) { + LOGGER.error (MessageEnum.RA_FAULT_INFO_EXC, "", "createVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - Fault info", e1); + } + // Build and send Asynchronous error response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.createVnfNotification (messageId, false, exCat, eMsg, null, null, null); + } catch (Exception e1) { + error = "Error sending createVnf notification " + e1.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "createVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending createVnf notification", e1); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_CREATE_VNF_COMPLETE, "", "createVnfA", "", "createVnfA"); + return; + } + LOGGER.debug ("Async Create VNF: " + vnfName + " VnfId:" + vnfId.value); + // Build and send Asynchronous response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.createVnfNotification (messageId, + true, + null, + null, + vnfId.value, + copyCreateOutputs (outputs), + copyVrb (vnfRollback)); + } catch (Exception e) { + error = "Error sending createVnf notification " + e.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "createVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending createVnf notification", e); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_CREATE_VNF_COMPLETE, "", "createVnfA"); + return; + } + + @Override + public void updateVnfA (String cloudSiteId, + String tenantId, + String vnfType, + String vnfVersion, + String vnfName, + String requestType, + String volumeGroupHeatStackId, + Map <String, String> inputs, + String messageId, + MsoRequest msoRequest, + String notificationUrl) { + String error; + String serviceName = "UpdateVnfA"; + MsoLogger.setServiceName (serviceName); + MsoLogger.setLogContext (msoRequest); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + LOGGER.info (MessageEnum.RA_ASYNC_UPDATE_VNF, vnfName, vnfType, cloudSiteId, tenantId, "", "UpdateVnfA"); + + // Use the synchronous method to perform the actual Create + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory,cloudConfigFactory); + + // Synchronous Web Service Outputs + Holder <String> vnfId = new Holder <String> (); + Holder <Map <String, String>> outputs = new Holder <Map <String, String>> (); + Holder <VnfRollback> vnfRollback = new Holder <VnfRollback> (); + + try { + vnfAdapter.updateVnf (cloudSiteId, tenantId, vnfType,vnfVersion, vnfName, requestType, volumeGroupHeatStackId, inputs, msoRequest, outputs, vnfRollback); + MsoLogger.setServiceName (serviceName); + } catch (VnfException e) { + MsoLogger.setServiceName (serviceName); + LOGGER.error (MessageEnum.RA_UPDATE_VNF_ERR, vnfName, cloudSiteId, tenantId, "", "UpdateVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending updateVnf notification", e); + org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory exCat = null; + String eMsg = null; + try { + eMsg = e.getFaultInfo ().getMessage (); + exCat = org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory.fromValue (e.getFaultInfo () + .getCategory () + .name ()); + } catch (Exception e1) { + LOGGER.error (MessageEnum.RA_FAULT_INFO_EXC, "", "UpdateVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - fault info", e1); + } + // Build and send Asynchronous error response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.updateVnfNotification (messageId, false, exCat, eMsg, null, null); + } catch (Exception e1) { + error = "Error sending updateVnf notification " + e1.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "UpdateVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending updateVnf notification", e1); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_UPDATE_VNF_COMPLETE, "", "UpdateVnfA"); + return; + } + LOGGER.debug ("Async Update VNF: " + vnfName + " VnfId:" + vnfId.value); + // Build and send Asynchronous response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.updateVnfNotification (messageId, + true, + null, + null, + copyUpdateOutputs (outputs), + copyVrb (vnfRollback)); + } catch (Exception e) { + error = "Error sending updateVnf notification " + e.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "UpdateVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending updateVnf notification", e); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_UPDATE_VNF_COMPLETE, "", "UpdateVnfA"); + return; + } + + /** + * This is the "Query VNF" web service implementation. + * It will look up a VNF by name or ID in the specified cloud and tenant. + * + * The method returns an indicator that the VNF exists, its Openstack internal + * ID, its status, and the set of outputs (from when the stack was created). + * + * @param cloudSiteId CLLI code of the cloud site in which to query + * @param tenantId Openstack tenant identifier + * @param vnfName VNF Name or Openstack ID + * @param msoRequest Request tracking information for logs + * @param notificationURL the target URL for asynchronous response + */ + @Override + public void queryVnfA (String cloudSiteId, + String tenantId, + String vnfName, + String messageId, + MsoRequest msoRequest, + String notificationUrl) { + String error; + String serviceName = "QueryVnfA"; + MsoLogger.setServiceName (serviceName); + MsoLogger.setLogContext (msoRequest); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + LOGGER.info (MessageEnum.RA_ASYNC_QUERY_VNF, vnfName, cloudSiteId, tenantId); + + // Use the synchronous method to perform the actual query + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory,cloudConfigFactory); + + // Synchronous Web Service Outputs + Holder <Boolean> vnfExists = new Holder <Boolean> (); + Holder <String> vnfId = new Holder <String> (); + Holder <VnfStatus> status = new Holder <VnfStatus> (); + Holder <Map <String, String>> outputs = new Holder <Map <String, String>> (); + + try { + vnfAdapter.queryVnf (cloudSiteId, tenantId, vnfName, msoRequest, vnfExists, vnfId, status, outputs); + MsoLogger.setServiceName (serviceName); + } catch (VnfException e) { + MsoLogger.setServiceName (serviceName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, "", "queryVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending queryVnfA notification", e); + org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory exCat = null; + String eMsg = null; + try { + eMsg = e.getFaultInfo ().getMessage (); + exCat = org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory.fromValue (e.getFaultInfo () + .getCategory () + .name ()); + } catch (Exception e1) { + LOGGER.error (MessageEnum.RA_FAULT_INFO_EXC, "", "queryVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - fault info", e1); + } + // Build and send Asynchronous error response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.queryVnfNotification (messageId, false, exCat, eMsg, null, null, null, null); + } catch (Exception e1) { + error = "Error sending queryVnf notification " + e1.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "queryVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending queryVnf notification", e1); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_QUERY_VNF_COMPLETE, "", "queryVnfA"); + return; + } + + if (!vnfExists.value) { + LOGGER.debug ("Async Query, VNF not found"); + } else { + LOGGER.debug ("Async Query, VNF=" + vnfId.value + ", status=" + status.value); + } + // Build and send Asynchronous response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + org.openecomp.mso.adapters.vnf.async.client.VnfStatus vnfS = org.openecomp.mso.adapters.vnf.async.client.VnfStatus.fromValue (status.value.name ()); + notifyPort.queryVnfNotification (messageId, + true, + null, + null, + vnfExists.value, + vnfId.value, + vnfS, + copyQueryOutputs (outputs)); + } catch (Exception e) { + error = "Error sending queryVnf notification " + e.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "queryVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending queryVnf notification", e); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + + LOGGER.info (MessageEnum.RA_ASYNC_QUERY_VNF_COMPLETE, "", "queryVnfA"); + return; + } + + /** + * This is the Asynchronous "Delete VNF" web service implementation. + * It will delete a VNF by name or ID in the specified cloud and tenant. + * + * The method has no outputs. + * + * @param cloudSiteId CLLI code of the cloud site in which to delete + * @param tenantId Openstack tenant identifier + * @param vnfName VNF Name or Openstack ID + * @param msoRequest Request tracking information for logs + * @param notificationURL the target URL for asynchronous response + */ + @Override + public void deleteVnfA (String cloudSiteId, + String tenantId, + String vnfName, + String messageId, + MsoRequest msoRequest, + String notificationUrl) { + String error; + String serviceName = "DeleteVnfA"; + MsoLogger.setServiceName (serviceName); + MsoLogger.setLogContext (msoRequest); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + LOGGER.info (MessageEnum.RA_ASYNC_DELETE_VNF, vnfName, cloudSiteId, tenantId); + + // Use the synchronous method to perform the actual delete + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory,cloudConfigFactory); + + try { + vnfAdapter.deleteVnf (cloudSiteId, tenantId, vnfName, msoRequest); + MsoLogger.setServiceName (serviceName); + } catch (VnfException e) { + MsoLogger.setServiceName (serviceName); + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, vnfName, cloudSiteId, tenantId, "", "deleteVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending deleteVnfA notification", e); + org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory exCat = null; + String eMsg = null; + try { + eMsg = e.getFaultInfo ().getMessage (); + exCat = org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory.fromValue (e.getFaultInfo () + .getCategory () + .name ()); + } catch (Exception e1) { + LOGGER.error (MessageEnum.RA_FAULT_INFO_EXC, "", "deleteVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - fault info", e1); + } + // Build and send Asynchronous error response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.deleteVnfNotification (messageId, false, exCat, eMsg); + } catch (Exception e1) { + error = "Error sending deleteVnf notification " + e1.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "deleteVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending deleteVnfA notification", e1); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_DELETE_VNF_COMPLETE, "", "deleteVnfA"); + return; + } + + LOGGER.debug ("Async Delete VNF: " + vnfName); + // Build and send Asynchronous response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.deleteVnfNotification (messageId, true, null, null); + + } catch (Exception e) { + error = "Error sending deleteVnf notification " + e.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "deleteVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending deleteVnfA notification", e); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + + LOGGER.info (MessageEnum.RA_ASYNC_DELETE_VNF_COMPLETE, "", "deleteVnfA"); + return; + } + + /** + * This web service endpoint will rollback a previous Create VNF operation. + * A rollback object is returned to the client in a successful creation + * response. The client can pass that object as-is back to the rollbackVnf + * operation to undo the creation. + */ + @Override + public void rollbackVnfA (VnfRollback rollback, String messageId, String notificationUrl) { + String serviceName = "RollbackVnfA"; + MsoLogger.setServiceName (serviceName); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + String error; + // rollback may be null (e.g. if stack already existed when Create was called) + if (rollback == null) { + error = "Empty Rollback: No action to perform"; + LOGGER.info (MessageEnum.RA_ROLLBACK_NULL, "", "rollbackVnfA"); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + return; + } + + MsoLogger.setLogContext (rollback.getMsoRequest ()); + LOGGER.info (MessageEnum.RA_ASYNC_ROLLBACK_VNF, "", "rollbackVnfA"); + + // Use the synchronous method to perform the actual rollback + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory,cloudConfigFactory); + + try { + vnfAdapter.rollbackVnf (rollback); + MsoLogger.setServiceName (serviceName); + } catch (VnfException e) { + MsoLogger.setServiceName (serviceName); + LOGGER.error (MessageEnum.RA_ROLLBACK_VNF_ERR, "", "rollbackVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending rollbackVnfA notification", e); + org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory exCat = null; + String eMsg = null; + try { + eMsg = e.getFaultInfo ().getMessage (); + exCat = org.openecomp.mso.adapters.vnf.async.client.MsoExceptionCategory.fromValue (e.getFaultInfo () + .getCategory () + .name ()); + } catch (Exception e1) { + LOGGER.error (MessageEnum.RA_FAULT_INFO_EXC, "", "rollbackVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - fault info", e1); + } + // Build and send Asynchronous error response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.rollbackVnfNotification (messageId, false, exCat, eMsg); + } catch (Exception e1) { + error = "Error sending rollbackVnf notification " + e1.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "rollbackVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending rollbackVnfA notification", e1); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + LOGGER.info (MessageEnum.RA_ASYNC_ROLLBACK_VNF_COMPLETE, "", "rollbackVnfA"); + return; + } + + LOGGER.debug ("Async Rollback VNF:" + rollback.getVnfId ()); + // Build and send Asynchronous response + try { + VnfAdapterNotify notifyPort = getNotifyEP (notificationUrl); + notifyPort.rollbackVnfNotification (messageId, true, null, null); + } catch (Exception e) { + error = "Error sending rollbackVnf notification " + e.getMessage (); + LOGGER.error (MessageEnum.RA_SEND_VNF_NOTIF_ERR, "", "rollbackVnfA", MsoLogger.ErrorCode.BusinessProcesssError, "Exception sending rollbackVnfA notification", e); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, error); + } + + LOGGER.info (MessageEnum.RA_ASYNC_ROLLBACK_VNF_COMPLETE, "", "rollbackVnfA"); + return; + } + + private org.openecomp.mso.adapters.vnf.async.client.VnfRollback copyVrb (Holder <VnfRollback> hVrb) { + org.openecomp.mso.adapters.vnf.async.client.VnfRollback cvrb = new org.openecomp.mso.adapters.vnf.async.client.VnfRollback (); + + if (hVrb != null && hVrb.value != null) { + org.openecomp.mso.adapters.vnf.async.client.MsoRequest cmr = new org.openecomp.mso.adapters.vnf.async.client.MsoRequest (); + + cvrb.setCloudSiteId (hVrb.value.getCloudSiteId ()); + if (hVrb.value.getMsoRequest() != null) { + cmr.setRequestId (hVrb.value.getMsoRequest ().getRequestId ()); + cmr.setServiceInstanceId (hVrb.value.getMsoRequest ().getServiceInstanceId ()); + } else { + cmr.setRequestId (null); + cmr.setServiceInstanceId (null); + } + cvrb.setMsoRequest (cmr); + cvrb.setVnfId (hVrb.value.getVnfId ()); + cvrb.setTenantId (hVrb.value.getTenantId ()); + cvrb.setTenantCreated (hVrb.value.getTenantCreated ()); + cvrb.setVnfCreated (hVrb.value.getVnfCreated ()); + } + return cvrb; + } + + private CreateVnfNotification.Outputs copyCreateOutputs (Holder <Map <String, String>> hMap) { + + CreateVnfNotification.Outputs outputs = new CreateVnfNotification.Outputs (); + + if (hMap != null && hMap.value != null) { + Map <String, String> sMap = new HashMap <String, String> (); + sMap = hMap.value; + CreateVnfNotification.Outputs.Entry entry = new CreateVnfNotification.Outputs.Entry (); + + for (String key : sMap.keySet ()) { + entry.setKey (key); + entry.setValue (sMap.get (key)); + outputs.getEntry ().add (entry); + } + } + return outputs; + } + + private UpdateVnfNotification.Outputs copyUpdateOutputs (Holder <Map <String, String>> hMap) { + + UpdateVnfNotification.Outputs outputs = new UpdateVnfNotification.Outputs (); + + if (hMap != null && hMap.value != null) { + Map <String, String> sMap = new HashMap <String, String> (); + sMap = hMap.value; + UpdateVnfNotification.Outputs.Entry entry = new UpdateVnfNotification.Outputs.Entry (); + + for (String key : sMap.keySet ()) { + entry.setKey (key); + entry.setValue (sMap.get (key)); + outputs.getEntry ().add (entry); + } + } + return outputs; + } + + private QueryVnfNotification.Outputs copyQueryOutputs (Holder <Map <String, String>> hMap) { + + QueryVnfNotification.Outputs outputs = new QueryVnfNotification.Outputs (); + + if (hMap != null && hMap.value != null) { + Map <String, String> sMap = new HashMap <String, String> (); + sMap = hMap.value; + + QueryVnfNotification.Outputs.Entry entry = new QueryVnfNotification.Outputs.Entry (); + + for (String key : sMap.keySet ()) { + entry.setKey (key); + entry.setValue (sMap.get (key)); + outputs.getEntry ().add (entry); + } + } + return outputs; + } + + private VnfAdapterNotify getNotifyEP (String notificationUrl) { + + URL warWsdlLoc = null; + try { + warWsdlLoc = Thread.currentThread ().getContextClassLoader ().getResource ("VnfAdapterNotify.wsdl"); + } catch (Exception e) { + LOGGER.error (MessageEnum.RA_WSDL_NOT_FOUND, "VnfAdapterNotify.wsdl", "", "getNotifyEP", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - WSDL not found", e); + } + if (warWsdlLoc == null) { + LOGGER.error (MessageEnum.RA_WSDL_NOT_FOUND, "VnfAdapterNotify.wsdl", "", "getNotifyEP", MsoLogger.ErrorCode.BusinessProcesssError, "WSDL not found"); + } else { + try { + LOGGER.debug ("VnfAdpaterNotify.wsdl location:" + warWsdlLoc.toURI ().toString ()); + } catch (Exception e) { + LOGGER.error (MessageEnum.RA_WSDL_URL_CONVENTION_EXC, "VnfAdapterNotify.wsdl", "", "getNotifyEP", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - WSDL URL convention", e); + } + } + + VnfAdapterNotify_Service notifySvc = new VnfAdapterNotify_Service (warWsdlLoc, + new QName ("http://com.att.mso/vnfNotify", + "vnfAdapterNotify")); + + VnfAdapterNotify notifyPort = notifySvc.getMsoVnfAdapterAsyncImplPort (); + + BindingProvider bp = (BindingProvider) notifyPort; + + URL epUrl = null; + try { + epUrl = new URL (notificationUrl); + } catch (MalformedURLException e1) { + LOGGER.error (MessageEnum.RA_INIT_NOTIF_EXC, "", "getNotifyEP", MsoLogger.ErrorCode.BusinessProcesssError, "MalformedURLException", e1); + } + + LOGGER.debug ("Notification Endpoint URL: " + epUrl.toExternalForm ()); + + bp.getRequestContext ().put (BindingProvider.ENDPOINT_ADDRESS_PROPERTY, epUrl.toExternalForm ()); + + // authentication + try { + Map <String, Object> req_ctx = bp.getRequestContext (); + Map <String, List <String>> headers = new HashMap <String, List <String>> (); + + String userCredentials = msoPropertiesFactory.getMsoJavaProperties (MSO_PROP_VNF_ADAPTER).getEncryptedProperty (BPEL_AUTH_PROP, + "", + ENCRYPTION_KEY); + + String basicAuth = "Basic " + DatatypeConverter.printBase64Binary (userCredentials.getBytes ()); + req_ctx.put (MessageContext.HTTP_REQUEST_HEADERS, headers); + headers.put ("Authorization", Collections.singletonList (basicAuth)); + } catch (Exception e) { + LOGGER.error (MessageEnum.RA_SET_CALLBACK_AUTH_EXC, "", "getNotifyEP", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - Unable to set authorization in callback request", e); + alarmLogger.sendAlarm ("MsoInternalError", MsoAlarmLogger.CRITICAL, "Unable to set authorization in callback request"); + } + + return notifyPort; + } + +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterImpl.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterImpl.java new file mode 100644 index 0000000000..757f875128 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/MsoVnfAdapterImpl.java @@ -0,0 +1,2391 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Scanner; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.jws.WebService; +import javax.xml.ws.Holder; + +import org.openecomp.mso.adapters.vnf.exceptions.VnfAlreadyExists; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; +import org.openecomp.mso.adapters.vnf.exceptions.VnfNotFound; +import org.openecomp.mso.cloud.CloudConfigFactory; +import org.openecomp.mso.cloud.CloudConfig; +import org.openecomp.mso.cloud.CloudSite; +import org.openecomp.mso.db.catalog.utils.MavenLikeVersioning; +import org.openecomp.mso.db.catalog.CatalogDatabase; +import org.openecomp.mso.db.catalog.beans.HeatEnvironment; +import org.openecomp.mso.db.catalog.beans.HeatFiles; +import org.openecomp.mso.db.catalog.beans.HeatTemplate; +import org.openecomp.mso.db.catalog.beans.HeatTemplateParam; +import org.openecomp.mso.db.catalog.beans.VnfResource; +import org.openecomp.mso.db.catalog.beans.VfModule; +import org.openecomp.mso.db.catalog.beans.VnfComponent; +import org.openecomp.mso.entity.MsoRequest; +import org.openecomp.mso.logger.MessageEnum; +import org.openecomp.mso.logger.MsoAlarmLogger; +import org.openecomp.mso.logger.MsoLogger; +import org.openecomp.mso.openstack.beans.HeatStatus; +import org.openecomp.mso.openstack.beans.StackInfo; +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.openstack.beans.VnfRollback; +import org.openecomp.mso.openstack.exceptions.MsoException; +import org.openecomp.mso.openstack.exceptions.MsoExceptionCategory; +import org.openecomp.mso.openstack.utils.MsoHeatUtils; +import org.openecomp.mso.openstack.utils.MsoHeatUtilsWithUpdate; +import org.openecomp.mso.openstack.utils.MsoHeatEnvironmentEntry; +import org.openecomp.mso.properties.MsoPropertiesFactory; + +import org.codehaus.jackson.JsonFactory; +import org.codehaus.jackson.JsonNode; +import org.codehaus.jackson.JsonParser; +import org.codehaus.jackson.JsonParseException; +import org.codehaus.jackson.map.ObjectMapper; + +@WebService(serviceName = "VnfAdapter", endpointInterface = "org.openecomp.mso.adapters.vnf.MsoVnfAdapter", targetNamespace = "http://com.att.mso/vnf") +public class MsoVnfAdapterImpl implements MsoVnfAdapter { + + CloudConfigFactory cloudConfigFactory = new CloudConfigFactory(); + protected CloudConfig cloudConfig = null; + + MsoPropertiesFactory msoPropertiesFactory=new MsoPropertiesFactory(); + + private static final String MSO_PROP_VNF_ADAPTER = "MSO_PROP_VNF_ADAPTER"; + private static final String MSO_CONFIGURATION_ERROR = "MsoConfigurationError"; + private static final String VNF_ADAPTER_SERVICE_NAME = "MSO-BPMN:MSO-VnfAdapter."; + private static final String LOG_REPLY_NAME = "MSO-VnfAdapter:MSO-BPMN."; + private static MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA); + private static MsoAlarmLogger alarmLogger = new MsoAlarmLogger (); + private static final String CHECK_REQD_PARAMS = "org.openecomp.mso.adapters.vnf.checkRequiredParameters"; + private static final String ADD_GET_FILES_ON_VOLUME_REQ = "org.openecomp.mso.adapters.vnf.addGetFilesOnVolumeReq"; + + /** + * Health Check web method. Does nothing but return to show the adapter is deployed. + */ + @Override + public void healthCheck () { + LOGGER.debug ("Health check call in VNF Adapter"); + } + + /** + * DO NOT use that constructor to instantiate this class, the msoPropertiesfactory will be NULL. + * @see MsoVnfAdapterImpl#MsoVnfAdapterImpl(MsoPropertiesFactory, CloudConfigFactory) + */ + public MsoVnfAdapterImpl() { + + } + + /** + * This constructor MUST be used if this class is called with the new operator. + * @param msoPropFactory + */ + public MsoVnfAdapterImpl(MsoPropertiesFactory msoPropFactory, CloudConfigFactory cloudConfigFact) { + this.msoPropertiesFactory = msoPropFactory; + this.cloudConfigFactory = cloudConfigFact; + } + + /** + * This is the "Create VNF" web service implementation. + * It will create a new VNF of the requested type in the specified cloud + * and tenant. The tenant must exist before this service is called. + * + * If a VNF with the same name already exists, this can be considered a + * success or failure, depending on the value of the 'failIfExists' parameter. + * + * All VNF types will be defined in the MSO catalog. The caller must request + * one of these pre-defined types or an error will be returned. Within the + * catalog, each VNF type references (among other things) a Heat template + * which is used to deploy the required VNF artifacts (VMs, networks, etc.) + * to the cloud. + * + * Depending on the Heat template, a variable set of input parameters will + * be defined, some of which are required. The caller is responsible to + * pass the necessary input data for the VNF or an error will be thrown. + * + * The method returns the vnfId (the canonical name), a Map of VNF output + * attributes, and a VnfRollback object. This last object can be passed + * as-is to the rollbackVnf operation to undo everything that was created + * for the VNF. This is useful if a VNF is successfully created but the + * orchestrator fails on a subsequent operation. + * + * @param cloudSiteId CLLI code of the cloud site in which to create the VNF + * @param tenantId Openstack tenant identifier + * @param vnfType VNF type key, should match a VNF definition in catalog DB + * @param vnfVersion VNF version key, should match a VNF definition in catalog DB + * @param vnfName Name to be assigned to the new VNF + * @param inputs Map of key=value inputs for VNF stack creation + * @param failIfExists Flag whether already existing VNF should be considered + * a success or failure + * @param msoRequest Request tracking information for logs + * @param vnfId Holder for output VNF Openstack ID + * @param outputs Holder for Map of VNF outputs from heat (assigned IPs, etc) + * @param rollback Holder for returning VnfRollback object + */ + @Override + public void createVnf (String cloudSiteId, + String tenantId, + String vnfType, + String vnfVersion, + String vnfName, + String requestType, + String volumeGroupHeatStackId, + Map <String, String> inputs, + Boolean failIfExists, + Boolean backout, + MsoRequest msoRequest, + Holder <String> vnfId, + Holder <Map <String, String>> outputs, + Holder <VnfRollback> rollback) throws VnfException { + // Create a hook here to catch shortcut createVf requests: + if (requestType != null) { + if (requestType.startsWith("VFMOD")) { + LOGGER.debug("Calling createVfModule from createVnf -- requestType=" + requestType); + String newRequestType = requestType.substring(5); + String vfVolGroupHeatStackId = ""; + String vfBaseHeatStackId = ""; + try { + if (volumeGroupHeatStackId != null) { + vfVolGroupHeatStackId = volumeGroupHeatStackId.substring(0, volumeGroupHeatStackId.lastIndexOf("|")); + vfBaseHeatStackId = volumeGroupHeatStackId.substring(volumeGroupHeatStackId.lastIndexOf("|")+1); + } + } catch (Exception e) { + // might be ok - both are just blank + LOGGER.debug("ERROR trying to parse the volumeGroupHeatStackId " + volumeGroupHeatStackId); + } + this.createVfModule(cloudSiteId, + tenantId, + vnfType, + vnfVersion, + vnfName, + newRequestType, + vfVolGroupHeatStackId, + vfBaseHeatStackId, + inputs, + failIfExists, + backout, + msoRequest, + vnfId, + outputs, + rollback); + return; + } + } + // createVf will know if the requestType starts with "X" that it's the "old" way + StringBuilder newRequestTypeSb = new StringBuilder("X"); + String vfVolGroupHeatStackId = ""; + String vfBaseHeatStackId = ""; + if (requestType != null) { + newRequestTypeSb.append(requestType); + } + this.createVfModule(cloudSiteId, + tenantId, + vnfType, + vnfVersion, + vnfName, + newRequestTypeSb.toString(), + vfVolGroupHeatStackId, + vfBaseHeatStackId, + inputs, + failIfExists, + backout, + msoRequest, + vnfId, + outputs, + rollback); + return; + // End createVf shortcut + } + + @Override + public void updateVnf (String cloudSiteId, + String tenantId, + String vnfType, + String vnfVersion, + String vnfName, + String requestType, + String volumeGroupHeatStackId, + Map <String, String> inputs, + MsoRequest msoRequest, + Holder <Map <String, String>> outputs, + Holder <VnfRollback> rollback) throws VnfException { + MsoLogger.setLogContext (msoRequest.getRequestId (), msoRequest.getServiceInstanceId ()); + MsoLogger.setServiceName ("UpdateVnf"); + String requestTypeString = ""; + if (requestType != null && !requestType.equals("")) { + requestTypeString = requestType; + } + String nestedStackId = null; + if (volumeGroupHeatStackId != null && !volumeGroupHeatStackId.equals("")) { + nestedStackId = volumeGroupHeatStackId; + } + + LOGGER.debug ("Updating VNF: " + vnfName + " of type " + vnfType + "in " + cloudSiteId + "/" + tenantId); + LOGGER.debug("requestTypeString = " + requestTypeString + ", nestedStackId = " + nestedStackId); + + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + + // Build a default rollback object (no actions performed) + VnfRollback vnfRollback = new VnfRollback (); + vnfRollback.setCloudSiteId (cloudSiteId); + vnfRollback.setTenantId (tenantId); + vnfRollback.setMsoRequest (msoRequest); + vnfRollback.setRequestType(requestTypeString); + + // First, look up to see if the VNF already exists. + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + MsoHeatUtilsWithUpdate heatU = new MsoHeatUtilsWithUpdate (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + StackInfo heatStack = null; + long queryStackStarttime1 = System.currentTimeMillis (); + try { + heatStack = heat.queryStack (cloudSiteId, tenantId, vnfName); + LOGGER.recordMetricEvent (queryStackStarttime1, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "QueryStack", vnfName); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("UpdateVNF"); + String error = "Update VNF: Query " + vnfName + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (queryStackStarttime1, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", vnfName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.BusinessProcesssError, "Exception in updateVnf", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + + if (heatStack == null || heatStack.getStatus () == HeatStatus.NOTFOUND) { + // Not Found + String error = "Update VNF: Stack " + vnfName + " does not exist in " + cloudSiteId + "/" + tenantId; + LOGGER.error (MessageEnum.RA_VNF_NOT_EXIST, vnfName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: Stack " + vnfName + " does not exist"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfNotFound (cloudSiteId, tenantId, vnfName); + } else { + LOGGER.debug ("Found Existing stack, status=" + heatStack.getStatus ()); + // Populate the outputs from the existing stack. + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + rollback.value = vnfRollback; // Default rollback - no updates performed + } + + // 1604 Cinder Volume support - handle a nestedStackId if sent (volumeGroupHeatStackId): + StackInfo nestedHeatStack = null; + long queryStackStarttime2 = System.currentTimeMillis (); + if (nestedStackId != null) { + try { + LOGGER.debug("Querying for nestedStackId = " + nestedStackId); + nestedHeatStack = heat.queryStack(cloudSiteId, tenantId, nestedStackId); + LOGGER.recordMetricEvent (queryStackStarttime2, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "QueryStack", vnfName); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("UpdateVNF"); + String error = "Update VNF: Attached heatStack ID Query " + nestedStackId + " in " + cloudSiteId + "/" + tenantId + ": " + me ; + LOGGER.recordMetricEvent (queryStackStarttime2, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", vnfName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.AvailabilityError, "Exception trying to query nested stack", me); + LOGGER.debug("ERROR trying to query nested stack= " + error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + if (nestedHeatStack == null || nestedHeatStack.getStatus() == HeatStatus.NOTFOUND) { + String error = "Update VNF: Attached heatStack ID DOES NOT EXIST " + nestedStackId + " in " + cloudSiteId + "/" + tenantId + " USER ERROR" ; + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, error, "OpenStack", "QueryStack", MsoLogger.ErrorCode.AvailabilityError, "Attached heatStack ID DOES NOT EXIST"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + LOGGER.debug(error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug("Found nested heat stack - copying values to inputs"); + this.sendMapToDebug(inputs); + heat.copyStringOutputsToInputs(inputs, nestedHeatStack.getOutputs(), false); + this.sendMapToDebug(inputs); + } + } + + // Ready to deploy the new VNF + + try(CatalogDatabase db = new CatalogDatabase ()) { + // Retrieve the VNF definition + VnfResource vnf; + if (vnfVersion != null && !vnfVersion.isEmpty ()) { + vnf = db.getVnfResource (vnfType, vnfVersion); + } else { + vnf = db.getVnfResource (vnfType); + } + if (vnf == null) { + String error = "Update VNF: Unknown VNF Type: " + vnfType; + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "VNF Type", vnfType, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: Unknown VNF Type"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } + LOGGER.debug ("Got VNF definition from Catalog: " + vnf.toString ()); + + // Currently, all VNFs are orchestrated via HEAT + if (!"HEAT".equals (vnf.getOrchestrationMode ())) { + String error = "Update VNF: Configuration error: VNF=" + vnfType; + LOGGER.error (MessageEnum.RA_CONFIG_EXC, " VNF=" + vnfType, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: Configuration error"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.BadRequest, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } + + //1604 - Need to handle an updateVolume request. + VnfComponent vnfComponent = null; + if (requestTypeString != null && !requestTypeString.equals("")) { + LOGGER.debug("About to query for vnfComponent id = " + vnf.getId() + ", type = " + requestTypeString.toUpperCase()); + vnfComponent = db.getVnfComponent(vnf.getId(), requestTypeString.toUpperCase()); + if (vnfComponent == null) { + String error = "Update VNF: Cannot find VNF Component entry for: " + vnfType + ", type = " + requestTypeString.toUpperCase(); + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "VNF Type", vnfType, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: Cannot find VNF Component entry"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } + LOGGER.debug("FOUND VnfComponent: " + vnfComponent.toString()); + } + + HeatTemplate heatTemplate = db.getHeatTemplate (vnf.getTemplateId ()); + if (heatTemplate == null) { + String error = "Update VNF: undefined Heat Template. VNF=" + vnfType; + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Template ID", String.valueOf(vnf.getTemplateId ()), "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: undefined Heat Template"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } + + // If this is a component request - get the template associated for volumes + // May change this - for now get both templates - but volume will be 2nd, which makes sense + // for the rest of the code. Same with envt later + if (vnfComponent != null) { + LOGGER.debug("Querying db to find component template " + vnfComponent.getHeatTemplateId()); + heatTemplate = db.getHeatTemplate(vnfComponent + .getHeatTemplateId()); + if (heatTemplate == null) { + String error = "Update VNF: undefined Heat Template for Volume Component. VNF=" + + vnfType; + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, + "Heat Template ID", + String.valueOf(vnfComponent.getHeatTemplateId()), "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: undefined Heat Template for Volume Component"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + alarmLogger.sendAlarm(MSO_CONFIGURATION_ERROR, + MsoAlarmLogger.CRITICAL, error); + throw new VnfException(error, MsoExceptionCategory.INTERNAL); + } + } + + LOGGER.debug ("Got HEAT Template from DB: " + heatTemplate.toString ()); + + // Add check for any Environment variable + HeatEnvironment heatEnvironment = null; + String heatEnvironmentString = null; + + if (vnf.getEnvironmentId () != null) { + LOGGER.debug ("about to call getHeatEnvironment with :" + vnf.getEnvironmentId () + ":"); + heatEnvironment = db.getHeatEnvironment (vnf.getEnvironmentId ()); + if (heatEnvironment == null) { + + String error = "Create VNF: undefined Heat Environment. VNF=" + vnfType + + ", Environment ID=" + + vnf.getEnvironmentId (); + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Environment ID", String.valueOf(vnf.getEnvironmentId ()), "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Create VNF: undefined Heat Environment"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } else { + LOGGER.debug ("Got Heat Environment from DB: " + heatEnvironment.toString ()); + heatEnvironmentString = heatEnvironment.getEnvironment (); //this.parseEnvironment (heatEnvironment.getEnvironment ()); + LOGGER.debug ("After parsing: " + heatEnvironmentString); + } + } else { + LOGGER.debug ("no environment parameter for this VNF " + vnfType); + } + + //1604 - override the VNF environment with the one for the component + if(vnfComponent != null) { + if (vnfComponent.getHeatEnvironmentId () != null) { + LOGGER.debug ("about to call getHeatEnvironment with :" + vnfComponent.getHeatEnvironmentId () + ":"); + heatEnvironment = db.getHeatEnvironment (vnfComponent.getHeatEnvironmentId ()); + if (heatEnvironment == null) { + String error = "Update VNF: undefined Heat Environment. VNF=" + vnfType + + ", Environment ID=" + + vnfComponent.getHeatEnvironmentId (); + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Environment ID", String.valueOf(vnfComponent.getHeatEnvironmentId ()), "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: undefined Heat Environment"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } else { + LOGGER.debug ("Got Heat Environment from DB: " + heatEnvironment.toString ()); + heatEnvironmentString = heatEnvironment.getEnvironment (); //this.parseEnvironment (heatEnvironment.getEnvironment ()); + LOGGER.debug ("after parsing: " + heatEnvironmentString); + } + } else { + LOGGER.debug ("no environment parameter for this VNF VOLUME component " + vnfType); + } + } + // End 1604 + + + LOGGER.debug ("In MsoVnfAdapterImpl, about to call db.getNestedTemplates avec templateId=" + + heatTemplate.getId ()); + Map <String, Object> nestedTemplates = db.getNestedTemplates (heatTemplate.getId ()); + Map <String, Object> nestedTemplatesChecked = new HashMap <String, Object> (); + if (nestedTemplates != null) { + // for debugging print them out + LOGGER.debug ("Contents of nestedTemplates - to be added to files: on stack:"); + for (String providerResourceFile : nestedTemplates.keySet ()) { + String providerResourceFileChecked = providerResourceFile; //this.enforceFilePrefix (providerResourceFile); + String childTemplateBody = (String) nestedTemplates.get (providerResourceFile); + nestedTemplatesChecked.put (providerResourceFileChecked, childTemplateBody); + LOGGER.debug (providerResourceFileChecked + " -> " + childTemplateBody); + } + } else { + LOGGER.debug ("No nested templates found - nothing to do here"); + nestedTemplatesChecked = null; + } + + // Also add the files: for any get_files associated with this vnf_resource_id + // *if* there are any + LOGGER.debug ("In MsoVnfAdapterImpl.updateVnf, about to call db.getHeatFiles avec vnfResourceId=" + + vnf.getId ()); + Map <String, HeatFiles> heatFiles = db.getHeatFiles (vnf.getId ()); + Map <String, Object> heatFilesObjects = new HashMap <String, Object> (); + if (heatFiles != null) { + // add these to stack - to be done in createStack + // here, we will map them to Map<String, Object> from Map<String, HeatFiles> + // this will match the nested templates format + LOGGER.debug ("Contents of heatFiles - to be added to files: on stack:"); + + for (String heatFileName : heatFiles.keySet ()) { + String heatFileBody = heatFiles.get (heatFileName).getFileBody (); + // Remove the file:/// enforcement for get_file: + //String heatFileNameChecked = this.enforceFilePrefix (heatFileName); + String heatFileNameChecked = heatFileName; + LOGGER.debug (heatFileNameChecked + " -> " + heatFileBody); + heatFilesObjects.put (heatFileNameChecked, heatFileBody); + } + } else { + LOGGER.debug ("No heat files found -nothing to do here"); + heatFilesObjects = null; + } + + // Check that required parameters have been supplied + String missingParams = null; + List <String> paramList = new ArrayList <String> (); + + // New for 1510 - consult the PARAM_ALIAS field to see if we've been + // supplied an alias. Only check if we don't find it initially. + // Also new in 1510 - don't flag missing parameters if there's an environment - because they might be there. + // And also new - add parameter to turn off checking all together if we find we're blocking orders we + // shouldn't + boolean haveEnvironmentParameters = false; + boolean checkRequiredParameters = true; + try { + String propertyString = msoPropertiesFactory.getMsoJavaProperties (MSO_PROP_VNF_ADAPTER) + .getProperty (MsoVnfAdapterImpl.CHECK_REQD_PARAMS,null); + if ("false".equalsIgnoreCase (propertyString) || "n".equalsIgnoreCase (propertyString)) { + checkRequiredParameters = false; + LOGGER.debug ("CheckRequiredParameters is FALSE. Will still check but then skip blocking..." + + MsoVnfAdapterImpl.CHECK_REQD_PARAMS); + } + } catch (Exception e) { + // No problem - default is true + LOGGER.debug ("An exception occured trying to get property " + MsoVnfAdapterImpl.CHECK_REQD_PARAMS, e); + } + // 1604 - Add enhanced environment & parameter checking + // Part 1: parse envt entries to see if reqd parameter is there (before used a simple grep + // Part 2: only submit to openstack the parameters in the envt that are in the heat template + // Note this also removes any comments + MsoHeatEnvironmentEntry mhee = null; + if (heatEnvironmentString != null && heatEnvironmentString.toLowerCase ().contains ("parameters:")) { + LOGGER.debug("Enhanced environment checking enabled - 1604"); + haveEnvironmentParameters = true; + StringBuilder sb = new StringBuilder(heatEnvironmentString); + //LOGGER.debug("About to create MHEE with " + sb); + mhee = new MsoHeatEnvironmentEntry(sb); + StringBuilder sb2 = new StringBuilder("\nHeat Template Parameters:\n"); + for (HeatTemplateParam parm : heatTemplate.getParameters()) { + sb2.append("\t" + parm.getParamName() + ", required=" + parm.isRequired()); + } + if (!mhee.isValid()) { + sb2.append("Environment says it's not valid! " + mhee.getErrorString()); + } else { + sb2.append("\nEnvironment:"); + sb2.append(mhee.toFullString()); + } + LOGGER.debug(sb2.toString()); + } else { + LOGGER.debug("NO ENVIRONMENT for this entry"); + } + + for (HeatTemplateParam parm : heatTemplate.getParameters ()) { + LOGGER.debug ("Parameter:'" + parm.getParamName () + + "', isRequired=" + + parm.isRequired () + + ", alias=" + + parm.getParamAlias ()); + if (parm.isRequired () && (inputs == null || !inputs.containsKey (parm.getParamName ()))) { + if (inputs.containsKey (parm.getParamAlias ())) { + // They've submitted using an alias name. Remove that from inputs, and add back using real name. + String realParamName = parm.getParamName (); + String alias = parm.getParamAlias (); + String value = inputs.get (alias); + LOGGER.debug ("*Found an Alias: paramName=" + realParamName + + ",alias=" + + alias + + ",value=" + + value); + inputs.remove (alias); + inputs.put (realParamName, value); + LOGGER.debug (alias + " entry removed from inputs, added back using " + realParamName); + } + // enhanced - check if it's in the Environment (note: that method + else if (mhee != null && mhee.containsParameter(parm.getParamName())) { + + LOGGER.debug ("Required parameter " + parm.getParamName () + + " appears to be in environment - do not count as missing"); + } + else { + LOGGER.debug ("adding to missing parameters list: " + parm.getParamName ()); + if (missingParams == null) { + missingParams = parm.getParamName (); + } else { + missingParams += "," + parm.getParamName (); + } + } + } + paramList.add (parm.getParamName ()); + } + if (missingParams != null) { + // Problem - missing one or more required parameters + if (checkRequiredParameters) { + String error = "Update VNF: Missing Required inputs: " + missingParams; + LOGGER.error (MessageEnum.RA_MISSING_PARAM, missingParams, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Update VNF: Missing Required inputs"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataError, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug ("found missing parameters - but checkRequiredParameters is false - will not block"); + } + } else { + LOGGER.debug ("No missing parameters found - ok to proceed"); + } + + // Here - modify heatEnvironmentString + StringBuilder parsedEnvironmentString = null; + String newEnvironmentString = null; + if (mhee != null) { + LOGGER.debug("Environment before:\n" + heatEnvironmentString); + parsedEnvironmentString = mhee.toFullStringExcludeNonParams(heatTemplate.getParameters()); + LOGGER.debug("Environment after:\n" + parsedEnvironmentString.toString()); + newEnvironmentString = parsedEnvironmentString.toString(); + } + + // Remove any extraneous parameters (don't throw an error) + if (inputs != null) { + List <String> extraParams = new ArrayList <String> (); + extraParams.addAll (inputs.keySet ()); + // This is not a valid parameter for this template + extraParams.removeAll (paramList); + if (!extraParams.isEmpty ()) { + LOGGER.warn (MessageEnum.RA_VNF_EXTRA_PARAM, vnfType, extraParams.toString(), "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "VNF Extra params"); + inputs.keySet ().removeAll (extraParams); + } + } + + // "Fix" the template if it has CR/LF (getting this from Oracle) + String template = heatTemplate.getHeatTemplate (); + template = template.replaceAll ("\r\n", "\n"); + + // Have the tenant. Now deploy the stack itself + // Ignore MsoTenantNotFound and MsoStackAlreadyExists exceptions + // because we already checked for those. + long updateStackStarttime = System.currentTimeMillis (); + try { + heatStack = heatU.updateStack (cloudSiteId, + tenantId, + vnfName, + template, + copyStringInputs (inputs), + true, + heatTemplate.getTimeoutMinutes (), + newEnvironmentString, + //heatEnvironmentString, + nestedTemplatesChecked, + heatFilesObjects); + LOGGER.recordMetricEvent (updateStackStarttime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "UpdateStack", vnfName); + } catch (MsoException me) { + me.addContext ("UpdateVNF"); + String error = "Update VNF " + vnfType + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (updateStackStarttime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "UpdateStack", vnfName); + LOGGER.error (MessageEnum.RA_UPDATE_VNF_ERR, vnfType, cloudSiteId, tenantId, "OpenStack", "updateStack", MsoLogger.ErrorCode.DataError, "Exception - updateStack", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + } + + // Reach this point if updateStack is successful. + // Populate remaining rollback info and response parameters. + vnfRollback.setVnfId (heatStack.getCanonicalName ()); + vnfRollback.setVnfCreated (true); + + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + rollback.value = vnfRollback; + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully update VNF"); + return; + } + + /** + * This is the "Query VNF" web service implementation. + * It will look up a VNF by name or ID in the specified cloud and tenant. + * + * The method returns an indicator that the VNF exists, its Openstack internal + * ID, its status, and the set of outputs (from when the stack was created). + * + * @param cloudSiteId CLLI code of the cloud site in which to query + * @param tenantId Openstack tenant identifier + * @param vnfName VNF Name or Openstack ID + * @param msoRequest Request tracking information for logs + * @param vnfExists Flag reporting the result of the query + * @param vnfId Holder for output VNF Openstack ID + * @param outputs Holder for Map of VNF outputs from heat (assigned IPs, etc) + */ + @Override + public void queryVnf (String cloudSiteId, + String tenantId, + String vnfName, + MsoRequest msoRequest, + Holder <Boolean> vnfExists, + Holder <String> vnfId, + Holder <VnfStatus> status, + Holder <Map <String, String>> outputs) throws VnfException { + MsoLogger.setLogContext (msoRequest); + MsoLogger.setServiceName ("QueryVnf"); + LOGGER.debug ("Querying VNF " + vnfName + " in " + cloudSiteId + "/" + tenantId); + + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + StackInfo heatStack = null; + long subStartTime = System.currentTimeMillis (); + try { + heatStack = heat.queryStack (cloudSiteId, tenantId, vnfName); + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "QueryStack", vnfName); + } catch (MsoException me) { + me.addContext ("QueryVNF"); + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + String error = "Query VNF: " + vnfName + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", vnfName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, "OpenStack", "QueryVNF", MsoLogger.ErrorCode.DataError, "Exception - queryStack", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + + // Populate the outputs based on the returned Stack information + // + if (heatStack == null || heatStack.getStatus () == HeatStatus.NOTFOUND) { + // Not Found + vnfExists.value = Boolean.FALSE; + status.value = VnfStatus.NOTFOUND; + vnfId.value = null; + outputs.value = new HashMap <String, String> (); // Return as an empty map + + LOGGER.debug ("VNF " + vnfName + " not found"); + } else { + vnfExists.value = Boolean.TRUE; + status.value = stackStatusToVnfStatus (heatStack.getStatus ()); + vnfId.value = heatStack.getCanonicalName (); + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + + LOGGER.debug ("VNF " + vnfName + " found, ID = " + vnfId.value); + } + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully query VNF"); + return; + } + + /** + * This is the "Delete VNF" web service implementation. + * It will delete a VNF by name or ID in the specified cloud and tenant. + * + * The method has no outputs. + * + * @param cloudSiteId CLLI code of the cloud site in which to delete + * @param tenantId Openstack tenant identifier + * @param vnfName VNF Name or Openstack ID + * @param msoRequest Request tracking information for logs + */ + @Override + public void deleteVnf (String cloudSiteId, + String tenantId, + String vnfName, + MsoRequest msoRequest) throws VnfException { + MsoLogger.setLogContext (msoRequest); + MsoLogger.setServiceName ("DeleteVnf"); + LOGGER.debug ("Deleting VNF " + vnfName + " in " + cloudSiteId + "/" + tenantId); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + // Use the MsoHeatUtils to delete the stack. Set the polling flag to true. + // The possible outcomes of deleteStack are a StackInfo object with status + // of NOTFOUND (on success) or FAILED (on error). Also, MsoOpenstackException + // could be thrown. + long subStartTime = System.currentTimeMillis (); + try { + heat.deleteStack (tenantId, cloudSiteId, vnfName, true); + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "DeleteStack", vnfName); + } catch (MsoException me) { + me.addContext ("DeleteVNF"); + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + String error = "Delete VNF: " + vnfName + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "DeleteStack", vnfName); + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, vnfName, cloudSiteId, tenantId, "OpenStack", "DeleteVNF", MsoLogger.ErrorCode.DataError, "Exception - DeleteVNF", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + + // On success, nothing is returned. + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully delete VNF"); + return; + } + + /** + * This web service endpoint will rollback a previous Create VNF operation. + * A rollback object is returned to the client in a successful creation + * response. The client can pass that object as-is back to the rollbackVnf + * operation to undo the creation. + */ + @Override + public void rollbackVnf (VnfRollback rollback) throws VnfException { + long startTime = System.currentTimeMillis (); + MsoLogger.setServiceName ("RollbackVnf"); + // rollback may be null (e.g. if stack already existed when Create was called) + if (rollback == null) { + LOGGER.info (MessageEnum.RA_ROLLBACK_NULL, "OpenStack", "rollbackVnf"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.BadRequest, "Rollback request content is null"); + return; + } + + // Get the elements of the VnfRollback object for easier access + String cloudSiteId = rollback.getCloudSiteId (); + String tenantId = rollback.getTenantId (); + String vnfId = rollback.getVnfId (); + + MsoLogger.setLogContext (rollback.getMsoRequest()); + + LOGGER.debug ("Rolling Back VNF " + vnfId + " in " + cloudSiteId + "/" + tenantId); + + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + // Use the MsoHeatUtils to delete the stack. Set the polling flag to true. + // The possible outcomes of deleteStack are a StackInfo object with status + // of NOTFOUND (on success) or FAILED (on error). Also, MsoOpenstackException + // could be thrown. + long subStartTime = System.currentTimeMillis (); + try { + heat.deleteStack (tenantId, cloudSiteId, vnfId, true); + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "DeleteStack", null); + } catch (MsoException me) { + // Failed to rollback the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("RollbackVNF"); + String error = "Rollback VNF: " + vnfId + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "DeleteStack", null); + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, vnfId, cloudSiteId, tenantId, "OpenStack", "DeleteStack", MsoLogger.ErrorCode.DataError, "Exception - DeleteStack", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully roll back VNF"); + return; + } + + private VnfStatus stackStatusToVnfStatus (HeatStatus stackStatus) { + switch (stackStatus) { + case CREATED: + return VnfStatus.ACTIVE; + case UPDATED: + return VnfStatus.ACTIVE; + case FAILED: + return VnfStatus.FAILED; + default: + return VnfStatus.UNKNOWN; + } + } + + private Map <String, String> copyStringOutputs (Map <String, Object> stackOutputs) { + Map <String, String> stringOutputs = new HashMap <String, String> (); + for (String key : stackOutputs.keySet ()) { + if (stackOutputs.get (key) instanceof String) { + stringOutputs.put (key, (String) stackOutputs.get (key)); + } + } + return stringOutputs; + } + + private Map <String, Object> copyStringInputs (Map <String, String> stringInputs) { + return new HashMap <String, Object> (stringInputs); + } + + /* + * a helper method to make sure that any resource_registry entry of the format + * "xx::xx" : yyy.yaml (or yyy.template) + * has the file name prepended with "file:///" + * Return a String of the environment body that's passed in. + * Have to be careful not to mess up the original formatting. + */ + private String parseEnvironment (String environment) { + StringBuilder sb = new StringBuilder (); + try (Scanner scanner = new Scanner (environment)) { + scanner.useDelimiter ("\n"); + String line = null; + Pattern resource = Pattern.compile ("\\s*\"\\w+::\\S+\"\\s*:"); + LOGGER.debug ("regex pattern for finding a resource_registry: \\s*\"\\w+::\\S+\"\\s*:"); + while (scanner.hasNextLine ()) { + line = scanner.nextLine (); + if (line.toLowerCase ().contains ("resource_registry")) { + sb.append (line + "\n"); + boolean done = false; + // basically keep scanning until EOF or parameters: section + while (scanner.hasNextLine () && !done) { + line = scanner.nextLine (); + if ("parameters:".equalsIgnoreCase (line.trim ())) { + sb.append (line + "\n"); + done = true; + break; + } + Matcher m = resource.matcher (line); + if (m.find ()) { + sb.append (m.group ()); + String secondPart = line.substring (m.end ()).trim (); + String output = secondPart; + if (secondPart.endsWith (".yaml") + || secondPart.endsWith (".template") && !secondPart.startsWith ("file:///")) { + output = "file:///" + secondPart; + LOGGER.debug ("changed " + secondPart + " to " + output); + } // don't do anything if it's not .yaml or .template + sb.append (" " + output + "\n"); + } else { + sb.append (line + "\n"); + } + } + } else { + sb.append (line + "\n"); + continue; + } + } + scanner.close (); + } catch (Exception e) { + LOGGER.debug ("Error trying to scan " + environment, e); + return environment; + } + return sb.toString (); + } + + /* + * helper class to add file:/// to the Provider_Resource_File entry in HEAT_NESTED_TEMPLATE + * and the File_Name entry in HEAT_FILES if the file:/// part is missing. + */ + private String enforceFilePrefix (String string) { + if (string.trim ().startsWith ("file:///")) { + // just leave it + return string; + } + if (string.trim ().endsWith (".yaml") || string.trim ().endsWith (".template")) { + // only .yaml or .template are valid anyway - otherwise don't bother + return "file:///" + string.trim (); + } else { + LOGGER.debug (string + " is NOT a .yaml or .template file"); + } + return string; + } + + private void sendMapToDebug(Map<String, String> inputs) { + int i = 0; + StringBuilder sb = new StringBuilder("inputs:"); + if (inputs == null) { + sb.append("\tNULL"); + } + else if (inputs.size() < 1) { + sb.append("\tEMPTY"); + } else { + for (String str : inputs.keySet()) { + sb.append("\titem " + i++ + ": " + str + "=" + inputs.get(str)); + } + } + LOGGER.debug(sb.toString()); + return; + } + + public void createVfModule(String cloudSiteId, + String tenantId, + String vnfType, + String vnfVersion, + String vnfName, + String requestType, + String volumeGroupHeatStackId, + String baseVfHeatStackId, + Map <String, String> inputs, + Boolean failIfExists, + Boolean backout, + MsoRequest msoRequest, + Holder <String> vnfId, + Holder <Map <String, String>> outputs, + Holder <VnfRollback> rollback) throws VnfException { + String vfModuleName = vnfName; + String vfModuleType = vnfType; + String vfVersion = vnfVersion; + MsoLogger.setLogContext (msoRequest); + MsoLogger.setServiceName ("CreateVfModule"); + String requestTypeString = ""; + if (requestType != null && !requestType.equals("")) { + requestTypeString = requestType; + } + String nestedStackId = null; + if (volumeGroupHeatStackId != null && !volumeGroupHeatStackId.equals("")) { + if (!volumeGroupHeatStackId.equalsIgnoreCase("null")) { + nestedStackId = volumeGroupHeatStackId; + } + } + String nestedBaseStackId = null; + if (baseVfHeatStackId != null && !baseVfHeatStackId.equals("")) { + if (!baseVfHeatStackId.equalsIgnoreCase("null")) { + nestedBaseStackId = baseVfHeatStackId; + } + } + + if (inputs == null) { + // Create an empty set of inputs + inputs = new HashMap<String,String>(); + LOGGER.debug("inputs == null - setting to empty"); + } else { + this.sendMapToDebug(inputs); + } + //This method will also handle doing things the "old" way - i.e., just orchestrate a VNF + boolean oldWay = false; + if (requestTypeString.startsWith("X")) { + oldWay = true; + LOGGER.debug("orchestrating a VNF - *NOT* a module!"); + requestTypeString = requestTypeString.substring(1); + } + + // 1607 - let's parse out the request type we're being sent + boolean isBaseRequest = false; + boolean isVolumeRequest = false; + if (requestTypeString.startsWith("VOLUME")) { + isVolumeRequest = true; + } + + LOGGER.debug("requestTypeString = " + requestTypeString + ", nestedStackId = " + nestedStackId + ", nestedBaseStackId = " + nestedBaseStackId); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + + // Build a default rollback object (no actions performed) + VnfRollback vfRollback = new VnfRollback(); + vfRollback.setCloudSiteId(cloudSiteId); + vfRollback.setTenantId(tenantId); + vfRollback.setMsoRequest(msoRequest); + vfRollback.setRequestType(requestTypeString); + vfRollback.setVolumeGroupHeatStackId(volumeGroupHeatStackId); + vfRollback.setBaseGroupHeatStackId(baseVfHeatStackId); + vfRollback.setIsBase(isBaseRequest); + + // First, look up to see if the VF already exists. + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + StackInfo heatStack = null; + long subStartTime1 = System.currentTimeMillis (); + try { + heatStack = heat.queryStack (cloudSiteId, tenantId, vfModuleName); + LOGGER.recordMetricEvent (subStartTime1, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "QueryStack", vfModuleName); + } catch (MsoException me) { + String error = "Create VF Module: Query " + vfModuleName + " in " + cloudSiteId + "/" + tenantId + ": " + me ; + LOGGER.recordMetricEvent (subStartTime1, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", vfModuleName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, "OpenStack", "queryStack", MsoLogger.ErrorCode.DataError, "Exception - queryStack", me); + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("CreateVFModule"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + // New with 1607 - more precise handling/messaging if the stack already exists + if (heatStack != null && !(heatStack.getStatus () == HeatStatus.NOTFOUND)) { + // INIT, CREATED, NOTFOUND, FAILED, BUILDING, DELETING, UNKNOWN, UPDATING, UPDATED + HeatStatus status = heatStack.getStatus(); + if (status == HeatStatus.INIT || status == HeatStatus.BUILDING || status == HeatStatus.DELETING || status == HeatStatus.UPDATING) { + // fail - it's in progress - return meaningful error + String error = "Create VF: Stack " + vfModuleName + " already exists and has status " + status.toString() + " in " + cloudSiteId + "/" + tenantId + "; please wait for it to complete, or fix manually."; + LOGGER.error (MessageEnum.RA_VNF_ALREADY_EXIST, vfModuleName, cloudSiteId, tenantId, "OpenStack", "queryStack", MsoLogger.ErrorCode.DataError, "Stack " + vfModuleName + " already exists"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, error); + throw new VnfAlreadyExists (vfModuleName, cloudSiteId, tenantId, heatStack.getCanonicalName ()); + } + if (status == HeatStatus.FAILED) { + // fail - it exists and is in a FAILED state + String error = "Create VF: Stack " + vfModuleName + " already exists and is in FAILED state in " + cloudSiteId + "/" + tenantId + "; requires manual intervention."; + LOGGER.error (MessageEnum.RA_VNF_ALREADY_EXIST, vfModuleName, cloudSiteId, tenantId, "OpenStack", "queryStack", MsoLogger.ErrorCode.DataError, "Stack " + vfModuleName + " already exists and is in FAILED state"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, error); + throw new VnfAlreadyExists (vfModuleName, cloudSiteId, tenantId, heatStack.getCanonicalName ()); + } + if (status == HeatStatus.UNKNOWN || status == HeatStatus.UPDATED) { + // fail - it exists and is in a FAILED state + String error = "Create VF: Stack " + vfModuleName + " already exists and has status " + status.toString() + " in " + cloudSiteId + "/" + tenantId + "; requires manual intervention."; + LOGGER.error (MessageEnum.RA_VNF_ALREADY_EXIST, vfModuleName, cloudSiteId, tenantId, "OpenStack", "queryStack", MsoLogger.ErrorCode.DataError, "Stack " + vfModuleName + " already exists and is in UPDATED or UNKNOWN state"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, error); + throw new VnfAlreadyExists (vfModuleName, cloudSiteId, tenantId, heatStack.getCanonicalName ()); + } + if (status == HeatStatus.CREATED) { + // fail - it exists + if (failIfExists != null && failIfExists) { + String error = "Create VF: Stack " + vfModuleName + " already exists in " + cloudSiteId + "/" + tenantId; + LOGGER.error (MessageEnum.RA_VNF_ALREADY_EXIST, vfModuleName, cloudSiteId, tenantId, "OpenStack", "queryStack", MsoLogger.ErrorCode.DataError, "Stack " + vfModuleName + " already exists"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, error); + throw new VnfAlreadyExists (vfModuleName, cloudSiteId, tenantId, heatStack.getCanonicalName ()); + } else { + LOGGER.debug ("Found Existing stack, status=" + heatStack.getStatus ()); + // Populate the outputs from the existing stack. + vnfId.value = heatStack.getCanonicalName (); + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + rollback.value = vfRollback; // Default rollback - no updates performed + } + } + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully create VF Module"); + return; + + } + + // handle a nestedStackId if sent- this one would be for the volume - so applies to both Vf and Vnf + StackInfo nestedHeatStack = null; + long subStartTime2 = System.currentTimeMillis (); + if (nestedStackId != null) { + try { + LOGGER.debug("Querying for nestedStackId = " + nestedStackId); + nestedHeatStack = heat.queryStack(cloudSiteId, tenantId, nestedStackId); + LOGGER.recordMetricEvent (subStartTime2, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "QueryStack", vfModuleName); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("CreateVFModule"); + String error = "Create VFModule: Attached heatStack ID Query " + nestedStackId + " in " + cloudSiteId + "/" + tenantId + ": " + me ; + LOGGER.recordMetricEvent (subStartTime2, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", vfModuleName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, "OpenStack", "queryStack", MsoLogger.ErrorCode.BusinessProcesssError, "MsoException trying to query nested stack", me); + LOGGER.debug("ERROR trying to query nested stack= " + error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + if (nestedHeatStack == null || nestedHeatStack.getStatus() == HeatStatus.NOTFOUND) { + String error = "Create VFModule: Attached heatStack ID DOES NOT EXIST " + nestedStackId + " in " + cloudSiteId + "/" + tenantId + " USER ERROR" ; + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, error, "OpenStack", "queryStack", MsoLogger.ErrorCode.BusinessProcesssError, "Create VFModule: Attached heatStack ID DOES NOT EXIST"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, error); + LOGGER.debug(error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug("Found nested volume heat stack - copying values to inputs"); + this.sendMapToDebug(inputs); + heat.copyStringOutputsToInputs(inputs, nestedHeatStack.getOutputs(), false); + this.sendMapToDebug(inputs); + } + } + + // handle a nestedBaseStackId if sent- this is the stack ID of the base. Should be null for VNF requests + StackInfo nestedBaseHeatStack = null; + long subStartTime3 = System.currentTimeMillis (); + if (nestedBaseStackId != null) { + try { + LOGGER.debug("Querying for nestedBaseStackId = " + nestedBaseStackId); + nestedBaseHeatStack = heat.queryStack(cloudSiteId, tenantId, nestedBaseStackId); + LOGGER.recordMetricEvent (subStartTime3, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "QueryStack", vfModuleName); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("CreateVFModule"); + String error = "Create VFModule: Attached baseHeatStack ID Query " + nestedBaseStackId + " in " + cloudSiteId + "/" + tenantId + ": " + me ; + LOGGER.recordMetricEvent (subStartTime3, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", vfModuleName); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.BusinessProcesssError, "MsoException trying to query nested base stack", me); + LOGGER.debug("ERROR trying to query nested base stack= " + error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + if (nestedBaseHeatStack == null || nestedBaseHeatStack.getStatus() == HeatStatus.NOTFOUND) { + String error = "Create VFModule: Attached base heatStack ID DOES NOT EXIST " + nestedBaseStackId + " in " + cloudSiteId + "/" + tenantId + " USER ERROR" ; + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, error, "OpenStack", "QueryStack", MsoLogger.ErrorCode.BusinessProcesssError, "Create VFModule: Attached base heatStack ID DOES NOT EXIST"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, error); + LOGGER.debug(error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug("Found nested base heat stack - copying values to inputs"); + this.sendMapToDebug(inputs); + heat.copyStringOutputsToInputs(inputs, nestedBaseHeatStack.getOutputs(), false); + this.sendMapToDebug(inputs); + } + } + + // Ready to deploy the new VNF + + try (CatalogDatabase db = new CatalogDatabase()) { + // Retrieve the VF + VfModule vf = null; + VnfResource vnfResource = null; + LOGGER.debug("version: " + vfVersion); + if (!oldWay) { + // Need to handle old and new schema methods - for a time. Try the new way first. + if (vfVersion != null && !vfVersion.isEmpty()) { + vf = db.getVfModuleType(vfModuleType, vfVersion); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " and version=" + vfVersion + " in the TYPE column - will try in MODEL_NAME"); + vf = db.getVfModuleModelName(vfModuleType, vfVersion); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " and version=" + vfVersion + " in the MODEL_NAME field either - ERROR"); + } + } + } else { + vf = db.getVfModuleType(vfModuleType); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " in the TYPE column - will try in MODEL_NAME"); + vf = db.getVfModuleModelName(vfModuleType); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " in the MODEL_NAME field either - ERROR"); + } + } + } + if (vf == null) { + String error = "Create VF Module: Unable to determine specific VF Module Type: " + + vfModuleType; + if (vfVersion != null && !vfVersion.isEmpty()) { + error += " with version = " + vfVersion; + } + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, + "VF Module Type", vfModuleType, "OpenStack", "", MsoLogger.ErrorCode.DataError, "Create VF Module: Unable to determine specific VF Module Type"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfException(error, MsoExceptionCategory.USERDATA); + } + LOGGER.debug("Got VF module definition from Catalog: " + + vf.toString()); + + if (vf.isBase()) { + isBaseRequest = true; + LOGGER.debug("This is a BASE VF request!"); + } else { + LOGGER.debug("This is *not* a BASE VF request!"); + if (!isVolumeRequest && nestedBaseStackId == null) { + LOGGER.debug("DANGER WILL ROBINSON! This is unexpected - no nestedBaseStackId with this non-base request"); + } + } + } else { + if (vfVersion != null && !vfVersion.isEmpty()) { + vnfResource = db.getVnfResource(vnfType, vnfVersion); + } else { + vnfResource = db.getVnfResource(vnfType); + } + if (vnfResource == null) { + String error = "Create VNF: Unknown VNF Type: " + vnfType; + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, "VNF Type", + vnfType, "OpenStack", "", MsoLogger.ErrorCode.DataError, "Create VNF: Unknown VNF Type"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfException(error, MsoExceptionCategory.USERDATA); + } + LOGGER.debug("Got VNF module definition from Catalog: " + + vnfResource.toString()); + } + // By here - we have either a vf or vnfResource + + //1607 - Add version check + // First - see if it's in the VnfResource record + // if we have a vf Module - then we have to query to get the VnfResource record. + if (!oldWay) { + if (vf.getVnfResourceId() != null) { + int vnfResourceId = vf.getVnfResourceId(); + vnfResource = db.getVnfResourceById(vnfResourceId); + if (vnfResource == null) { + LOGGER.debug("Unable to find vnfResource at " + vnfResourceId + " will not error for now..."); + } + } + } + String minVersionVnf = null; + String maxVersionVnf = null; + if (vnfResource != null) { + try { + minVersionVnf = vnfResource.getAicVersionMin(); + maxVersionVnf = vnfResource.getAicVersionMax(); + } catch (Exception e) { + LOGGER.debug("Unable to pull min/max version for this VNF Resource entry"); + minVersionVnf = null; + maxVersionVnf = null; + } + if (minVersionVnf != null && minVersionVnf.equals("")) { + minVersionVnf = null; + } + if (maxVersionVnf != null && maxVersionVnf.equals("")) { + maxVersionVnf = null; + } + } + if (minVersionVnf != null && maxVersionVnf != null) { + MavenLikeVersioning aicV = new MavenLikeVersioning(); + CloudSite cloudSite = null; + String aicVersion = ""; + if (this.cloudConfig == null) { + this.cloudConfig = this.cloudConfigFactory.getCloudConfig(); + } + // double check + if (this.cloudConfig != null) { + cloudSite = this.cloudConfig.getCloudSite(cloudSiteId); + if (cloudSite != null) { + aicV.setVersion(cloudSite.getAic_version()); + if ((aicV.isMoreRecentThan(minVersionVnf) || aicV.isTheSameVersion(minVersionVnf)) // aic >= min + && (aicV.isTheSameVersion(maxVersionVnf) || !(aicV.isMoreRecentThan(maxVersionVnf)))) { //aic <= max + LOGGER.debug("VNF Resource " + vnfResource.getVnfType() + " VersionMin=" + minVersionVnf + " VersionMax:" + maxVersionVnf + " supported on Cloud: " + cloudSite.getId() + " with AIC_Version:" + cloudSite.getAic_version()); + } else { + // ERROR + String error = "VNF Resource type: " + vnfResource.getVnfType() + " VersionMin=" + minVersionVnf + " VersionMax:" + maxVersionVnf + " NOT supported on Cloud: " + cloudSite.getId() + " with AIC_Version:" + cloudSite.getAic_version(); + LOGGER.error(MessageEnum.RA_CONFIG_EXC, error, "OpenStack", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - setVersion"); + LOGGER.debug(error); + throw new VnfException(error, MsoExceptionCategory.USERDATA); + } + } // let this error out downstream to avoid introducing uncertainty at this stage + } else { + LOGGER.debug("cloudConfig is NULL - cannot check cloud site version"); + } + + } else { + LOGGER.debug("AIC Version not set in VNF_Resource - this is expected thru 1607 - do not error here - not checked."); + } + // End Version check 1607 + + // with VF_MODULE - we have both the non-vol and vol template/envs in that object + // with VNF_RESOURCE - we use the old methods. + Integer heatTemplateId = null; + Integer heatEnvtId = null; + + if (!oldWay) { + if (isVolumeRequest) { + heatTemplateId = vf.getVolTemplateId(); + heatEnvtId = vf.getVolEnvironmentId(); + } else { + heatTemplateId = vf.getTemplateId(); + heatEnvtId = vf.getEnvironmentId(); + } + } else { + if (isVolumeRequest) { + VnfComponent vnfComponent = null; + vnfComponent = db.getVnfComponent(vnfResource.getId(), "VOLUME"); + if (vnfComponent == null) { + String error = "Create VNF: Cannot find VNF Component entry for: " + vnfType + ", type = VOLUME"; + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "VNF Type", vnfType, "OpenStack", "getVnfComponent", MsoLogger.ErrorCode.DataError, "Create VNF: Cannot find VNF Component entry"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + heatTemplateId = vnfComponent.getHeatTemplateId(); + heatEnvtId = vnfComponent.getHeatEnvironmentId(); + } + } else { + heatTemplateId = vnfResource.getTemplateId(); + heatEnvtId = vnfResource.getEnvironmentId(); + } + } + // By the time we get here - heatTemplateId and heatEnvtId should be populated (or null) + HeatTemplate heatTemplate = null; + if (heatTemplateId == null) { + String error = "Create: No Heat Template ID defined in catalog database for " + vnfType + ", reqType=" + requestTypeString; + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Template ID", vnfType, "OpenStack", "", MsoLogger.ErrorCode.DataError, "Create: No Heat Template ID defined in catalog database"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + alarmLogger.sendAlarm(MSO_CONFIGURATION_ERROR, + MsoAlarmLogger.CRITICAL, error); + throw new VnfException(error, MsoExceptionCategory.INTERNAL); + } else { + heatTemplate = db.getHeatTemplate(heatTemplateId); + } + if (heatTemplate == null) { + String error = "Create VF/VNF: no entry found for heat template ID = " + heatTemplateId; + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, + "Heat Template ID", + String.valueOf(heatTemplateId), "OpenStack", "", MsoLogger.ErrorCode.BusinessProcesssError, "Create VF/VNF: no entry found for heat template ID = " + heatTemplateId); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + alarmLogger.sendAlarm(MSO_CONFIGURATION_ERROR, + MsoAlarmLogger.CRITICAL, error); + throw new VnfException(error, MsoExceptionCategory.INTERNAL); + } + LOGGER.debug("Got HEAT Template from DB"); + + HeatEnvironment heatEnvironment = null; + String heatEnvironmentString = null; + + if (heatEnvtId != null && heatEnvtId != 0) { + LOGGER.debug ("about to call getHeatEnvironment with :" + heatEnvtId + ":"); + heatEnvironment = db.getHeatEnvironment (heatEnvtId); + if (heatEnvironment == null) { + String error = "Create VFModule: undefined Heat Environment. VFModule=" + vfModuleType + + ", Environment ID=" + + heatEnvtId; + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Environment ID", String.valueOf(heatEnvtId), "OpenStack", "getHeatEnvironment", MsoLogger.ErrorCode.BusinessProcesssError, "Create VFModule: undefined Heat Environment"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } else { + LOGGER.debug ("Got Heat Environment from DB: " + heatEnvironment.toString ()); + heatEnvironmentString = heatEnvironment.getEnvironment (); //this.parseEnvironment (heatEnvironment.getEnvironment ()); + LOGGER.debug ("after parsing: " + heatEnvironmentString); + } + } else { + LOGGER.debug ("no environment parameter found for this Type " + vfModuleType); + } + + // 1510 - Add the files: for nested templates *if* there are any + LOGGER.debug ("In MsoVnfAdapterImpl, createVfModule about to call db.getNestedTemplates avec templateId=" + + heatTemplate.getId ()); + Map <String, Object> nestedTemplates = db.getNestedTemplates (heatTemplate.getId ()); + Map <String, Object> nestedTemplatesChecked = new HashMap <String, Object> (); + if (nestedTemplates != null) { + // for debugging print them out + LOGGER.debug ("Contents of nestedTemplates - to be added to files: on stack:"); + for (String providerResourceFile : nestedTemplates.keySet ()) { + String providerResourceFileChecked = providerResourceFile; //this.enforceFilePrefix (providerResourceFile); + String childTemplateBody = (String) nestedTemplates.get (providerResourceFile); + LOGGER.debug (providerResourceFileChecked + " -> " + childTemplateBody); + nestedTemplatesChecked.put (providerResourceFileChecked, childTemplateBody); + } + } else { + LOGGER.debug ("No nested templates found - nothing to do here"); + nestedTemplatesChecked = null; // just to make sure + } + + // 1510 - Also add the files: for any get_files associated with this vnf_resource_id + // *if* there are any + Map<String, HeatFiles> heatFiles = null; + Map<String, Object> heatFilesObjects = new HashMap<String, Object>(); + + // Add ability to turn on adding get_files with volume requests (by property). + boolean addGetFilesOnVolumeReq = false; + try { + String propertyString = msoPropertiesFactory.getMsoJavaProperties(MSO_PROP_VNF_ADAPTER).getProperty(MsoVnfAdapterImpl.ADD_GET_FILES_ON_VOLUME_REQ, null); + if ("true".equalsIgnoreCase(propertyString) || "y".equalsIgnoreCase(propertyString)) { + addGetFilesOnVolumeReq = true; + LOGGER.debug("AddGetFilesOnVolumeReq - setting to true! " + propertyString); + } + } catch (Exception e) { + LOGGER.debug("An error occured trying to get property " + MsoVnfAdapterImpl.ADD_GET_FILES_ON_VOLUME_REQ + " - default to false", e); + } + + if (!isVolumeRequest || addGetFilesOnVolumeReq) { + if (oldWay) { + LOGGER.debug("In MsoVnfAdapterImpl createVfModule, about to call db.getHeatFiles avec vnfResourceId=" + + vnfResource.getId()); + heatFiles = db.getHeatFiles(vnfResource.getId()); + } else { + // 1607 - now use VF_MODULE_TO_HEAT_FILES table + LOGGER.debug("In MsoVnfAdapterImpl createVfModule, about to call db.getHeatFilesForVfModule avec vfModuleId=" + + vf.getId()); + heatFiles = db + .getHeatFilesForVfModule(vf.getId()); + } + if (heatFiles != null) { + // add these to stack - to be done in createStack + // here, we will map them to Map<String, Object> from + // Map<String, HeatFiles> + // this will match the nested templates format + LOGGER.debug("Contents of heatFiles - to be added to files: on stack:"); + + for (String heatFileName : heatFiles.keySet()) { + if (heatFileName.startsWith("_ERROR|")) { + // This means there was an invalid entry in VF_MODULE_TO_HEAT_FILES table - the heat file it pointed to could not be found. + String heatFileId = heatFileName.substring(heatFileName.lastIndexOf("|")+1); + String error = "Create: No HEAT_FILES entry in catalog database for " + vfModuleType + " at HEAT_FILES index=" + heatFileId; + LOGGER.debug(error); + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "HEAT_FILES entry not found at " + heatFileId, vfModuleType, "OpenStack", "", MsoLogger.ErrorCode.BusinessProcesssError, "HEAT_FILES entry not found"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } + String heatFileBody = heatFiles.get(heatFileName) + .getFileBody(); + String heatFileNameChecked = heatFileName; + LOGGER.debug(heatFileNameChecked + " -> " + + heatFileBody); + heatFilesObjects.put(heatFileNameChecked, heatFileBody); + } + } else { + LOGGER.debug("No heat files found -nothing to do here"); + heatFilesObjects = null; + } + } else { + LOGGER.debug("Volume request - DO NOT CHECK for HEAT_FILES"); + } + + // Check that required parameters have been supplied + String missingParams = null; + List <String> paramList = new ArrayList <String> (); + + // New for 1510 - consult the PARAM_ALIAS field to see if we've been + // supplied an alias. Only check if we don't find it initially. + // Also new in 1510 - don't flag missing parameters if there's an environment - because they might be there. + // And also new - add parameter to turn off checking all together if we find we're blocking orders we + // shouldn't + boolean haveEnvironmentParameters = false; + boolean checkRequiredParameters = true; + try { + String propertyString = msoPropertiesFactory.getMsoJavaProperties (MSO_PROP_VNF_ADAPTER) + .getProperty (MsoVnfAdapterImpl.CHECK_REQD_PARAMS,null); + if ("false".equalsIgnoreCase (propertyString) || "n".equalsIgnoreCase (propertyString)) { + checkRequiredParameters = false; + LOGGER.debug ("CheckRequiredParameters is FALSE. Will still check but then skip blocking..." + + MsoVnfAdapterImpl.CHECK_REQD_PARAMS); + } + } catch (Exception e) { + // No problem - default is true + LOGGER.debug ("An exception occured trying to get property " + MsoVnfAdapterImpl.CHECK_REQD_PARAMS, e); + } + // 1604 - Add enhanced environment & parameter checking + // Part 1: parse envt entries to see if reqd parameter is there (before used a simple grep + // Part 2: only submit to openstack the parameters in the envt that are in the heat template + // Note this also removes any comments + MsoHeatEnvironmentEntry mhee = null; + if (heatEnvironmentString != null && heatEnvironmentString.contains ("parameters:")) { + //LOGGER.debug ("Have an Environment argument with a parameters: section - will bypass checking for valid params - but will still check for aliases"); + LOGGER.debug("Enhanced environment checking enabled - 1604"); + haveEnvironmentParameters = true; + StringBuilder sb = new StringBuilder(heatEnvironmentString); + //LOGGER.debug("About to create MHEE with " + sb); + mhee = new MsoHeatEnvironmentEntry(sb); + StringBuilder sb2 = new StringBuilder("\nHeat Template Parameters:\n"); + for (HeatTemplateParam parm : heatTemplate.getParameters()) { + sb2.append("\t" + parm.getParamName() + ", required=" + parm.isRequired()); + } + if (!mhee.isValid()) { + sb2.append("Environment says it's not valid! " + mhee.getErrorString()); + } else { + sb2.append("\nEnvironment:"); + sb2.append(mhee.toFullString()); + } + LOGGER.debug(sb2.toString()); + } else { + LOGGER.debug("NO ENVIRONMENT for this entry"); + } + // This is kind of a mess. inputs is a Map<String, String> -- + // if one of the parameters is json - we need to pass String, JsonNode - + // so we will store off the parameters that are json in its own HashMap + // if there are any json params - then we convert inputs to a Map<String, Object> + // and pass that to createStack + HashMap<String, JsonNode> jsonParams = new HashMap<String, JsonNode>(); + boolean hasJson = false; + + for (HeatTemplateParam parm : heatTemplate.getParameters ()) { + LOGGER.debug ("Parameter:'" + parm.getParamName () + + "', isRequired=" + + parm.isRequired () + + ", alias=" + + parm.getParamAlias ()); + // New 1607 - support json type + String parameterType = parm.getParamType(); + if (parameterType == null || parameterType.trim().equals("")) { + parameterType = "String"; + } + JsonNode jsonNode = null; + if (parameterType.equalsIgnoreCase("json") && inputs != null) { + if (inputs.containsKey(parm.getParamName()) ) { + hasJson = true; + String jsonString = null; + try { + jsonString = inputs.get(parm.getParamName()); + jsonNode = new ObjectMapper().readTree(jsonString); + } catch (JsonParseException jpe) { + //TODO - what to do here? + //for now - send the error to debug, but just leave it as a String + String errorMessage = jpe.getMessage(); + LOGGER.debug("Json Error Converting " + parm.getParamName() + " - " + errorMessage); + hasJson = false; + jsonNode = null; + } catch (Exception e) { + // or here? + LOGGER.debug("Json Error Converting " + parm.getParamName() + " " + e.getMessage()); + hasJson = false; + jsonNode = null; + } + if (jsonNode != null) { + jsonParams.put(parm.getParamName(), jsonNode); + } + } else if (inputs.containsKey(parm.getParamAlias())) { + hasJson = true; + String jsonString = null; + try { + jsonString = inputs.get(parm.getParamAlias()); + jsonNode = new ObjectMapper().readTree(jsonString); + } catch (JsonParseException jpe) { + //TODO - what to do here? + //for now - send the error to debug, but just leave it as a String + String errorMessage = jpe.getMessage(); + LOGGER.debug("Json Error Converting " + parm.getParamName() + " - " + errorMessage); + hasJson = false; + jsonNode = null; + } catch (Exception e) { + // or here? + LOGGER.debug("Json Error Converting " + parm.getParamName() + " " + e.getMessage()); + hasJson = false; + jsonNode = null; + } + if (jsonNode != null) { + // Notice here - we add it to the jsonParams hashMap with the actual name - + // then manipulate the inputs so when we check for aliases below - it will not + // get flagged. + jsonParams.put(parm.getParamName(), jsonNode); + inputs.remove(parm.getParamAlias()); + inputs.put(parm.getParamName(), jsonString); + } + } //TODO add a check for the parameter in the env file + } + if (parm.isRequired () && (inputs == null || !inputs.containsKey (parm.getParamName ()))) { + // Check if they have an alias + LOGGER.debug("**Parameter " + parm.getParamName() + " is required and not in the inputs..."); + if (inputs.containsKey (parm.getParamAlias ())) { + // They've submitted using an alias name. Remove that from inputs, and add back using real name. + String realParamName = parm.getParamName (); + String alias = parm.getParamAlias (); + String value = inputs.get (alias); + LOGGER.debug ("*Found an Alias: paramName=" + realParamName + + ",alias=" + + alias + + ",value=" + + value); + inputs.remove (alias); + inputs.put (realParamName, value); + LOGGER.debug (alias + " entry removed from inputs, added back using " + realParamName); + } + // enhanced - check if it's in the Environment (note: that method + else if (mhee != null && mhee.containsParameter(parm.getParamName())) { + + LOGGER.debug ("Required parameter " + parm.getParamName () + + " appears to be in environment - do not count as missing"); + } else { + LOGGER.debug ("adding to missing parameters list: " + parm.getParamName ()); + if (missingParams == null) { + missingParams = parm.getParamName (); + } else { + missingParams += "," + parm.getParamName (); + } + } + } + paramList.add (parm.getParamName ()); + } + if (missingParams != null) { + if (checkRequiredParameters) { + // Problem - missing one or more required parameters + String error = "Create VFModule: Missing Required inputs: " + missingParams; + LOGGER.error (MessageEnum.RA_MISSING_PARAM, missingParams, "OpenStack", "", MsoLogger.ErrorCode.DataError, "Create VFModule: Missing Required inputs"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.BadRequest, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug ("found missing parameters - but checkRequiredParameters is false - will not block"); + } + } else { + LOGGER.debug ("No missing parameters found - ok to proceed"); + } + + // Here - modify heatEnvironmentString + StringBuilder parsedEnvironmentString = null; + String newEnvironmentString = null; + if (mhee != null) { + LOGGER.debug("Environment before:\n" + heatEnvironmentString); + parsedEnvironmentString = mhee.toFullStringExcludeNonParams(heatTemplate.getParameters()); + LOGGER.debug("Environment after:\n" + parsedEnvironmentString.toString()); + newEnvironmentString = parsedEnvironmentString.toString(); + } + + // Remove any extraneous parameters (don't throw an error) + if (inputs != null) { + List <String> extraParams = new ArrayList <String> (); + extraParams.addAll (inputs.keySet ()); + extraParams.removeAll (paramList); + if (!extraParams.isEmpty ()) { + LOGGER.warn (MessageEnum.RA_VNF_EXTRA_PARAM, vnfType, extraParams.toString(), "OpenStack", "", MsoLogger.ErrorCode.DataError, "Extra params"); + inputs.keySet ().removeAll (extraParams); + } + } + // 1607 - when we get here - we have clean inputs. Check if we have + Map<String, Object> inputsTwo = null; + if (hasJson && jsonParams.size() > 0) { + inputsTwo = new HashMap<String, Object>(); + for (String keyParamName : inputs.keySet()) { + if (jsonParams.containsKey(keyParamName)) { + inputsTwo.put(keyParamName, jsonParams.get(keyParamName)); + } else { + inputsTwo.put(keyParamName, inputs.get(keyParamName)); + } + } + } + + // "Fix" the template if it has CR/LF (getting this from Oracle) + String template = heatTemplate.getHeatTemplate (); + template = template.replaceAll ("\r\n", "\n"); + + // Have the tenant. Now deploy the stack itself + // Ignore MsoTenantNotFound and MsoStackAlreadyExists exceptions + // because we already checked for those. + long createStackStarttime = System.currentTimeMillis (); + try { + // heatStack = heat.createStack(cloudSiteId, tenantId, vnfName, template, inputs, true, + // heatTemplate.getTimeoutMinutes()); + if (backout == null) { + backout = true; + } + if (heat != null) { + LOGGER.debug("heat is not null!!"); + } + + if (!hasJson) { + heatStack = heat.createStack (cloudSiteId, + tenantId, + vfModuleName, + template, + inputs, + true, + heatTemplate.getTimeoutMinutes (), + newEnvironmentString, + //heatEnvironmentString, + nestedTemplatesChecked, + heatFilesObjects, + backout.booleanValue()); + LOGGER.recordMetricEvent (createStackStarttime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "CreateStack", vfModuleName); + } else { + heatStack = heat.createStack (cloudSiteId, + tenantId, + vfModuleName, + template, + inputsTwo, + true, + heatTemplate.getTimeoutMinutes (), + newEnvironmentString, + //heatEnvironmentString, + nestedTemplatesChecked, + heatFilesObjects, + backout.booleanValue()); + + } + LOGGER.recordMetricEvent (createStackStarttime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "CreateStack", vfModuleName); + } catch (MsoException me) { + me.addContext ("CreateVFModule"); + String error = "Create VF Module " + vfModuleType + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (createStackStarttime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "CreateStack", vfModuleName); + LOGGER.error (MessageEnum.RA_CREATE_VNF_ERR, vfModuleType, cloudSiteId, tenantId, "OpenStack", "", MsoLogger.ErrorCode.DataError, "MsoException - createStack", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } catch (NullPointerException npe) { + String error = "Create VFModule " + vfModuleType + " in " + cloudSiteId + "/" + tenantId + ": " + npe; + LOGGER.recordMetricEvent (createStackStarttime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "CreateStack", vfModuleName); + LOGGER.error (MessageEnum.RA_CREATE_VNF_ERR, vfModuleType, cloudSiteId, tenantId, "OpenStack", "", MsoLogger.ErrorCode.DataError, "NullPointerException - createStack", npe); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + LOGGER.debug("NULL POINTER EXCEPTION at heat.createStack"); + //npe.addContext ("CreateVNF"); + throw new VnfException ("NullPointerException during heat.createStack"); + } catch (Exception e) { + LOGGER.recordMetricEvent (createStackStarttime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, "Exception while creating stack with OpenStack", "OpenStack", "CreateStack", vfModuleName); + LOGGER.debug("unhandled exception at heat.createStack"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, "Exception while creating stack with OpenStack"); + throw new VnfException("Exception during heat.createStack! " + e.getMessage()); + } + } catch (Exception e) { + LOGGER.debug("unhandled exception in create VF"); + throw new VnfException("Exception during create VF " + e.getMessage()); + + } + + // Reach this point if createStack is successful. + // Populate remaining rollback info and response parameters. + vfRollback.setVnfId (heatStack.getCanonicalName ()); + vfRollback.setVnfCreated (true); + + vnfId.value = heatStack.getCanonicalName (); + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + rollback.value = vfRollback; + + LOGGER.debug ("VF Module " + vfModuleName + " successfully created"); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully create VF Module"); + return; + + + } + + public void deleteVfModule (String cloudSiteId, + String tenantId, + String vnfName, + MsoRequest msoRequest) throws VnfException { + MsoLogger.setLogContext (msoRequest); + MsoLogger.setServiceName ("DeleteVf"); + LOGGER.debug ("Deleting VF " + vnfName + " in " + cloudSiteId + "/" + tenantId); + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + // Use the MsoHeatUtils to delete the stack. Set the polling flag to true. + // The possible outcomes of deleteStack are a StackInfo object with status + // of NOTFOUND (on success) or FAILED (on error). Also, MsoOpenstackException + // could be thrown. + long subStartTime = System.currentTimeMillis (); + try { + heat.deleteStack (tenantId, cloudSiteId, vnfName, true); + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully received response from Open Stack", "OpenStack", "DeleteStack", vnfName); + } catch (MsoException me) { + me.addContext ("DeleteVNF"); + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + String error = "Delete VF: " + vnfName + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (subStartTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "DeleteStack", vnfName); + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, vnfName, cloudSiteId, tenantId, "OpenStack", "DeleteStack", MsoLogger.ErrorCode.DataError, "Exception - deleteStack", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + + // On success, nothing is returned. + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully delete VF"); + return; + } + + @Override + public void updateVfModule (String cloudSiteId, + String tenantId, + String vnfType, + String vnfVersion, + String vnfName, + String requestType, + String volumeGroupHeatStackId, + String baseVfHeatStackId, + String vfModuleStackId, + Map <String, String> inputs, + MsoRequest msoRequest, + Holder <Map <String, String>> outputs, + Holder <VnfRollback> rollback) throws VnfException { + String vfModuleName = vnfName; + String vfModuleType = vnfType; + String vfVersion = vnfVersion; + String methodName = "updateVfModule"; + MsoLogger.setLogContext (msoRequest.getRequestId (), msoRequest.getServiceInstanceId ()); + String serviceName = VNF_ADAPTER_SERVICE_NAME + methodName; + MsoLogger.setServiceName (serviceName); + + String requestTypeString = ""; + if (requestType != null && !requestType.equals("")) { + requestTypeString = requestType; + } + String nestedStackId = null; + if (volumeGroupHeatStackId != null && !volumeGroupHeatStackId.equals("")) { + if (!volumeGroupHeatStackId.equalsIgnoreCase("null")) { + nestedStackId = volumeGroupHeatStackId; + } + } + String nestedBaseStackId = null; + if (baseVfHeatStackId != null && !baseVfHeatStackId.equals("")) { + if (!baseVfHeatStackId.equalsIgnoreCase("null")) { + nestedBaseStackId = baseVfHeatStackId; + } + } + + if (inputs == null) { + // Create an empty set of inputs + inputs = new HashMap<String,String>(); + LOGGER.debug("inputs == null - setting to empty"); + } else { + this.sendMapToDebug(inputs); + } + boolean isBaseRequest = false; + boolean isVolumeRequest = false; + if (requestTypeString.startsWith("VOLUME")) { + isVolumeRequest = true; + } + if (vfModuleName == null || vfModuleName.trim().equals("")) { + if (vfModuleStackId != null) { + vfModuleName = this.getVfModuleNameFromModuleStackId(vfModuleStackId); + } + } + + LOGGER.debug ("Updating VFModule: " + vfModuleName + " of type " + vfModuleType + "in " + cloudSiteId + "/" + tenantId); + LOGGER.debug("requestTypeString = " + requestTypeString + ", nestedStackId = " + nestedStackId + ", nestedBaseStackId = " + nestedBaseStackId); + + // Will capture execution time for metrics + long startTime = System.currentTimeMillis (); + + // Build a default rollback object (no actions performed) + VnfRollback vfRollback = new VnfRollback (); + vfRollback.setCloudSiteId (cloudSiteId); + vfRollback.setTenantId (tenantId); + vfRollback.setMsoRequest (msoRequest); + vfRollback.setRequestType(requestTypeString); + vfRollback.setVolumeGroupHeatStackId(volumeGroupHeatStackId); + vfRollback.setBaseGroupHeatStackId(baseVfHeatStackId); + vfRollback.setIsBase(isBaseRequest); + vfRollback.setVfModuleStackId(vfModuleStackId); + + // First, look up to see if the VNF already exists. + MsoHeatUtils heat = new MsoHeatUtils (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + MsoHeatUtilsWithUpdate heatU = new MsoHeatUtilsWithUpdate (MSO_PROP_VNF_ADAPTER, msoPropertiesFactory,cloudConfigFactory); + + StackInfo heatStack = null; + long queryStackStarttime = System.currentTimeMillis (); + LOGGER.debug("UpdateVfModule - querying for " + vfModuleName); + try { + heatStack = heat.queryStack (cloudSiteId, tenantId, vfModuleName); + LOGGER.recordMetricEvent (queryStackStarttime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully receive response from Open Stack", "OpenStack", "QueryStack", null); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("UpdateVFModule"); + String error = "Update VFModule: Query " + vfModuleName + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (queryStackStarttime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", null); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Exception - QueryStack", me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + + //TODO - do we need to check for the other status possibilities? + if (heatStack == null || heatStack.getStatus () == HeatStatus.NOTFOUND) { + // Not Found + String error = "Update VF: Stack " + vfModuleName + " does not exist in " + cloudSiteId + "/" + tenantId; + LOGGER.error (MessageEnum.RA_VNF_NOT_EXIST, vfModuleName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfNotFound (cloudSiteId, tenantId, vfModuleName); + } else { + LOGGER.debug ("Found Existing stack, status=" + heatStack.getStatus ()); + // Populate the outputs from the existing stack. + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + rollback.value = vfRollback; // Default rollback - no updates performed + } + + // 1604 Cinder Volume support - handle a nestedStackId if sent (volumeGroupHeatStackId): + StackInfo nestedHeatStack = null; + long queryStackStarttime2 = System.currentTimeMillis (); + if (nestedStackId != null) { + try { + LOGGER.debug("Querying for nestedStackId = " + nestedStackId); + nestedHeatStack = heat.queryStack(cloudSiteId, tenantId, nestedStackId); + LOGGER.recordMetricEvent (queryStackStarttime2, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully receive response from Open Stack", "OpenStack", "QueryStack", null); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("UpdateVFModule"); + String error = "Update VF: Attached heatStack ID Query " + nestedStackId + " in " + cloudSiteId + "/" + tenantId + ": " + me ; + LOGGER.recordMetricEvent (queryStackStarttime2, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", null); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Exception - " + error, me); + LOGGER.debug("ERROR trying to query nested stack= " + error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + if (nestedHeatStack == null || nestedHeatStack.getStatus() == HeatStatus.NOTFOUND) { + MsoLogger.setServiceName (serviceName); + String error = "Update VFModule: Attached volume heatStack ID DOES NOT EXIST " + nestedStackId + " in " + cloudSiteId + "/" + tenantId + " USER ERROR" ; + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vnfName, cloudSiteId, tenantId, error, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, error); + LOGGER.debug(error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug("Found nested heat stack - copying values to inputs"); + this.sendMapToDebug(inputs); + heat.copyStringOutputsToInputs(inputs, nestedHeatStack.getOutputs(), false); + this.sendMapToDebug(inputs); + } + } + // handle a nestedBaseStackId if sent - this is the stack ID of the base. + StackInfo nestedBaseHeatStack = null; + if (nestedBaseStackId != null) { + long queryStackStarttime3 = System.currentTimeMillis (); + try { + LOGGER.debug("Querying for nestedBaseStackId = " + nestedBaseStackId); + nestedBaseHeatStack = heat.queryStack(cloudSiteId, tenantId, nestedBaseStackId); + LOGGER.recordMetricEvent (queryStackStarttime3, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully receive response from Open Stack", "OpenStack", "QueryStack", null); + } catch (MsoException me) { + // Failed to query the Stack due to an openstack exception. + // Convert to a generic VnfException + me.addContext ("UpdateVfModule"); + String error = "Update VFModule: Attached baseHeatStack ID Query " + nestedBaseStackId + " in " + cloudSiteId + "/" + tenantId + ": " + me ; + LOGGER.recordMetricEvent (queryStackStarttime3, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "QueryStack", null); + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, "Exception - " + error, me); + LOGGER.debug("ERROR trying to query nested base stack= " + error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + if (nestedBaseHeatStack == null || nestedBaseHeatStack.getStatus() == HeatStatus.NOTFOUND) { + MsoLogger.setServiceName (serviceName); + String error = "Update VFModule: Attached base heatStack ID DOES NOT EXIST " + nestedBaseStackId + " in " + cloudSiteId + "/" + tenantId + " USER ERROR" ; + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, cloudSiteId, tenantId, error, "OpenStack", "QueryStack", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + LOGGER.debug(error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug("Found nested base heat stack - copying values to inputs"); + this.sendMapToDebug(inputs); + heat.copyStringOutputsToInputs(inputs, nestedBaseHeatStack.getOutputs(), false); + this.sendMapToDebug(inputs); + } + } + + // Ready to deploy the new VNF + + try (CatalogDatabase db = new CatalogDatabase ()) { + // Retrieve the VF definition + //VnfResource vnf; + VfModule vf = null; + if (vfVersion != null && !vfVersion.isEmpty ()) { + vf = db.getVfModuleType(vfModuleType, vfVersion); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " and version = " + vfVersion + " in the TYPE column - will try in MODEL_NAME"); + vf = db.getVfModuleModelName(vfModuleType, vfVersion); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " and version = " + vfVersion + " in the MODEL_NAME field either - ERROR"); + } + } + } else { + vf = db.getVfModuleType(vfModuleType); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " in the TYPE column - will try in MODEL_NAME"); + vf = db.getVfModuleModelName(vfModuleType); + if (vf == null) { + LOGGER.debug("Unable to find " + vfModuleType + " in the MODEL_NAME field either - ERROR"); + } + } + } + if (vf == null) { + String error = "Update VFModule: Unknown VF Module Type: " + vfModuleType; + if (vfVersion != null && !vfVersion.isEmpty()) { + error += " with version = " + vfVersion; + } + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "VF Module Type", vfModuleType, "OpenStack", "", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataError, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } + LOGGER.debug ("Got VF module definition from Catalog: " + vf.toString ()); + + HeatTemplate heatTemplate = null; + Integer heatTemplateId = null; + Integer heatEnvtId = null; + if (!isVolumeRequest) { + heatTemplateId = vf.getTemplateId(); + heatEnvtId = vf.getEnvironmentId(); + } else { + heatTemplateId = vf.getVolTemplateId(); + heatEnvtId = vf.getVolEnvironmentId(); + } + if (heatTemplateId == null) { + String error = "UpdateVF: No Heat Template ID defined in catalog database for " + vfModuleType + ", reqType=" + requestTypeString; + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Template ID", vfModuleType, "OpenStack", "", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + alarmLogger.sendAlarm(MSO_CONFIGURATION_ERROR, + MsoAlarmLogger.CRITICAL, error); + throw new VnfException(error, MsoExceptionCategory.INTERNAL); + } else { + heatTemplate = db.getHeatTemplate(heatTemplateId); + } + + if (heatTemplate == null) { + String error = "Update VNF: undefined Heat Template. VF=" + + vfModuleType + ", heat template id = " + heatTemplateId; + LOGGER.error(MessageEnum.RA_VNF_UNKNOWN_PARAM, + "Heat Template ID", + String.valueOf(heatTemplateId), "OpenStack", "", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm(MSO_CONFIGURATION_ERROR, + MsoAlarmLogger.CRITICAL, error); + + throw new VnfException(error, MsoExceptionCategory.INTERNAL); + } + + LOGGER.debug ("Got HEAT Template from DB: " + heatTemplate.toString ()); + + // Add check for any Environment variable + HeatEnvironment heatEnvironment = null; + String heatEnvironmentString = null; + + if (heatEnvtId != null) { + LOGGER.debug ("about to call getHeatEnvironment with :" + heatEnvtId + ":"); + heatEnvironment = db.getHeatEnvironment (heatEnvtId); + if (heatEnvironment == null) { + + String error = "Update VNF: undefined Heat Environment. VF=" + vfModuleType + + ", Environment ID=" + + heatEnvtId; + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "Heat Environment ID", String.valueOf(heatEnvtId), "OpenStack", "", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } else { + LOGGER.debug ("Got Heat Environment from DB: " + heatEnvironment.toString ()); + heatEnvironmentString = heatEnvironment.getEnvironment (); //this.parseEnvironment (heatEnvironment.getEnvironment ()); + LOGGER.debug ("After parsing: " + heatEnvironmentString); + } + } else { + LOGGER.debug ("no environment parameter for this VFModuleType " + vfModuleType); + } + + + LOGGER.debug ("In MsoVnfAdapterImpl, about to call db.getNestedTemplates avec templateId=" + + heatTemplate.getId ()); + Map <String, Object> nestedTemplates = db.getNestedTemplates (heatTemplate.getId ()); + Map <String, Object> nestedTemplatesChecked = new HashMap <String, Object> (); + if (nestedTemplates != null) { + // for debugging print them out + LOGGER.debug ("Contents of nestedTemplates - to be added to files: on stack:"); + for (String providerResourceFile : nestedTemplates.keySet ()) { + String providerResourceFileChecked = providerResourceFile; //this.enforceFilePrefix (providerResourceFile); + String childTemplateBody = (String) nestedTemplates.get (providerResourceFile); + nestedTemplatesChecked.put (providerResourceFileChecked, childTemplateBody); + LOGGER.debug (providerResourceFileChecked + " -> " + childTemplateBody); + } + } else { + LOGGER.debug ("No nested templates found - nothing to do here"); + nestedTemplatesChecked = null; + } + + // Also add the files: for any get_files associated with this VfModule + // *if* there are any + LOGGER.debug ("In MsoVnfAdapterImpl.updateVfModule, about to call db.getHeatFiles avec vfModuleId=" + + vf.getId ()); + + Map <String, HeatFiles> heatFiles = null; +// Map <String, HeatFiles> heatFiles = db.getHeatFiles (vnf.getId ()); + Map <String, Object> heatFilesObjects = new HashMap <String, Object> (); + + // Add ability to turn on adding get_files with volume requests (by property). + boolean addGetFilesOnVolumeReq = false; + try { + String propertyString = msoPropertiesFactory.getMsoJavaProperties(MSO_PROP_VNF_ADAPTER).getProperty(MsoVnfAdapterImpl.ADD_GET_FILES_ON_VOLUME_REQ, null); + if ("true".equalsIgnoreCase(propertyString) || "y".equalsIgnoreCase(propertyString)) { + addGetFilesOnVolumeReq = true; + LOGGER.debug("AddGetFilesOnVolumeReq - setting to true! " + propertyString); + } + } catch (Exception e) { + LOGGER.debug("An error occured trying to get property " + MsoVnfAdapterImpl.ADD_GET_FILES_ON_VOLUME_REQ + " - default to false", e); + } + if (!isVolumeRequest || addGetFilesOnVolumeReq) { + heatFiles = db.getHeatFilesForVfModule(vf.getId()); + if (heatFiles != null) { + // add these to stack - to be done in createStack + // here, we will map them to Map<String, Object> from Map<String, HeatFiles> + // this will match the nested templates format + LOGGER.debug ("Contents of heatFiles - to be added to files: on stack:"); + + for (String heatFileName : heatFiles.keySet ()) { + if (heatFileName.startsWith("_ERROR|")) { + // This means there was an invalid entry in VF_MODULE_TO_HEAT_FILES table - the heat file it pointed to could not be found. + String heatFileId = heatFileName.substring(heatFileName.lastIndexOf("|")+1); + String error = "Create: No HEAT_FILES entry in catalog database for " + vfModuleType + " at HEAT_FILES index=" + heatFileId; + LOGGER.debug(error); + LOGGER.error (MessageEnum.RA_VNF_UNKNOWN_PARAM, "HEAT_FILES entry not found at " + heatFileId, vfModuleType, "OpenStack", "", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound, error); + // Alarm on this error, configuration must be fixed + alarmLogger.sendAlarm (MSO_CONFIGURATION_ERROR, MsoAlarmLogger.CRITICAL, error); + throw new VnfException (error, MsoExceptionCategory.INTERNAL); + } + String heatFileBody = heatFiles.get (heatFileName).getFileBody (); + LOGGER.debug (heatFileName + " -> " + heatFileBody); + heatFilesObjects.put (heatFileName, heatFileBody); + } + } else { + LOGGER.debug ("No heat files found -nothing to do here"); + heatFilesObjects = null; + } + } + + // Check that required parameters have been supplied + String missingParams = null; + List <String> paramList = new ArrayList <String> (); + + // New for 1510 - consult the PARAM_ALIAS field to see if we've been + // supplied an alias. Only check if we don't find it initially. + // Also new in 1510 - don't flag missing parameters if there's an environment - because they might be there. + // And also new - add parameter to turn off checking all together if we find we're blocking orders we + // shouldn't + boolean haveEnvironmentParameters = false; + boolean checkRequiredParameters = true; + try { + String propertyString = msoPropertiesFactory.getMsoJavaProperties (MSO_PROP_VNF_ADAPTER) + .getProperty (MsoVnfAdapterImpl.CHECK_REQD_PARAMS,null); + if ("false".equalsIgnoreCase (propertyString) || "n".equalsIgnoreCase (propertyString)) { + checkRequiredParameters = false; + LOGGER.debug ("CheckRequiredParameters is FALSE. Will still check but then skip blocking..." + + MsoVnfAdapterImpl.CHECK_REQD_PARAMS); + } + } catch (Exception e) { + // No problem - default is true + LOGGER.debug ("An exception occured trying to get property " + MsoVnfAdapterImpl.CHECK_REQD_PARAMS, e); + } + // 1604 - Add enhanced environment & parameter checking + // Part 1: parse envt entries to see if reqd parameter is there (before used a simple grep + // Part 2: only submit to openstack the parameters in the envt that are in the heat template + // Note this also removes any comments + MsoHeatEnvironmentEntry mhee = null; + if (heatEnvironmentString != null && heatEnvironmentString.toLowerCase ().contains ("parameters:")) { + LOGGER.debug("Enhanced environment checking enabled - 1604"); + haveEnvironmentParameters = true; + StringBuilder sb = new StringBuilder(heatEnvironmentString); + //LOGGER.debug("About to create MHEE with " + sb); + mhee = new MsoHeatEnvironmentEntry(sb); + StringBuilder sb2 = new StringBuilder("\nHeat Template Parameters:\n"); + for (HeatTemplateParam parm : heatTemplate.getParameters()) { + sb2.append("\t" + parm.getParamName() + ", required=" + parm.isRequired()); + } + if (!mhee.isValid()) { + sb2.append("Environment says it's not valid! " + mhee.getErrorString()); + } else { + sb2.append("\nEnvironment:"); + sb2.append(mhee.toFullString()); + } + LOGGER.debug(sb2.toString()); + } else { + LOGGER.debug("NO ENVIRONMENT for this entry"); + } + + // New for 1607 - support params of json type + HashMap<String, JsonNode> jsonParams = new HashMap<String, JsonNode>(); + boolean hasJson = false; + + for (HeatTemplateParam parm : heatTemplate.getParameters ()) { + LOGGER.debug ("Parameter:'" + parm.getParamName () + + "', isRequired=" + + parm.isRequired () + + ", alias=" + + parm.getParamAlias ()); + // handle json + String parameterType = parm.getParamType(); + if (parameterType == null || parameterType.trim().equals("")) { + parameterType = "String"; + } + JsonNode jsonNode = null; + if (parameterType.equalsIgnoreCase("json") && inputs != null) { + if (inputs.containsKey(parm.getParamName()) ) { + hasJson = true; + String jsonString = null; + try { + jsonString = inputs.get(parm.getParamName()); + jsonNode = new ObjectMapper().readTree(jsonString); + } catch (JsonParseException jpe) { + //TODO - what to do here? + //for now - send the error to debug, but just leave it as a String + String errorMessage = jpe.getMessage(); + LOGGER.debug("Json Error Converting " + parm.getParamName() + " - " + errorMessage); + hasJson = false; + jsonNode = null; + } catch (Exception e) { + // or here? + LOGGER.debug("Json Error Converting " + parm.getParamName() + " " + e.getMessage()); + hasJson = false; + jsonNode = null; + } + if (jsonNode != null) { + jsonParams.put(parm.getParamName(), jsonNode); + } + } else if (inputs.containsKey(parm.getParamAlias())) { + hasJson = true; + String jsonString = null; + try { + jsonString = inputs.get(parm.getParamAlias()); + jsonNode = new ObjectMapper().readTree(jsonString); + } catch (JsonParseException jpe) { + //TODO - what to do here? + //for now - send the error to debug, but just leave it as a String + String errorMessage = jpe.getMessage(); + LOGGER.debug("Json Error Converting " + parm.getParamName() + " - " + errorMessage); + hasJson = false; + jsonNode = null; + } catch (Exception e) { + // or here? + LOGGER.debug("Json Error Converting " + parm.getParamName() + " " + e.getMessage()); + hasJson = false; + jsonNode = null; + } + if (jsonNode != null) { + // Notice here - we add it to the jsonParams hashMap with the actual name - + // then manipulate the inputs so when we check for aliases below - it will not + // get flagged. + jsonParams.put(parm.getParamName(), jsonNode); + inputs.remove(parm.getParamAlias()); + inputs.put(parm.getParamName(), jsonString); + } + } //TODO add a check for the parameter in the env file + } + + if (parm.isRequired () && (inputs == null || !inputs.containsKey (parm.getParamName ()))) { + if (inputs.containsKey (parm.getParamAlias ())) { + // They've submitted using an alias name. Remove that from inputs, and add back using real name. + String realParamName = parm.getParamName (); + String alias = parm.getParamAlias (); + String value = inputs.get (alias); + LOGGER.debug ("*Found an Alias: paramName=" + realParamName + + ",alias=" + + alias + + ",value=" + + value); + inputs.remove (alias); + inputs.put (realParamName, value); + LOGGER.debug (alias + " entry removed from inputs, added back using " + realParamName); + } + // enhanced - check if it's in the Environment (note: that method + else if (mhee != null && mhee.containsParameter(parm.getParamName())) { + + LOGGER.debug ("Required parameter " + parm.getParamName () + + " appears to be in environment - do not count as missing"); + } + else { + LOGGER.debug ("adding to missing parameters list: " + parm.getParamName ()); + if (missingParams == null) { + missingParams = parm.getParamName (); + } else { + missingParams += "," + parm.getParamName (); + } + } + } + paramList.add (parm.getParamName ()); + } + if (missingParams != null) { + // Problem - missing one or more required parameters + if (checkRequiredParameters) { + String error = "Update VNF: Missing Required inputs: " + missingParams; + LOGGER.error (MessageEnum.RA_MISSING_PARAM, missingParams, "OpenStack", "", MsoLogger.ErrorCode.DataError, error); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.BadRequest, error); + throw new VnfException (error, MsoExceptionCategory.USERDATA); + } else { + LOGGER.debug ("found missing parameters - but checkRequiredParameters is false - will not block"); + } + } else { + LOGGER.debug ("No missing parameters found - ok to proceed"); + } + + // Here - modify heatEnvironmentString + StringBuilder parsedEnvironmentString = null; + String newEnvironmentString = null; + if (mhee != null) { + LOGGER.debug("Environment before:\n" + heatEnvironmentString); + parsedEnvironmentString = mhee.toFullStringExcludeNonParams(heatTemplate.getParameters()); + LOGGER.debug("Environment after:\n" + parsedEnvironmentString.toString()); + newEnvironmentString = parsedEnvironmentString.toString(); + } + + // Remove any extraneous parameters (don't throw an error) + if (inputs != null) { + List <String> extraParams = new ArrayList <String> (); + extraParams.addAll (inputs.keySet ()); + // This is not a valid parameter for this template + extraParams.removeAll (paramList); + if (!extraParams.isEmpty ()) { + LOGGER.warn (MessageEnum.RA_VNF_EXTRA_PARAM, vnfType, extraParams.toString(), "OpenStack", "", MsoLogger.ErrorCode.DataError, "Extra params"); + inputs.keySet ().removeAll (extraParams); + } + } + // 1607 - when we get here - we have clean inputs. Create inputsTwo in case we have json + Map<String, Object> inputsTwo = null; + if (hasJson && jsonParams.size() > 0) { + inputsTwo = new HashMap<String, Object>(); + for (String keyParamName : inputs.keySet()) { + if (jsonParams.containsKey(keyParamName)) { + inputsTwo.put(keyParamName, jsonParams.get(keyParamName)); + } else { + inputsTwo.put(keyParamName, inputs.get(keyParamName)); + } + } + } + + // "Fix" the template if it has CR/LF (getting this from Oracle) + String template = heatTemplate.getHeatTemplate (); + template = template.replaceAll ("\r\n", "\n"); + + // Have the tenant. Now deploy the stack itself + // Ignore MsoTenantNotFound and MsoStackAlreadyExists exceptions + // because we already checked for those. + long updateStackStarttime = System.currentTimeMillis (); + try { + if (!hasJson) { + heatStack = heatU.updateStack (cloudSiteId, + tenantId, + vfModuleName, + template, + copyStringInputs (inputs), + true, + heatTemplate.getTimeoutMinutes (), + newEnvironmentString, + //heatEnvironmentString, + nestedTemplatesChecked, + heatFilesObjects); + LOGGER.recordMetricEvent (updateStackStarttime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully receive response from Open Stack", "OpenStack", "UpdateStack", null); + } else { + heatStack = heatU.updateStack (cloudSiteId, + tenantId, + vfModuleName, + template, + inputsTwo, + true, + heatTemplate.getTimeoutMinutes (), + newEnvironmentString, + //heatEnvironmentString, + nestedTemplatesChecked, + heatFilesObjects); + LOGGER.recordMetricEvent (updateStackStarttime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully receive response from Open Stack", "OpenStack", "UpdateStack", null); + + } + } catch (MsoException me) { + me.addContext ("UpdateVFModule"); + String error = "Update VFModule " + vfModuleType + " in " + cloudSiteId + "/" + tenantId + ": " + me; + LOGGER.recordMetricEvent (updateStackStarttime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error, "OpenStack", "UpdateStack", null); + LOGGER.error (MessageEnum.RA_UPDATE_VNF_ERR, vfModuleType, cloudSiteId, tenantId, "OpenStack", "", MsoLogger.ErrorCode.DataError, "Exception - " + error, me); + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError, error); + throw new VnfException (me); + } + } + + // Reach this point if updateStack is successful. + // Populate remaining rollback info and response parameters. + vfRollback.setVnfId (heatStack.getCanonicalName ()); + vfRollback.setVnfCreated (true); + + outputs.value = copyStringOutputs (heatStack.getOutputs ()); + rollback.value = vfRollback; + LOGGER.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, "Successfully update VF Module"); + return; + } + + private String getVfModuleNameFromModuleStackId(String vfModuleStackId) { + // expected format of vfModuleStackId is "MSOTEST51-vSAMP3_base_module-0/1fc1f86c-7b35-447f-99a6-c23ec176ae24" + // before the "/" is the vfModuleName and after the "/" is the heat stack id in Openstack + if (vfModuleStackId == null) + return null; + int index = vfModuleStackId.lastIndexOf('/'); + if (index <= 0) + return null; + String vfModuleName = null; + try { + vfModuleName = vfModuleStackId.substring(0, index); + } catch (Exception e) { + vfModuleName = null; + } + return vfModuleName; + } + +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VfRollback.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VfRollback.java new file mode 100644 index 0000000000..90ab01bd8c --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VfRollback.java @@ -0,0 +1,137 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + + +import org.openecomp.mso.entity.MsoRequest; + +public class VfRollback { + private String vnfId; + private String tenantId; + private String cloudSiteId; + private boolean tenantCreated = false; + private boolean vnfCreated = false; + private MsoRequest msoRequest; + private String volumeGroupName; + private String volumeGroupId; + private String requestType; + private String volumeGroupHeatStackId; + private String baseGroupHeatStackId; + private boolean isBase = false; + private String vfModuleStackId; + + + public String getVnfId() { + return vnfId; + } + public void setVnfId(String vnfId) { + this.vnfId = vnfId; + } + public String getTenantId() { + return tenantId; + } + + public void setTenantId(String tenantId) { + this.tenantId = tenantId; + } + public String getCloudSiteId() { + return cloudSiteId; + } + public void setCloudSiteId(String cloudId) { + this.cloudSiteId = cloudId; + } + public boolean getTenantCreated() { + return tenantCreated; + } + public void setTenantCreated(boolean tenantCreated) { + this.tenantCreated = tenantCreated; + } + public boolean getVnfCreated() { + return vnfCreated; + } + public void setVnfCreated(boolean vnfCreated) { + this.vnfCreated = vnfCreated; + } + public MsoRequest getMsoRequest() { + return msoRequest; + } + public void setMsoRequest (MsoRequest msoRequest) { + this.msoRequest = msoRequest; + } + public String getVolumeGroupName() { + return this.volumeGroupName; + } + public void setVolumeGroupName(String volumeGroupName) { + this.volumeGroupName = volumeGroupName; + } + public String getVolumeGroupId() { + return this.volumeGroupId; + } + public void setVolumeGroupId(String volumeGroupId) { + this.volumeGroupId = volumeGroupId; + } + public String getRequestType() { + return this.requestType; + } + public void setRequestType(String requestType) { + this.requestType = requestType; + } + /* + private String volumeGroupHeatStackId; + private String baseGroupHeatStackId; + private boolean isBase = false; + */ + public String getVolumeGroupHeatStackId() { + return this.volumeGroupHeatStackId; + } + public void setVolumeGroupHeatStackId(String volumeGroupHeatStackId) { + this.volumeGroupHeatStackId = volumeGroupHeatStackId; + } + + public String getBaseGroupHeatStackId() { + return this.baseGroupHeatStackId; + } + public void setBaseGroupHeatStackId(String baseGroupHeatStackId) { + this.baseGroupHeatStackId = baseGroupHeatStackId; + } + + public boolean isBase() { + return this.isBase; + } + public void setIsBase(boolean isBase) { + this.isBase = isBase; + } + public String getVfModuleStackId() { + return this.vfModuleStackId; + } + public void setVfModuleStackId(String vfModuleStackId) { + this.vfModuleStackId = vfModuleStackId; + } + + @Override + public String toString() { + return "VfRollback: cloud=" + cloudSiteId + ", tenant=" + tenantId + + ", vnf=" + vnfId + ", tenantCreated=" + tenantCreated + + ", vnfCreated=" + vnfCreated + ", requestType = " + requestType + + ", volumeGroupHeatStackId = " + this.volumeGroupHeatStackId; + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VnfAdapterRest.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VnfAdapterRest.java new file mode 100644 index 0000000000..6906f816a7 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VnfAdapterRest.java @@ -0,0 +1,628 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import java.util.Map; + +import javax.ws.rs.Consumes; +import javax.ws.rs.DELETE; +import javax.ws.rs.GET; +import javax.ws.rs.HEAD; +import javax.ws.rs.POST; +import javax.ws.rs.PUT; +import javax.ws.rs.Path; +import javax.ws.rs.PathParam; +import javax.ws.rs.Produces; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.Response; +import javax.ws.rs.core.GenericEntity; +import javax.ws.rs.core.MediaType; +import javax.xml.ws.Holder; + +import org.apache.http.HttpStatus; + +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; +import org.openecomp.mso.cloud.CloudConfigFactory; +import org.openecomp.mso.entity.MsoRequest; +import org.openecomp.mso.logger.MessageEnum; +import org.openecomp.mso.logger.MsoLogger; +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.openstack.beans.VnfRollback; +import org.openecomp.mso.openstack.exceptions.MsoExceptionCategory; +import org.openecomp.mso.properties.MsoPropertiesFactory; +import org.openecomp.mso.adapters.vnfrest.*; + +/** + * This class services calls to the REST interface for VF Modules (http://host:port/vnfs/rest/v1/vnfs) + * Both XML and JSON can be produced/consumed. Set Accept: and Content-Type: headers appropriately. XML is the default. + * For testing, call with cloudSiteId = ___TESTING___ + * To test exceptions, also set tenantId = ___TESTING___ + */ +@Path("/v1/vnfs") +public class VnfAdapterRest { + private static MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA); + private static final String TESTING_KEYWORD = "___TESTING___"; + private final CloudConfigFactory cloudConfigFactory = new CloudConfigFactory(); + private final MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory(); + private final MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory, cloudConfigFactory); + //TODO Logging, SkipAAI, CREATED flags, Integrate with BPEL, Auth, + + @HEAD + @GET + @Path("/healthcheck") + @Produces(MediaType.TEXT_HTML) + public Response healthcheck () { + String CHECK_HTML = "<!DOCTYPE html><html><head><meta charset=\"ISO-8859-1\"><title>Health Check</title></head><body>Application ready</body></html>"; + return Response.ok().entity(CHECK_HTML).build(); + } + + /* + * URL:http://localhost:8080/vnfs/rest/v1/vnfs/<aaivnfid>/vf-modules/<aaimodid> + * REQUEST: + * {"deleteVfModuleRequest": + {"cloudSiteId": "DAN", + "tenantId": "214b428a1f554c02935e66330f6a5409", + "vnfId": "somevnfid", + "vfModuleId": "somemodid", + "vfModuleStackId": "4e567676-e266-4594-a3a6-131c8a2baf73", + "messageId": "ra.1", + "notificationUrl": "http://localhost:8089/vnfmock", + "skipAAI": true, + "msoRequest": { + "requestId": "ra1", + "serviceInstanceId": "sa1" + }} + } + */ + @DELETE + @Path("{aaiVnfId}/vf-modules/{aaiVfModuleId}") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response deleteVfModule ( + @PathParam("aaiVnfId") String aaiVnfId, + @PathParam("aaiVfModuleId") String aaiVfModuleId, + final DeleteVfModuleRequest req) + { + LOGGER.debug("Delete VfModule enter: " + req.toJsonString()); + if (aaiVnfId == null || !aaiVnfId.equals(req.getVnfId())) { + LOGGER.debug("Req rejected - aaiVnfId not provided or doesn't match URL"); + return Response + .status(HttpStatus.SC_BAD_REQUEST) + .type(MediaType.TEXT_PLAIN) + .entity("vnfid in URL does not match content") + .build(); + } + if (aaiVfModuleId == null || !aaiVfModuleId.equals(req.getVfModuleId())) { + LOGGER.debug("Req rejected - aaiVfModuleId not provided or doesn't match URL"); + return Response + .status(HttpStatus.SC_BAD_REQUEST) + .type(MediaType.TEXT_PLAIN) + .entity("vfModuleId in URL does not match content") + .build(); + } + DeleteVfModuleTask task = new DeleteVfModuleTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling delete, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, "", "deleteVfModule", MsoLogger.ErrorCode.BusinessProcesssError, "Exception in deleteVfModule", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("deleteVNFVolumes exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class DeleteVfModuleTask implements Runnable { + private final DeleteVfModuleRequest req; + private DeleteVfModuleResponse response = null; + private VfModuleExceptionResponse eresp = null; + private boolean sendxml; + + public DeleteVfModuleTask(DeleteVfModuleRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<DeleteVfModuleResponse>(response) {} + : new GenericEntity<VfModuleExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + + @Override + public void run() { + try { + String cloudsite = req.getCloudSiteId(); + if (cloudsite != null && !cloudsite.equals(TESTING_KEYWORD)) { + //vnfAdapter.deleteVnf (req.getCloudSiteId(), req.getTenantId(), req.getVfModuleStackId(), req.getMsoRequest()); + vnfAdapter.deleteVfModule (req.getCloudSiteId(), req.getTenantId(), req.getVfModuleStackId(), req.getMsoRequest()); + } + response = new DeleteVfModuleResponse(req.getVnfId(), req.getVfModuleId(), Boolean.TRUE, req.getMessageId()); + } catch (VnfException e) { + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "VnfException - Delete VNF Module", e); + eresp = new VfModuleExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.TRUE, req.getMessageId()); + } + if (!req.isSynchronous()) { + BpelRestClient bpelClient = new BpelRestClient(); + bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug ("Delete vfModule exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + + /* + * URL:http://localhost:8080/vnfs/rest/v1/vnfs/<aaiVnfId>/vf-modules/<aaiVfModuleId>?cloudSiteId=DAN&tenantId=vfModule?&skipAAI=TRUE&msoRequest.requestId=ra1&msoRequest.serviceInstanceId=si1&vfModuleName=T2N2S1 + * RESP: + * {"queryVfModuleResponse": { + "vfModuleId": "AvfmodId", + "vfModuleOutputs": {"entry": { + "key": "server_private_ip_1", + "value": "10.100.1.25" + }}, + "vfModuleStackId": "RaaVnf1/abfa8a6d-feb1-40af-aea3-109403b1cf6b", + "vnfId": "AvnfID", + "vnfStatus": "ACTIVE" + }} + */ + @GET + @Path("{aaiVnfId}/vf-modules/{aaiVfModuleId}") + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response queryVfModule( + @PathParam("aaiVnfId") String aaiVnfId, + @PathParam("aaiVfModuleId") String aaiVfModuleId, + @QueryParam("cloudSiteId") String cloudSiteId, + @QueryParam("tenantId") String tenantId, + @QueryParam("vfModuleName") String vfModuleName, //RAA? Id in doc + @QueryParam("skipAAI") Boolean skipAAI, + @QueryParam("msoRequest.requestId") String requestId, + @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId) + { + //This request responds synchronously only + LOGGER.debug ("Query vfModule enter:" + vfModuleName); + MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId); + + try { + int respStatus = HttpStatus.SC_OK; + QueryVfModuleResponse qryResp = new QueryVfModuleResponse(aaiVnfId, aaiVfModuleId, null, null, null); + Holder<Boolean> vnfExists = new Holder<Boolean>(); + Holder<String> vfModuleId = new Holder<String>(); + Holder<VnfStatus> status = new Holder<VnfStatus>(); + Holder<Map<String, String>> outputs = new Holder <Map <String, String>> (); + vnfAdapter.queryVnf (cloudSiteId, tenantId, vfModuleName, msoRequest, vnfExists, vfModuleId, status, outputs); + if (!vnfExists.value) { + LOGGER.debug ("vfModule not found"); + respStatus = HttpStatus.SC_NOT_FOUND; + } else { + LOGGER.debug ("vfModule found" + vfModuleId.value + ", status=" + status.value); + qryResp.setVfModuleId(vfModuleId.value); + qryResp.setVnfStatus(status.value); + qryResp.setVfModuleOutputs(outputs.value); + } + LOGGER.debug ("Query vfModule exit"); + return Response + .status(respStatus) + .entity(new GenericEntity<QueryVfModuleResponse>(qryResp) {}) + .build(); + } catch (VnfException e) { + LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, vfModuleName, "", "queryVfModule", MsoLogger.ErrorCode.BusinessProcesssError, "VnfException - queryVfModule", e); + VfModuleExceptionResponse excResp = new VfModuleExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.FALSE, null); + return Response + .status(HttpStatus.SC_INTERNAL_SERVER_ERROR) + .entity(new GenericEntity<VfModuleExceptionResponse>(excResp) {}) + .build(); + } + } + + /*URL: http://localhost:8080/vnfs/rest/v1/vnfs/<aaivnfid>/vf-modules + *REQUEST: + * {"createVfModuleRequest": + {"cloudSiteId": "DAN", + "tenantId": "214b428a1f554c02935e66330f6a5409", + "vnfId": "somevnfid", + "vfModuleId": "somemodid", + "vfModuleName": "RaaVnf1", + "vnfType": "ApacheVnf", + "vfModuleParams": {"entry": [ + {"key": "network_id", + "value": "59ed7b41-2983-413f-ba93-e7d437433916"}, + {"key": "subnet_id", + "value": "086c9298-5c57-49b7-bb2b-6fd5730c5d92"}, + {"key": "server_name_0", + "value": "RaaVnf1"} + ]}, + "failIfExists": true, + "messageId": "ra.1", + "notificationUrl": "http://localhost:8089/vnfmock", + "skipAAI": true, + "msoRequest": { + "requestId": "ra1", + "serviceInstanceId": "sa1" + }} + } + */ + @POST + @Path("{aaiVnfId}/vf-modules") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response createVfModule( + @PathParam("aaiVnfId") String aaiVnfId, + final CreateVfModuleRequest req) + { + LOGGER.debug("Create VfModule enter inside VnfAdapterRest: " + req.toJsonString()); + if (aaiVnfId == null || !aaiVnfId.equals(req.getVnfId())) { + LOGGER.debug("Req rejected - aaiVnfId not provided or doesn't match URL"); + return Response + .status(HttpStatus.SC_BAD_REQUEST) + .type(MediaType.TEXT_PLAIN) + .entity("vnfid in URL does not match content") + .build(); + } + CreateVfModuleTask task = new CreateVfModuleTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_CREATE_VNF_ERR, "", "createVfModule", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - createVfModule", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("createVfModule exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class CreateVfModuleTask implements Runnable { + private final CreateVfModuleRequest req; + private CreateVfModuleResponse response = null; + private VfModuleExceptionResponse eresp = null; + private boolean sendxml; + + public CreateVfModuleTask(CreateVfModuleRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<CreateVfModuleResponse>(response) {} + : new GenericEntity<VfModuleExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + + @Override + public void run() { + LOGGER.debug ("CreateVfModuleTask start"); + try { + // Synchronous Web Service Outputs + Holder <String> vfModuleStackId = new Holder <String> (); + Holder <Map <String, String>> outputs = new Holder <Map <String, String>> (); + Holder <VnfRollback> vnfRollback = new Holder <VnfRollback> (); + String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType(); + LOGGER.debug("completeVnfVfModuleType=" + completeVnfVfModuleType); + String cloudsite = req.getCloudSiteId(); + if (cloudsite != null && cloudsite.equals(TESTING_KEYWORD)) { + String tenant = req.getTenantId(); + if (tenant != null && tenant.equals(TESTING_KEYWORD)) { + throw new VnfException("testing."); + } + vnfRollback.value = new VnfRollback(req.getVnfId(), tenant, cloudsite, + true, false, new MsoRequest("reqid", "svcid"), + req.getVolumeGroupId(), req.getVolumeGroupId(), req.getRequestType()); + vfModuleStackId.value = "479D3D8B-6360-47BC-AB75-21CC91981484"; + outputs.value = VolumeAdapterRest.testMap(); + } else { +// vnfAdapter.createVnf (createReq.getCloudSiteId(), +// createReq.getTenantId(), +// createReq.getVnfType(), +// createReq.getVnfVersion(), +// createReq.getVfModuleName(), +// createReq.getRequestType(), +// createReq.getVolumeGroupStackId(), +// createReq.getVfModuleParams(), +// createReq.getFailIfExists(), +// createReq.getBackout(), +// createReq.getMsoRequest(), +// vfModuleStackId, +// outputs, +// vnfRollback); + vnfAdapter.createVfModule(req.getCloudSiteId(), + req.getTenantId(), + //req.getVnfType(), + completeVnfVfModuleType, + req.getVnfVersion(), + req.getVfModuleName(), + req.getRequestType(), + req.getVolumeGroupStackId(), + req.getBaseVfModuleStackId(), + req.getVfModuleParams(), + req.getFailIfExists(), + req.getBackout(), + req.getMsoRequest(), + vfModuleStackId, + outputs, + vnfRollback); + } + VfModuleRollback modRollback = new VfModuleRollback(vnfRollback.value, req.getVfModuleId(), vfModuleStackId.value, req.getMessageId()); + response = new CreateVfModuleResponse(req.getVnfId(), req.getVfModuleId(), + vfModuleStackId.value, Boolean.TRUE, outputs.value, modRollback, req.getMessageId()); + } catch (VnfException e) { + eresp = new VfModuleExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.TRUE, req.getMessageId()); + } + if (!req.isSynchronous()) { + BpelRestClient bpelClient = new BpelRestClient(); + bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug ("CreateVfModuleTask exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + + @PUT + @Path("{aaiVnfId}/vf-modules/{aaiVfModuleId}") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response updateVfModule( + @PathParam("aaiVnfId") String aaiVnfId, + @PathParam("aaiVfModuleId") String aaiVfModuleId, + final UpdateVfModuleRequest req) + { + LOGGER.debug("Update VfModule enter: " + req.toJsonString()); + UpdateVfModulesTask task = new UpdateVfModulesTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_UPDATE_VNF_ERR, "", "updateVfModule", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - updateVfModule", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("updateVfModules exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class UpdateVfModulesTask implements Runnable { + private final UpdateVfModuleRequest req; + private UpdateVfModuleResponse response = null; + private VfModuleExceptionResponse eresp = null; + private boolean sendxml; + + public UpdateVfModulesTask(UpdateVfModuleRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<UpdateVfModuleResponse>(response) {} + : new GenericEntity<VfModuleExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + @Override + public void run() { + try { + //MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl (msoPropertiesFactory, cloudConfigFactory); + + // Synchronous Web Service Outputs + Holder <String> vfModuleStackId = new Holder <String> (); + Holder <Map <String, String>> outputs = new Holder <Map <String, String>> (); + Holder <VnfRollback> vnfRollback = new Holder <VnfRollback> (); + String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType(); + LOGGER.debug("in updateVf - completeVnfVfModuleType=" + completeVnfVfModuleType); + + /* + vnfAdapter.updateVnf (updateReq.getCloudSiteId(), + updateReq.getTenantId(), + updateReq.getVnfType(), + updateReq.getVnfVersion(), + updateReq.getVfModuleName(), + updateReq.getRequestType(), + updateReq.getVolumeGroupStackId(), + updateReq.getVfModuleParams(), + updateReq.getMsoRequest(), + outputs, + vnfRollback); + */ + vnfAdapter.updateVfModule (req.getCloudSiteId(), + req.getTenantId(), + //req.getVnfType(), + completeVnfVfModuleType, + req.getVnfVersion(), + req.getVfModuleName(), + req.getRequestType(), + req.getVolumeGroupStackId(), + req.getBaseVfModuleId(), + req.getVfModuleStackId(), + req.getVfModuleParams(), + req.getMsoRequest(), + outputs, + vnfRollback); + + response = new UpdateVfModuleResponse(req.getVnfId(), req.getVfModuleId(), + vfModuleStackId.value, outputs.value, req.getMessageId()); + } catch (VnfException e) { + eresp = new VfModuleExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.TRUE, req.getMessageId()); + } + if (!req.isSynchronous()) { + // This is asynch, so POST response back to caller + BpelRestClient bpelClient = new BpelRestClient (); + bpelClient.bpelPost (getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug ("Update VfModule exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + /* + * URL:http://localhost:8080/vnfs/rest/v1/vnfs/<aaivnfid>/vf-modules/<aaimodid>/rollback + * REQUEST: + * {"deleteVfModuleRequest": + {"cloudSiteId": "DAN", + "tenantId": "214b428a1f554c02935e66330f6a5409", + "vnfId": "somevnfid", + "vfModuleId": "somemodid", + "vfModuleStackId": "4e567676-e266-4594-a3a6-131c8a2baf73", + "messageId": "ra.1", + "notificationUrl": "http://localhost:8089/vnfmock", + "skipAAI": true, + "msoRequest": { + "requestId": "ra1", + "serviceInstanceId": "sa1" + }} + } + */ + @DELETE + @Path("{aaiVnfId}/vf-modules/{aaiVfModuleId}/rollback") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response rollbackVfModule ( + @PathParam("aaiVnfId") String aaiVnfId, + @PathParam("aaiVfModuleId") String aaiVfModuleId, + //@QueryParam("rollback") String rollback, + final RollbackVfModuleRequest req) + { + LOGGER.debug("Rollback VfModule enter: " + req.toJsonString()); + RollbackVfModulesTask task = new RollbackVfModulesTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_ROLLBACK_VNF_ERR, "", "rollbackVfModule", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - rollbackVfModule", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("rollbackVfModule exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class RollbackVfModulesTask implements Runnable { + private final RollbackVfModuleRequest req; + private RollbackVfModuleResponse response = null; + private VfModuleExceptionResponse eresp = null; + private boolean sendxml; + + public RollbackVfModulesTask(RollbackVfModuleRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<RollbackVfModuleResponse>(response) {} + : new GenericEntity<VfModuleExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + @Override + public void run() { + try { + VfModuleRollback vmr = req.getVfModuleRollback(); + VnfRollback vrb = new VnfRollback( + vmr.getVfModuleStackId(), vmr.getTenantId(), vmr.getCloudSiteId(), true, true, + vmr.getMsoRequest(), null, null, null); + vnfAdapter.rollbackVnf (vrb); + response = new RollbackVfModuleResponse(Boolean.TRUE, req.getMessageId()); + } catch (VnfException e) { + LOGGER.error (MessageEnum.RA_ROLLBACK_VNF_ERR, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - rollbackVfModule", e); + eresp = new VfModuleExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, false, req.getMessageId()); + } + if (!req.isSynchronous()) { + // This is asynch, so POST response back to caller + BpelRestClient bpelClient = new BpelRestClient (); + bpelClient.bpelPost (getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug ("RollbackVfModulesTask exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VolumeAdapterRest.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VolumeAdapterRest.java new file mode 100644 index 0000000000..8fa1552bb0 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/VolumeAdapterRest.java @@ -0,0 +1,576 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf; + + +import java.util.HashMap; +import java.util.Map; + +import javax.ws.rs.Consumes; +import javax.ws.rs.DELETE; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.PUT; +import javax.ws.rs.Path; +import javax.ws.rs.PathParam; +import javax.ws.rs.Produces; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.GenericEntity; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import javax.xml.ws.Holder; + +import org.apache.http.HttpStatus; + +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; +import org.openecomp.mso.adapters.vnfrest.CreateVolumeGroupRequest; +import org.openecomp.mso.adapters.vnfrest.CreateVolumeGroupResponse; +import org.openecomp.mso.adapters.vnfrest.DeleteVolumeGroupRequest; +import org.openecomp.mso.adapters.vnfrest.DeleteVolumeGroupResponse; +import org.openecomp.mso.adapters.vnfrest.QueryVolumeGroupResponse; +import org.openecomp.mso.adapters.vnfrest.RollbackVolumeGroupRequest; +import org.openecomp.mso.adapters.vnfrest.RollbackVolumeGroupResponse; +import org.openecomp.mso.adapters.vnfrest.UpdateVolumeGroupRequest; +import org.openecomp.mso.adapters.vnfrest.UpdateVolumeGroupResponse; +import org.openecomp.mso.adapters.vnfrest.VolumeGroupExceptionResponse; +import org.openecomp.mso.adapters.vnfrest.VolumeGroupRollback; +import org.openecomp.mso.cloud.CloudConfigFactory; +import org.openecomp.mso.entity.MsoRequest; +import org.openecomp.mso.logger.MessageEnum; +import org.openecomp.mso.logger.MsoLogger; +import org.openecomp.mso.openstack.beans.VnfRollback; +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.openstack.exceptions.MsoExceptionCategory; +import org.openecomp.mso.properties.MsoPropertiesFactory; + +/** + * This class services calls to the REST interface for VNF Volumes (http://host:port/vnfs/rest/v1/volume-groups) + * Both XML and JSON can be produced/consumed. Set Accept: and Content-Type: headers appropriately. XML is the default. + * For testing, call with cloudSiteId = ___TESTING___ + * To test exceptions, also set tenantId = ___TESTING___ + */ +@Path("/v1/volume-groups") +public class VolumeAdapterRest { + private static final MsoLogger LOGGER = MsoLogger.getMsoLogger(MsoLogger.Catalog.RA); + private static final String TESTING_KEYWORD = "___TESTING___"; + private final CloudConfigFactory cloudConfigFactory = new CloudConfigFactory(); + private final MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory(); + private final MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl(msoPropertiesFactory, cloudConfigFactory); + + @POST + @Path("") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response createVNFVolumes(final CreateVolumeGroupRequest req) { + LOGGER.debug("createVNFVolumes enter: " + req.toJsonString()); + CreateVNFVolumesTask task = new CreateVNFVolumesTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_CREATE_VNF_ERR, "", "createVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - createVNFVolumes", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("createVNFVolumes exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class CreateVNFVolumesTask implements Runnable { + private final CreateVolumeGroupRequest req; + private CreateVolumeGroupResponse response = null; + private VolumeGroupExceptionResponse eresp = null; + private boolean sendxml; + + public CreateVNFVolumesTask(CreateVolumeGroupRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<CreateVolumeGroupResponse>(response) {} + : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + @Override + public void run() { + LOGGER.debug ("CreateVFModule VolumesTask start"); + try { + // Synchronous Web Service Outputs + Holder<String> stackId = new Holder<String>(); + Holder<Map<String, String>> outputs = new Holder<Map<String, String>>(); + Holder<VnfRollback> vnfRollback = new Holder<VnfRollback>(); + String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType(); + LOGGER.debug("in createVfModuleVolumes - completeVnfVfModuleType=" + completeVnfVfModuleType); + + String cloudsite = req.getCloudSiteId(); + if (cloudsite != null && cloudsite.equals(TESTING_KEYWORD)) { + String tenant = req.getTenantId(); + if (tenant != null && tenant.equals(TESTING_KEYWORD)) { + throw new VnfException("testing."); + } + stackId.value = "479D3D8B-6360-47BC-AB75-21CC91981484"; + outputs.value = testMap(); + } else { +// vnfAdapter.createVnf( +// req.getCloudSiteId(), +// req.getTenantId(), +// req.getVnfType(), +// req.getVnfVersion(), +// req.getVolumeGroupName(), +// "VOLUME", // request type is VOLUME +// null, // not sure about this +// req.getVolumeGroupParams(), +// req.getFailIfExists(), +// req.getSuppressBackout(), +// req.getMsoRequest(), +// stackId, +// outputs, +// vnfRollback); + vnfAdapter.createVfModule( + req.getCloudSiteId(), //cloudSiteId, + req.getTenantId(), //tenantId, + //req.getVnfType(), //vnfType, + completeVnfVfModuleType, + req.getVnfVersion(), //vnfVersion, + req.getVolumeGroupName(), //vnfName, + "VOLUME", //requestType, + null, //volumeGroupHeatStackId, + null, //baseVfHeatStackId, + req.getVolumeGroupParams(), //inputs, + req.getFailIfExists(), //failIfExists, + req.getSuppressBackout(), //backout, + req.getMsoRequest(), // msoRequest, + stackId, + outputs, + vnfRollback); + } + VolumeGroupRollback rb = new VolumeGroupRollback( + req.getVolumeGroupId(), + stackId.value, + true, // TODO boolean volumeGroupCreated, when would it be false? + req.getTenantId(), + req.getCloudSiteId(), + req.getMsoRequest(), + req.getMessageId()); + response = new CreateVolumeGroupResponse( + req.getVolumeGroupId(), + stackId.value, + true, // TODO boolean volumeGroupCreated, when would it be false? + outputs.value, + rb, + req.getMessageId()); + } catch (VnfException e) { + eresp = new VolumeGroupExceptionResponse( + e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId()); + } + if (!req.isSynchronous()) { + // This is asynch, so POST response back to caller + BpelRestClient bpelClient = new BpelRestClient(); + bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug ("CreateVFModule VolumesTask exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + + @DELETE + @Path("{aaiVolumeGroupId}") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response deleteVNFVolumes( + @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId, + final DeleteVolumeGroupRequest req + ) + { + LOGGER.debug("deleteVNFVolumes enter: " + req.toJsonString()); + if (aaiVolumeGroupId == null || !aaiVolumeGroupId.equals(req.getVolumeGroupId())) { + return Response + .status(HttpStatus.SC_BAD_REQUEST) + .type(MediaType.TEXT_PLAIN) + .entity("VolumeGroupId in URL does not match content") + .build(); + } + DeleteVNFVolumesTask task = new DeleteVNFVolumesTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_DELETE_VNF_ERR, "", "deleteVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - deleteVNFVolumes", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("deleteVNFVolumes exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class DeleteVNFVolumesTask implements Runnable { + private final DeleteVolumeGroupRequest req; + private DeleteVolumeGroupResponse response = null; + private VolumeGroupExceptionResponse eresp = null; + private boolean sendxml; + + public DeleteVNFVolumesTask(DeleteVolumeGroupRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<DeleteVolumeGroupResponse>(response) {} + : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + @Override + public void run() { + LOGGER.debug("DeleteVNFVolumesTask start"); + try { + if (!req.getCloudSiteId().equals(TESTING_KEYWORD)) { + vnfAdapter.deleteVnf(req.getCloudSiteId(), req.getTenantId(), req.getVolumeGroupStackId(), req.getMsoRequest()); + } + response = new DeleteVolumeGroupResponse(true, req.getMessageId()); + } catch (VnfException e) { + eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId()); + } + if (!req.isSynchronous()) { + // This is asynch, so POST response back to caller + BpelRestClient bpelClient = new BpelRestClient(); + bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug("DeleteVNFVolumesTask exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + + @DELETE + @Path("{aaiVolumeGroupId}/rollback") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response rollbackVNFVolumes( + @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId, + final RollbackVolumeGroupRequest req + ) + { + LOGGER.debug("rollbackVNFVolumes enter: " + req.toJsonString()); + if (aaiVolumeGroupId == null || req.getVolumeGroupRollback() == null || !aaiVolumeGroupId.equals(req.getVolumeGroupRollback().getVolumeGroupId())) { + return Response + .status(HttpStatus.SC_BAD_REQUEST) + .type(MediaType.TEXT_PLAIN) + .entity("VolumeGroupId in URL does not match content") + .build(); + } + RollbackVNFVolumesTask task = new RollbackVNFVolumesTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_ROLLBACK_VNF_ERR, "", "rollbackVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - rollbackVNFVolumes", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug("rollbackVNFVolumes exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class RollbackVNFVolumesTask implements Runnable { + private final RollbackVolumeGroupRequest req; + private RollbackVolumeGroupResponse response = null; + private VolumeGroupExceptionResponse eresp = null; + private boolean sendxml; + + public RollbackVNFVolumesTask(RollbackVolumeGroupRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<RollbackVolumeGroupResponse>(response) {} + : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + @Override + public void run() { + LOGGER.debug("DeleteVNFVolumesTask start"); + try { + VolumeGroupRollback vgr = req.getVolumeGroupRollback(); + VnfRollback vrb = new VnfRollback( + vgr.getVolumeGroupStackId(), vgr.getTenantId(), vgr.getCloudSiteId(), true, true, + vgr.getMsoRequest(), null, null, null); + vnfAdapter.rollbackVnf(vrb); + response = new RollbackVolumeGroupResponse(true, req.getMessageId()); + } catch (VnfException e) { + eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId()); + } + if (!req.isSynchronous()) { + // This is asynch, so POST response back to caller + BpelRestClient bpelClient = new BpelRestClient(); + bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug("DeleteVNFVolumesTask exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + + @PUT + @Path("{aaiVolumeGroupId}") + @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response updateVNFVolumes( + @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId, + final UpdateVolumeGroupRequest req + ) + { + LOGGER.debug("updateVNFVolumes enter: " + req.toJsonString()); + if (aaiVolumeGroupId == null || !aaiVolumeGroupId.equals(req.getVolumeGroupId())) { + return Response + .status(HttpStatus.SC_BAD_REQUEST) + .type(MediaType.TEXT_PLAIN) + .entity("VolumeGroupId in URL does not match content") + .build(); + } + UpdateVNFVolumesTask task = new UpdateVNFVolumesTask(req); + if (req.isSynchronous()) { + // This is a synchronous request + task.run(); + return Response + .status(task.getStatusCode()) + .entity(task.getGenericEntityResponse()) + .build(); + } else { + // This is an asynchronous request + try { + Thread t1 = new Thread(task); + t1.start(); + } catch (Exception e) { + // problem handling create, send generic failure as sync resp to caller + LOGGER.error (MessageEnum.RA_UPDATE_VNF_ERR, "", "updateVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - updateVNFVolumes", e); + return Response.serverError().build(); + } + // send sync response (ACK) to caller + LOGGER.debug ("updateVNFVolumes exit"); + return Response.status(HttpStatus.SC_ACCEPTED).build(); + } + } + + public class UpdateVNFVolumesTask implements Runnable { + private final UpdateVolumeGroupRequest req; + private UpdateVolumeGroupResponse response = null; + private VolumeGroupExceptionResponse eresp = null; + private boolean sendxml; + + public UpdateVNFVolumesTask(UpdateVolumeGroupRequest req) { + this.req = req; + this.sendxml = true; // can be set with a field or header later + } + public int getStatusCode() { + return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST; + } + public Object getGenericEntityResponse() { + return (response != null) + ? new GenericEntity<UpdateVolumeGroupResponse>(response) {} + : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {}; + } + private String getResponse() { + if (response != null) { + return sendxml ? response.toXmlString() : response.toJsonString(); + } else { + return sendxml ? eresp.toXmlString() : eresp.toJsonString(); + } + } + @Override + public void run() { + LOGGER.debug("UpdateVNFVolumesTask start"); + try { + @SuppressWarnings("unused") + Holder<String> stackId = new Holder<String> (); + Holder<Map<String, String>> outputs = new Holder<Map <String, String>> (); + Holder<VnfRollback> vnfRollback = new Holder<VnfRollback> (); + String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType(); + LOGGER.debug("in updateVfModuleVolume - completeVnfVfModuleType=" + completeVnfVfModuleType); + + if (req.getCloudSiteId().equals(TESTING_KEYWORD)) { + outputs.value = testMap(); + } else { + //vnfAdapter.updateVnf( + // req.getCloudSiteId(), + // req.getTenantId(), + // req.getVnfType(), + // req.getVnfVersion(), + // req.getVfModuleType(), + // "VOLUME", // request type is VOLUME + // req.getVolumeGroupStackId(), + // req.getVolumeGroupParams(), + // req.getMsoRequest(), + // outputs, + // vnfRollback); + vnfAdapter.updateVfModule (req.getCloudSiteId(), + req.getTenantId(), + //req.getVnfType(), + completeVnfVfModuleType, + req.getVnfVersion(), + req.getVolumeGroupStackId(), + "VOLUME", + null, + null, + req.getVolumeGroupStackId(), + req.getVolumeGroupParams(), + req.getMsoRequest(), + outputs, + vnfRollback); + } + response = new UpdateVolumeGroupResponse( + req.getVolumeGroupId(), req.getVolumeGroupStackId(), + outputs.value, req.getMessageId()); + } catch (VnfException e) { + eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId()); + } + if (!req.isSynchronous()) { + // This is asynch, so POST response back to caller + BpelRestClient bpelClient = new BpelRestClient(); + bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml); + } + LOGGER.debug("UpdateVNFVolumesTask exit: code=" + getStatusCode() + ", resp="+ getResponse()); + } + } + + @GET + @Path("{aaiVolumeGroupId}") + @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) + public Response queryVNFVolumes( + @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId, + @QueryParam("cloudSiteId") String cloudSiteId, + @QueryParam("tenantId") String tenantId, + @QueryParam("volumeGroupStackId") String volumeGroupStackId, + @QueryParam("skipAAI") Boolean skipAAI, + @QueryParam("msoRequest.requestId") String requestId, + @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId + ) + { + //This request responds synchronously only + LOGGER.debug ("queryVNFVolumes enter:" + aaiVolumeGroupId + " " + volumeGroupStackId); + MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId); + + try { + int respStatus = HttpStatus.SC_OK; + QueryVolumeGroupResponse qryResp = new QueryVolumeGroupResponse(aaiVolumeGroupId, volumeGroupStackId, null, null); + Holder<Boolean> vnfExists = new Holder<Boolean>(); + Holder<String> vfModuleId = new Holder<String>(); + Holder<VnfStatus> status = new Holder<VnfStatus>(); + Holder<Map<String, String>> outputs = new Holder<Map<String, String>>(); + if (cloudSiteId != null && cloudSiteId.equals(TESTING_KEYWORD)) { + if (tenantId != null && tenantId.equals(TESTING_KEYWORD)) { + throw new VnfException("testing."); + } + vnfExists.value = true; + vfModuleId.value = TESTING_KEYWORD; + status.value = VnfStatus.ACTIVE; + outputs.value = testMap(); + } else { + vnfAdapter.queryVnf(cloudSiteId, tenantId, volumeGroupStackId, msoRequest, vnfExists, vfModuleId, status, outputs); + } + if (!vnfExists.value) { + LOGGER.debug ("VNFVolumes not found"); + qryResp.setVolumeGroupStatus(status.value); + respStatus = HttpStatus.SC_NOT_FOUND; + } else { + LOGGER.debug ("VNFVolumes found " + vfModuleId.value + ", status=" + status.value); + qryResp.setVolumeGroupStatus(status.value); + qryResp.setVolumeGroupOutputs(outputs.value); + } + LOGGER.debug("Query queryVNFVolumes exit"); + return Response + .status(respStatus) + .entity(new GenericEntity<QueryVolumeGroupResponse>(qryResp) {}) + .build(); + } catch (VnfException e) { + LOGGER.error(MessageEnum.RA_QUERY_VNF_ERR, aaiVolumeGroupId, "", "queryVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "VnfException - queryVNFVolumes", e); + VolumeGroupExceptionResponse excResp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.FALSE, null); + LOGGER.debug("Query queryVNFVolumes exit"); + return Response + .status(HttpStatus.SC_INTERNAL_SERVER_ERROR) + .entity(new GenericEntity<VolumeGroupExceptionResponse>(excResp) {}) + .build(); + } + } + public static Map<String, String> testMap() { + Map<String, String> m = new HashMap<String, String>(); + m.put("mickey", "7"); + m.put("clyde", "10"); + m.put("wayne", "99"); + return m; + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfAlreadyExists.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfAlreadyExists.java new file mode 100644 index 0000000000..7cec0cd99e --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfAlreadyExists.java @@ -0,0 +1,42 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.exceptions; + + + +import javax.xml.ws.WebFault; + +/** + * This class reports an exception when trying to create a VNF when another + * VNF of the same name already exists in the target cloud/tenant. Note that + * the createVnf method suppresses this exception by default. + * + * + */ +@WebFault (name="VnfAlreadyExists", faultBean="org.openecomp.mso.adapters.vnf.exceptions.VnfExceptionBean", targetNamespace="http://com.att.mso/vnf") +public class VnfAlreadyExists extends VnfException { + + private static final long serialVersionUID = 1L; + + public VnfAlreadyExists (String name, String cloudId, String tenantId, String vnfId) { + super("VNF " + name + " already exists in cloud/tenant " + cloudId + "/" + tenantId + " with ID " + vnfId); + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfException.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfException.java new file mode 100644 index 0000000000..ceef76b468 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfException.java @@ -0,0 +1,80 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.exceptions; + + + +import javax.xml.ws.WebFault; + +import org.openecomp.mso.openstack.exceptions.MsoException; +import org.openecomp.mso.openstack.exceptions.MsoExceptionCategory; + +/** + * This class simply extends Exception (without addition additional functionality) + * to provide an identifier for VNF related exceptions on create, delete, query. + * + * + */ +@WebFault (name="VnfException", faultBean="org.openecomp.mso.adapters.vnf.exceptions.VnfExceptionBean", targetNamespace="http://com.att.mso/vnf") +public class VnfException extends Exception { + + private static final long serialVersionUID = 1L; + + private VnfExceptionBean faultInfo; + + public VnfException (String msg) { + super(msg); + faultInfo = new VnfExceptionBean (msg); + } + + public VnfException (Throwable e) { + super(e); + faultInfo = new VnfExceptionBean (e.getMessage()); + } + + public VnfException (String msg, Throwable e) { + super (msg, e); + faultInfo = new VnfExceptionBean (msg); + } + + public VnfException (String msg, MsoExceptionCategory category) { + super(msg); + faultInfo = new VnfExceptionBean (msg, category); + } + + public VnfException (String msg, MsoExceptionCategory category, Throwable e) { + super (msg, e); + faultInfo = new VnfExceptionBean (msg, category); + } + + public VnfException (MsoException e) { + super (e); + faultInfo = new VnfExceptionBean (e.getContextMessage(), e.getCategory()); + } + + public VnfExceptionBean getFaultInfo() { + return faultInfo; + } + + public void setFaultInfo(VnfExceptionBean faultInfo) { + this.faultInfo = faultInfo; + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfExceptionBean.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfExceptionBean.java new file mode 100644 index 0000000000..15918eabb8 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfExceptionBean.java @@ -0,0 +1,73 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.exceptions; + + +import java.io.Serializable; + +import org.openecomp.mso.openstack.exceptions.MsoExceptionCategory; + +/** + * Jax-WS Fault Bean for Vnf Exception + */ +public class VnfExceptionBean implements Serializable { + + private static final long serialVersionUID = -5699310749783790095L; + + private String message; + private MsoExceptionCategory category; + private Boolean rolledBack; + + public VnfExceptionBean () {} + + public VnfExceptionBean (String message) { + this.message = message; + } + + public VnfExceptionBean (String message, MsoExceptionCategory category) { + this.message = message; + this.category = category; + } + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + public MsoExceptionCategory getCategory () { + return category; + } + + public void setCategory (MsoExceptionCategory category) { + this.category = category; + } + + public Boolean isRolledBack() { + return rolledBack; + } + + public void setRolledBack(Boolean rolledBack) { + this.rolledBack = rolledBack; + } +} diff --git a/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfNotFound.java b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfNotFound.java new file mode 100644 index 0000000000..3c27d03daa --- /dev/null +++ b/adapters/mso-vnf-adapter/src/main/java/org/openecomp/mso/adapters/vnf/exceptions/VnfNotFound.java @@ -0,0 +1,43 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.exceptions; + + +import javax.xml.ws.WebFault; + +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; + +/** + * This class reports an exception when trying to update a Network that does + * not exist in the target cloud/tenant. Note that deleteNetwork suppresses + * this exception (deletion of non-existent network is considered a success). + * + * + */ +@WebFault (name="VnfNotFound", faultBean="org.openecomp.mso.adapters.vnf.exceptions.VnfExceptionBean", targetNamespace="http://com.att.mso/vnf") +public class VnfNotFound extends VnfException { + + private static final long serialVersionUID = 1L; + + public VnfNotFound (String cloudId, String tenantId, String vnfName) { + super("VNF " + vnfName + " not found in cloud/tenant " + cloudId + "/" + tenantId); + } +} diff --git a/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/QueryTest.java b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/QueryTest.java new file mode 100644 index 0000000000..96e50d0959 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/QueryTest.java @@ -0,0 +1,64 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.test; + + +import java.util.Map; + +import javax.xml.ws.Holder; + +import org.openecomp.mso.adapters.vnf.MsoVnfAdapter; +import org.openecomp.mso.adapters.vnf.MsoVnfAdapterImpl; +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; + +public class QueryTest { + public final static void main (String args[]) + { + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl(); + log ("Got a VnfAdapter"); + + String cloudId = "MT"; + String tenantId = "MSO_Test"; + String vnfName = "VNF_TEST1"; + Holder<Boolean> vnfExists = new Holder<Boolean>(); + Holder<String> vnfId = new Holder<String>(); + Holder<VnfStatus> status = new Holder<VnfStatus>(); + Holder<Map<String,String>> outputs = new Holder<Map<String,String>>(); + + try { + vnfAdapter.queryVnf(cloudId, tenantId, vnfName, null, + vnfExists, vnfId, status, outputs); + } catch (VnfException e) { + log ("Got an Exception: " + e); + } + + if (! vnfExists.value){ + log ("VNF Not Found"); + } else { + log ("Found VNF, ID = " + vnfId.value + ", status=" + status.value); + } + } + + private static void log (String msg) { + System.out.println (msg); + } +} diff --git a/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfCreateTest.java b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfCreateTest.java new file mode 100644 index 0000000000..02691726d8 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfCreateTest.java @@ -0,0 +1,87 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.test; + + +import java.util.HashMap; +import java.util.Map; + +import javax.xml.ws.Holder; + +import org.openecomp.mso.adapters.vnf.MsoVnfAdapter; +import org.openecomp.mso.adapters.vnf.MsoVnfAdapterImpl; +import org.openecomp.mso.openstack.beans.VnfRollback; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; + +public class VnfCreateTest { + public final static void main (String args[]) + { + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl(); + log ("Got a VnfAdapter"); + + // Web Service Inputs + String cloudId = "MT"; + String tenantName = "John_Test"; + String vnfType = "ApacheDemo"; + String vnfName = "AdapterTest"; + Map<String,String> inputs = new HashMap<String,String>(); + inputs.put("vnf_id", "abc"); + inputs.put("extra", "whocares"); + inputs.put("private_subnet_gateway", "10.4.1.1"); + inputs.put("private_subnet_cidr", "10.4.1.0/29"); + + // Web Service Outputs + Holder<String> vnfId = new Holder<String>(); + Holder<Map<String,String>> outputs = new Holder<Map<String,String>>(); + Holder<VnfRollback> vnfRollback = new Holder<VnfRollback>(); + + try { + vnfAdapter.createVnf(cloudId, tenantName, vnfType,null, vnfName, null, null, inputs, false, true, null, + vnfId, outputs, vnfRollback); + } catch (VnfException e) { + log ("Got a Create Exception: " + e); + System.exit(1); + } + + log ("Created VNF, ID = " + vnfId.value); + for (String key : outputs.value.keySet()) { + log (" " + key + " = " + outputs.value.get(key)); + } + if (vnfRollback.value != null) + log (vnfRollback.value.toString()); + + try { + Thread.sleep(5000); + } catch (InterruptedException e) {} + + log ("Rolling Back VNF"); + try { + vnfAdapter.rollbackVnf(vnfRollback.value); + } catch (VnfException e) { + log ("Got a Rollback Exception: " + e); + } + log ("VNF Rolled Back"); + } + + private static void log (String msg) { + System.out.println (msg); + } +} diff --git a/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfDeleteTest.java b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfDeleteTest.java new file mode 100644 index 0000000000..0c35da7f64 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfDeleteTest.java @@ -0,0 +1,52 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.test; + + + +import org.openecomp.mso.adapters.vnf.MsoVnfAdapter; +import org.openecomp.mso.adapters.vnf.MsoVnfAdapterImpl; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; + +public class VnfDeleteTest { + public final static void main (String args[]) + { + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl(); + log ("Got a VnfAdapter"); + + // Web Service Inputs + String cloudId = "MT"; + String tenantName = "MSO_Test"; + String vnfName = "AdapterTest"; + + try { + vnfAdapter.deleteVnf(cloudId, tenantName, vnfName, null); + } catch (VnfException e) { + log ("Got an Exception: " + e); + } + + log ("Deleted VNF"); + } + + private static void log (String msg) { + System.out.println (msg); + } +} diff --git a/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfQueryTest.java b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfQueryTest.java new file mode 100644 index 0000000000..923c222f60 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/test/java/org/openecomp/mso/adapters/vnf/test/VnfQueryTest.java @@ -0,0 +1,64 @@ +/*- + * ============LICENSE_START======================================================= + * OPENECOMP - MSO + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.mso.adapters.vnf.test; + + +import java.util.Map; + +import javax.xml.ws.Holder; + +import org.openecomp.mso.adapters.vnf.MsoVnfAdapter; +import org.openecomp.mso.adapters.vnf.MsoVnfAdapterImpl; +import org.openecomp.mso.openstack.beans.VnfStatus; +import org.openecomp.mso.adapters.vnf.exceptions.VnfException; + +public class VnfQueryTest { + public final static void main (String args[]) + { + MsoVnfAdapter vnfAdapter = new MsoVnfAdapterImpl(); + log ("Got a VnfAdapter"); + + String cloudId = "MT"; + String tenantId = "MSO_Test"; + String vnfName = "VNF_TEST1"; + Holder<Boolean> vnfExists = new Holder<Boolean>(); + Holder<String> vnfId = new Holder<String>(); + Holder<VnfStatus> status = new Holder<VnfStatus>(); + Holder<Map<String,String>> outputs = new Holder<Map<String,String>>(); + + try { + vnfAdapter.queryVnf(cloudId, tenantId, vnfName, null, + vnfExists, vnfId, status, outputs); + } catch (VnfException e) { + log ("Got an Exception: " + e); + } + + if (! vnfExists.value){ + log ("VNF Not Found"); + } else { + log ("Found VNF, ID = " + vnfId.value + ", status=" + status.value); + } + } + + private static void log (String msg) { + System.out.println (msg); + } +} diff --git a/adapters/mso-vnf-adapter/src/test/resources/META-INF/services/com.woorea.openstack.base.client.OpenStackClientConnector b/adapters/mso-vnf-adapter/src/test/resources/META-INF/services/com.woorea.openstack.base.client.OpenStackClientConnector new file mode 100644 index 0000000000..1281d32948 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/test/resources/META-INF/services/com.woorea.openstack.base.client.OpenStackClientConnector @@ -0,0 +1 @@ +com.woorea.openstack.connector.HttpClientConnector
\ No newline at end of file diff --git a/adapters/mso-vnf-adapter/src/test/resources/logback-test.xml b/adapters/mso-vnf-adapter/src/test/resources/logback-test.xml new file mode 100644 index 0000000000..238980e0c4 --- /dev/null +++ b/adapters/mso-vnf-adapter/src/test/resources/logback-test.xml @@ -0,0 +1,48 @@ +<!-- + ============LICENSE_START======================================================= + ECOMP MSO + ================================================================================ + Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + ================================================================================ + 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. + ============LICENSE_END========================================================= + --> + +<configuration > + + + <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> + <encoder> + <pattern>%d{MM/dd-HH:mm:ss.SSS}|%X{RequestId}|%X{ServiceInstanceId}|%thread|%X{ServiceName}|%X{InstanceUUID}|%.-5level|%X{AlertSeverity}||%X{ServerIPAddress}|%X{ServerFQDN}|%X{RemoteHost}||%X{Timer}|%msg%n</pattern> + </encoder> + </appender> + + + <logger name="com.att.eelf.audit" level="info" additivity="false"> + <appender-ref ref="STDOUT" /> + </logger> + + <logger name="com.att.eelf.metrics" level="info" additivity="false"> + <appender-ref ref="STDOUT" /> + </logger> + + <logger name="com.att.eelf.error" level="trace" additivity="false"> + <appender-ref ref="STDOUT" /> + </logger> + + <root level="info"> + <appender-ref ref="STDOUT" /> + </root> + + +</configuration> |