"vm_id": ""
},
{
- "vim_id": ""
+ "vm_id": ""
}
]
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright 2018 Huawei Technologies Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.csm.vnf;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.restclient.SystemEnvVariablesFactory;
+import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.Constant;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.sf.json.JSONArray;
+import net.sf.json.JSONException;
+import net.sf.json.JSONObject;
+
+/**
+ * <br>
+ * <p>
+ * </p>
+ *
+ * @author
+ * @version VFC 1.0 2018年5月17日
+ */
+public abstract class ScaleManager {
+
+ private static final Logger LOG = LoggerFactory.getLogger(ScaleManager.class);
+
+ private static String VM_IDS_PATH =
+ SystemEnvVariablesFactory.getInstance().getAppRoot() + System.getProperty(Constant.FILE_SEPARATOR) + "etc"
+ + System.getProperty(Constant.FILE_SEPARATOR) + "vnfpkginfo"
+ + System.getProperty(Constant.FILE_SEPARATOR) + "vms" + System.getProperty(Constant.FILE_SEPARATOR);
+
+ public static void beforeScaleOut(JSONObject queryVms, String vnfId) {
+ try {
+ JSONArray vms = queryVms.getJSONObject("data").getJSONArray("vms");
+ writeVmIdsToFile(vnfId, vms);
+ } catch(JSONException e) {
+ LOG.error("function=beforeScaleOut, msg=recode current vms JSONException");
+ }
+ }
+
+ public static JSONArray beforeScaleIn(JSONObject queryVms, String vnfId) {
+ JSONArray vmList = new JSONArray();
+ try {
+ JSONArray vms = queryVms.getJSONObject("data").getJSONArray("vms");
+ JSONArray recodeVms = readVmIdsFile(vnfId);
+ if(!recodeVms.isEmpty()) {
+ for(int i = 0; i < vms.size(); i++) {
+ JSONObject obj = vms.getJSONObject(i);
+ String vmId = obj.getString("id");
+ if(isScaleOutVm(recodeVms, vmId)) {
+ JSONObject vmIdObj = new JSONObject();
+ vmIdObj.put("vm_id", vmId);
+ vmList.add(vmIdObj);
+ }
+ }
+ }
+ } catch(JSONException e) {
+ LOG.error("function=beforeScaleIn, msg=recode current vms JSONException");
+ }
+ return vmList;
+ }
+
+ private static boolean isScaleOutVm(JSONArray recodeVms, String vmId) {
+ for(int i = 0; i < recodeVms.size(); i++) {
+ JSONObject obj = recodeVms.getJSONObject(i);
+ String oldVmId = obj.getString("id");
+ if(oldVmId.equalsIgnoreCase(vmId)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static String getVmIdsFilePath(String vnfId) {
+ return VM_IDS_PATH + vnfId + ".json";
+ }
+
+ private static void writeVmIdsToFile(String vnfId, JSONArray vms) {
+ String filePath = getVmIdsFilePath(vnfId);
+ FileOutputStream outStream = null;
+ try {
+ File destFile = FileUtils.getFile(filePath);
+
+ File parentFile = destFile.getParentFile();
+ if(parentFile != null) {
+ if(!parentFile.mkdirs() && !parentFile.isDirectory()) {
+ throw new IOException("Destination '" + parentFile + "' directory cannot be created");
+ }
+ }
+ if(!destFile.exists()) {
+ destFile.createNewFile();
+ }
+ outStream = new FileOutputStream(destFile);
+ outStream.write(vms.toString().getBytes());
+ } catch(IOException e) {
+ LOG.error("function=writeVmIdsToFile, msg=write vms to file ioexception, e : {}", e);
+ } finally {
+ IOUtils.closeQuietly(outStream);
+ }
+ }
+
+ private static JSONArray readVmIdsFile(String vnfId) {
+ String filePath = getVmIdsFilePath(vnfId);
+ InputStream ins = null;
+ BufferedInputStream bins = null;
+ String fileContent = "";
+ try {
+ ins = FileUtils.openInputStream(FileUtils.getFile(filePath));
+ bins = new BufferedInputStream(ins);
+
+ byte[] contentByte = new byte[ins.available()];
+ int num = bins.read(contentByte);
+
+
+ if(num > 0) {
+ fileContent = new String(contentByte);
+ }
+
+ if(StringUtils.isNotEmpty(fileContent)) {
+ return JSONArray.fromObject(fileContent);
+ }
+ } catch(IOException e) {
+ LOG.error("function=readVmIdsFile, msg=read vms from file IOException, filePath : {}", filePath);
+ } catch(JSONException e) {
+ LOG.error("function=readVmIdsFile, msg=read vms from file JSONException, fileContent : {}", fileContent);
+ } finally {
+ IOUtils.closeQuietly(bins);
+ IOUtils.closeQuietly(ins);
+ }
+ return new JSONArray();
+ }
+}
@Override
public JSONObject scaleVnf(JSONObject vnfObject, JSONObject vnfmObject, String vnfmId, String vnfInstanceId) {
LOG.warn("function=scaleVnf, msg=enter to scale a vnf");
+
+ JSONObject queryVms = ResultRequestUtil.call(vnfmObject,
+ String.format(ParamConstants.VNF_GET_VMINFO, vnfInstanceId), Constant.GET, null, Constant.CERTIFICATE);
+ LOG.info("function=scaleVnf, msg=query vms result=" + queryVms);
+
JSONObject restJson = new JSONObject();
restJson.put(Constant.RETCODE, Constant.REST_FAIL);
String path = String.format(ParamConstants.VNF_SCALE, vnfInstanceId);
JSONObject scaleInfo = new JSONObject();
JSONArray vduList = new JSONArray();
JSONObject vdu = new JSONObject();
- vdu.put("vdu_type", this.getVduType(vnfmObject, vnfInstanceId));
+
+ if(vnfObject.containsKey("configedVduType")) {
+ vdu.put("vdu_type", vnfObject.getString("configedVduType"));
+ } else {
+ vdu.put("vdu_type", this.getVduType(vnfmObject, queryVms));
+ }
vdu.put("h_steps", vnfObject.get("numberOfSteps"));
vduList.add(vdu);
scaleInfo.put("vnf_id", vnfInstanceId);
try {
// JSONObject additionalParam = vnfObject.getJSONObject("additionalParam");
// vmList = additionalParam.getJSONArray("vm_list");
- vmList = AdapterResourceManager.readScaleInVmIdFromJson().getJSONArray("vm_list");
+ vmList = ScaleManager.beforeScaleIn(queryVms, vnfInstanceId);
+ if(vmList.isEmpty()) {
+ vmList = AdapterResourceManager.readScaleInVmIdFromJson().getJSONArray("vm_list");
+ }
} catch(JSONException e) {
LOG.error("the param 'additionalParam' or 'vm_list' not found,please check it", e);
}
if(null != vmList && !vmList.isEmpty()) {
scaleInfo.put("vm_list", vmList);
}
+ } else if(scaleType == PARAM_ONE) {
+ ScaleManager.beforeScaleOut(queryVms, vnfInstanceId);
}
paramJson.put("scale_info", scaleInfo);
JSONObject queryResult =
return restJson;
}
- private String getVduType(JSONObject vnfmObject, String vnfInstanceId) {
+ private String getVduType(JSONObject vnfmObject, JSONObject queryResult) {
String vduType = "";
try {
- JSONObject queryResult =
- ResultRequestUtil.call(vnfmObject, String.format(ParamConstants.VNF_GET_VMINFO, vnfInstanceId),
- Constant.GET, null, Constant.CERTIFICATE);
- LOG.info("getVduType result=" + queryResult);
vduType = queryResult.getJSONObject("data").getJSONArray("vms").getJSONObject(0).getString("vdu_type");
} catch(Exception e) {
LOG.error("get vdu_type failed.", e);
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
+import org.apache.commons.lang3.StringUtils;
import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.ResultRequestUtil;
import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmUtil;
import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.adapter.impl.AdapterResourceManager;
this.vnfmDao = vnfmDao;
}
+ private String configedVduType;
+
+
+ /**
+ * @param configedVduType The configedVduType to set.
+ */
+ public void setConfigedVduType(String configedVduType) {
+ this.configedVduType = configedVduType;
+ }
+
/**
* Scale vnf
*
LOG.error("function=scaleVNF,can't find vnfm from db by vnfmId=" + vnfmId);
return restJson;
}
+ if(StringUtils.isNotEmpty(configedVduType)) {
+ vnfObject.put("configedVduType", configedVduType);
+ }
restJson = (new VnfMgrVnfm()).scaleVnf(vnfObject, vnfmObjcet, vnfmId, vnfInstanceId);
} catch(JSONException e) {
LOG.error("function=scaleVNF, msg=JSONException occurs, e={}.", e);
JSONObject responseJson = new JSONObject();
JSONObject jobInfoJson = new JSONObject();
JSONObject jobInfo = restJson.getJSONObject("data").getJSONObject("job_info");
- jobInfoJson.put("jobId", jobInfo.getString("job_id"));
+ jobInfoJson.put("jobId", jobInfo.getString("job_id") + ":job");
responseJson.put("progress", jobInfo.getString("task_progress_rate"));
- responseJson.put("status", jobInfo.getString("task_status"));
+
+ String taskStatus = jobInfo.getString("task_status");
+ if(taskStatus.equalsIgnoreCase("Successfully") || taskStatus.equalsIgnoreCase("finished")) {
+ responseJson.put("status", "finished");
+ } else if(taskStatus.equalsIgnoreCase("Failed")) {
+ responseJson.put("status", "error");
+ } else {
+ responseJson.put("status", "processing");
+ }
responseJson.put("errorCode", jobInfo.getString("error_code"));
responseJson.put("responseId", jobInfo.getString("task_progress_rate"));
jobInfoJson.put("responsedescriptor", responseJson);
JSONObject vm = vmList.getJSONObject(i);
LOG.info("function=callLcmNotify, vm: {}", vm);
JSONObject affectedVm = new JSONObject();
- affectedVm.put("vnfcInstanceId", vm.getString("vm_id"));
+ String vimVimId = vm.getString("vim_vm_id");
+ affectedVm.put("vnfcInstanceId", vimVimId);
affectedVm.put("changeType", changeType);
affectedVm.put("vimid", vimId);
- affectedVm.put("vmid", vm.getString("vm_id"));
+ affectedVm.put("vmid", vimVimId);
affectedVm.put("vmname", vm.getString("vm_name"));
- affectedVm.put("vduid", vm.getString("vm_id"));
+ affectedVm.put("vduid", vimVimId);
LOG.info("function=callLcmNotify, affectedVm: {}", affectedVm);
affectedVnfc.add(affectedVm);
}
public String getJob(@PathParam("jobId") String jobId, @PathParam("vnfmId") String vnfmId,
@Context HttpServletResponse resp, @QueryParam("@responseId") String responseId) {
LOG.warn("function=getJob, msg=enter to get a job: jobId: {}, responseId: {}", jobId, responseId);
- return getJob(jobId, vnfmId, resp);
+ return getJobProcess(jobId, vnfmId, resp, jobId);
}
/**
* @return
* @since VFC 1.0
*/
- private String getJob(String jobId, String vnfmId, HttpServletResponse resp) {
+ private String getJobProcess(String jobId, String vnfmId, HttpServletResponse resp, String orgJobId) {
JSONObject restJson = new JSONObject();
if(StringUtils.isEmpty(jobId) || StringUtils.isEmpty(vnfmId)) {
restJson = vnfMgr.getJob(jobId, vnfmId);
if(restJson.getInt(Constant.RETCODE) == Constant.REST_FAIL) {
- LOG.error("function=getJob, msg=getJob fail");
+ LOG.error("function=getJobProcess, msg=getJob fail");
resp.setStatus(Constant.HTTP_INNERERROR);
return restJson.toString();
}
- return getJobBody(restJson, jobId);
+ return getJobBody(restJson, orgJobId);
}
/**
LOG.warn("function=getJobFromVnfm, msg=enter to get a job: jobId: {}, responseId: {}", jobId, responseId);
String[] temps = jobId.split(":");
String tmpJobId = temps[0];
- String flag = temps[1];
+ String flag = "";
+ if(temps.length > 1) {
+ flag = temps[1];
+ }
LOG.warn("function=getJobFromVnfm, tmpJobId: {}, flag: {}", tmpJobId, flag);
if(flag.equalsIgnoreCase("no")) {
- return getJob(tmpJobId, vnfmId, resp);
+ return getJobProcess(tmpJobId, vnfmId, resp, jobId);
} else {
JSONObject restJson = vnfMgr.getJobFromVnfm(tmpJobId, vnfmId);
--- /dev/null
+vnf.scaleout.config.vdutype=
\ No newline at end of file
<import resource="classpath:META-INF/cxf/cxf.xml"/>
<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
+ <context:property-placeholder location="classpath:jdbc.properties" ignore-unresolvable="true"/>
+
<bean id="jsonProvider" class="org.codehaus.jackson.jaxrs.JacksonJsonProvider"/>
<bean id="source" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<bean id="vnfMgr" class="org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.process.VnfMgr">
<property name="vnfmDao" ref="vnfmDao"></property>
+ <property name="configedVduType" value="${vnf.scaleout.config.vdutype}"></property>
</bean>
<bean id="VnfRoa" class="org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.rest.VnfRoa">
Code Review / vfc / nfvo / driver / vnfm / svnfm.git / commitdiff