@Override
public VirtualNetworkFunctionRecord stopVNFCInstance(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord, VNFCInstance vnfcInstance)
throws Exception {
log.info("Stopping vnfc instance: " + vnfcInstance.getHostname());
if (VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), Event.STOP)
!= null) {
if (VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), Event.STOP)
.getLifecycle_events()
!= null) {
String output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEvent(virtualNetworkFunctionRecord, vnfcInstance, Event.STOP)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info(
"Executed script for STOP on VNFC Instance "
+ vnfcInstance.getHostname()
+ ". Output was: \n\n"
+ output);
}
}
return virtualNetworkFunctionRecord;
}
@Override
public VirtualNetworkFunctionRecord start(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord) throws Exception {
log.info("Starting vnfr: " + virtualNetworkFunctionRecord.getName());
if (VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), Event.START)
!= null) {
if (VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.START)
.getLifecycle_events()
!= null) {
String output = "\n--------------------\n--------------------\n";
for (String result : executeScriptsForEvent(virtualNetworkFunctionRecord, Event.START)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for START. Output was: \n\n" + output);
}
}
return virtualNetworkFunctionRecord;
}
@Override
public VirtualNetworkFunctionRecord instantiate(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord,
Object scripts,
Map<String, Collection<VimInstance>> vimInstances)
throws Exception {
log.info(
"Instantiation of VirtualNetworkFunctionRecord " + virtualNetworkFunctionRecord.getName());
if (null != scripts) {
this.saveScriptOnEms(virtualNetworkFunctionRecord, scripts);
}
for (VirtualDeploymentUnit virtualDeploymentUnit : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : virtualDeploymentUnit.getVnfc_instance()) {
log.debug("VNFCInstance: " + vnfcInstance);
}
}
String output = "\n--------------------\n--------------------\n";
for (String result : executeScriptsForEvent(virtualNetworkFunctionRecord, Event.INSTANTIATE)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for INSTANTIATE. Output was: \n\n" + output);
return virtualNetworkFunctionRecord;
}
public Iterable<String> executeScriptsForEvent(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord, Event event)
throws Exception { // TODO make it parallel
Map<String, String> env = getMap(virtualNetworkFunctionRecord);
Collection<String> res = new ArrayList<>();
LifecycleEvent le =
VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), event);
if (le != null) {
log.trace(
"The number of scripts for "
+ virtualNetworkFunctionRecord.getName()
+ " are: "
+ le.getLifecycle_events());
for (String script : le.getLifecycle_events()) {
log.info(
"Sending script: "
+ script
+ " to VirtualNetworkFunctionRecord: "
+ virtualNetworkFunctionRecord.getName());
for (VirtualDeploymentUnit vdu : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : vdu.getVnfc_instance()) {
Map<String, String> tempEnv = new HashMap<>();
for (Ip ip : vnfcInstance.getIps()) {
log.debug("Adding net: " + ip.getNetName() + " with value: " + ip.getIp());
tempEnv.put(ip.getNetName(), ip.getIp());
}
log.debug("adding floatingIp: " + vnfcInstance.getFloatingIps());
for (Ip fip : vnfcInstance.getFloatingIps()) {
tempEnv.put(fip.getNetName() + "_floatingIp", fip.getIp());
}
tempEnv.put("hostname", vnfcInstance.getHostname());
tempEnv = modifyUnsafeEnvVarNames(tempEnv);
env.putAll(tempEnv);
log.info("Environment Variables are: " + env);
String command = getJsonObject("EXECUTE", script, env).toString();
String output =
executeActionOnEMS(
vnfcInstance.getHostname(),
command,
virtualNetworkFunctionRecord,
vnfcInstance);
res.add(output);
saveLogToFile(virtualNetworkFunctionRecord, script, vnfcInstance, output);
for (String key : tempEnv.keySet()) {
env.remove(key);
}
}
}
}
}
return res;
}
protected void saveVirtualNetworkFunctionRecord() {
log.trace(
"ACTION is: " + action + " and the VNFR id is: " + virtualNetworkFunctionRecord.getId());
if (virtualNetworkFunctionRecord.getId() == null)
virtualNetworkFunctionRecord =
networkServiceRecordRepository.addVnfr(
virtualNetworkFunctionRecord, virtualNetworkFunctionRecord.getParent_ns_id());
else virtualNetworkFunctionRecord = vnfrRepository.save(virtualNetworkFunctionRecord);
}
@Override
public VirtualNetworkFunctionRecord heal(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord,
VNFCInstance component,
String cause)
throws Exception {
if ("switchToStandby".equals(cause)) {
for (VirtualDeploymentUnit virtualDeploymentUnit : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : virtualDeploymentUnit.getVnfc_instance()) {
if (vnfcInstance.getId().equals(component.getId())
&& "standby".equalsIgnoreCase(vnfcInstance.getState())) {
log.debug("Activation of the standby component");
if (VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.START)
!= null) {
log.debug(
"Executed scripts for event START "
+ this.executeScriptsForEvent(
virtualNetworkFunctionRecord, component, Event.START));
}
log.debug("Changing the status from standby to active");
// This is inside the vnfr
vnfcInstance.setState("ACTIVE");
// This is a copy of the object received as parameter and modified.
// It will be sent to the orchestrator
component.setState("ACTIVE");
break;
}
}
}
} else if (VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.HEAL)
!= null) {
if (VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), Event.HEAL)
.getLifecycle_events()
!= null) {
log.debug("Heal method started");
log.info("-----------------------------------------------------------------------");
String output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEvent(virtualNetworkFunctionRecord, component, Event.HEAL, cause)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for HEAL. Output was: \n\n" + output);
log.info("-----------------------------------------------------------------------");
}
}
return virtualNetworkFunctionRecord;
}
private Map<String, String> getMap(VirtualNetworkFunctionRecord virtualNetworkFunctionRecord) {
Map<String, String> res = new HashMap<>();
for (ConfigurationParameter configurationParameter :
virtualNetworkFunctionRecord.getProvides().getConfigurationParameters()) {
res.put(configurationParameter.getConfKey(), configurationParameter.getValue());
}
for (ConfigurationParameter configurationParameter :
virtualNetworkFunctionRecord.getConfigurations().getConfigurationParameters()) {
res.put(configurationParameter.getConfKey(), configurationParameter.getValue());
}
res = modifyUnsafeEnvVarNames(res);
return res;
}
protected void changeStatus() {
log.debug("Action is: " + action);
Status status = null;
switch (action) {
case ALLOCATE_RESOURCES:
status = Status.NULL;
break;
case SCALE_IN:
break;
case SCALING:
status = Status.SCALING;
break;
case ERROR:
status = Status.ERROR;
break;
case MODIFY:
status = Status.INACTIVE;
break;
case RELEASE_RESOURCES:
status = Status.TERMINATED;
break;
case GRANT_OPERATION:
status = Status.NULL;
break;
case INSTANTIATE:
status = Status.INITIALIZED;
break;
case SCALED:
status = Status.ACTIVE;
break;
case RELEASE_RESOURCES_FINISH:
status = Status.TERMINATED;
break;
case INSTANTIATE_FINISH:
status = Status.ACTIVE;
break;
case CONFIGURE:
break;
case START:
status = Status.ACTIVE;
break;
}
virtualNetworkFunctionRecord.setStatus(status);
log.debug(
"Changing status of VNFR: "
+ virtualNetworkFunctionRecord.getName()
+ " ( "
+ virtualNetworkFunctionRecord.getId()
+ " ) to "
+ status);
}
@Override
public void run() {
changeStatus();
try {
this.doWork();
} catch (Exception e) {
VnfmSender vnfmSender;
try {
vnfmSender =
this.getVnfmSender(
vnfmRegister.getVnfm(virtualNetworkFunctionRecord.getEndpoint()).getEndpointType());
} catch (NotFoundException e1) {
e1.printStackTrace();
throw new RuntimeException(e1);
}
NFVMessage message = new OrVnfmErrorMessage(virtualNetworkFunctionRecord, e.getMessage());
if (getTempDestination() != null) {
vnfmSender.sendCommand(message, getTempDestination());
} else {
try {
vnfmSender.sendCommand(
message, vnfmRegister.getVnfm(virtualNetworkFunctionRecord.getEndpoint()));
} catch (NotFoundException e1) {
e1.printStackTrace();
throw new RuntimeException(e1);
}
}
if (!log.isTraceEnabled())
log.error("There was an uncaught exception. Message is: " + e.getMessage());
else log.error("There was an uncaught exception. ", e);
EventFinishEvent eventFinishEvent = new EventFinishEvent();
eventFinishEvent.setAction(Action.ERROR);
virtualNetworkFunctionRecord.setStatus(Status.ERROR);
eventFinishEvent.setVirtualNetworkFunctionRecord(virtualNetworkFunctionRecord);
EventFinishNFVO event = new EventFinishNFVO(this);
event.setEventNFVO(eventFinishEvent);
this.publisher.publishEvent(event);
return;
}
/** Send event finish */
EventFinishEvent eventFinishEvent = new EventFinishEvent();
eventFinishEvent.setAction(action);
eventFinishEvent.setVirtualNetworkFunctionRecord(virtualNetworkFunctionRecord);
EventFinishNFVO event = new EventFinishNFVO(this);
event.setEventNFVO(eventFinishEvent);
this.publisher.publishEvent(event);
}
public void stop(String nsr_id) {
log.debug("Stopping ExecutionTask for all VNFRs of NSR with id: " + nsr_id);
NetworkServiceRecord nsr = null;
try {
nsr = nfvoRequestor.getNetworkServiceRecordAgent().findById(nsr_id);
} catch (SDKException e) {
log.error(e.getMessage(), e);
} catch (ClassNotFoundException e) {
log.error(e.getMessage(), e);
}
if (nsr != null && nsr.getVnfr() != null) {
for (VirtualNetworkFunctionRecord vnfr : nsr.getVnfr()) {
stop(nsr_id, vnfr.getId());
}
}
log.info("Stopped all ExecutionTasks for NSR with id: " + nsr_id);
}
@Override
public VirtualNetworkFunctionRecord modify(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord, VNFRecordDependency dependency)
throws Exception {
log.trace(
"VirtualNetworkFunctionRecord VERSION is: " + virtualNetworkFunctionRecord.getHb_version());
log.info("executing modify for VNFR: " + virtualNetworkFunctionRecord.getName());
log.debug("Got dependency: " + dependency);
log.debug("Parameters are: ");
for (Entry<String, DependencyParameters> entry : dependency.getParameters().entrySet()) {
log.debug("Source type: " + entry.getKey());
log.debug("Parameters: " + entry.getValue().getParameters());
}
if (VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.CONFIGURE)
!= null) {
log.debug(
"LifeCycle events: "
+ VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.CONFIGURE)
.getLifecycle_events());
log.info("-----------------------------------------------------------------------");
String output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEvent(virtualNetworkFunctionRecord, Event.CONFIGURE, dependency)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for CONFIGURE. Output was: \n\n" + output);
log.info("-----------------------------------------------------------------------");
} else {
log.debug("No LifeCycle events for Event.CONFIGURE");
}
return virtualNetworkFunctionRecord;
}
@Override
public VirtualNetworkFunctionRecord updateSoftware(
Script script, VirtualNetworkFunctionRecord virtualNetworkFunctionRecord) throws Exception {
for (VirtualDeploymentUnit vdu : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : vdu.getVnfc_instance()) {
updateScript(script, virtualNetworkFunctionRecord, vnfcInstance);
}
}
return virtualNetworkFunctionRecord;
}
public void saveScriptOnEms(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord, Object scripts) throws Exception {
log.debug("Scripts are: " + scripts.getClass().getName());
if (scripts instanceof String) {
String scriptLink = (String) scripts;
log.debug("Scripts are: " + scriptLink);
JsonObject jsonMessage = getJsonObject("CLONE_SCRIPTS", scriptLink, this.scriptPath);
for (VirtualDeploymentUnit virtualDeploymentUnit : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : virtualDeploymentUnit.getVnfc_instance()) {
executeActionOnEMS(
vnfcInstance.getHostname(),
jsonMessage.toString(),
virtualNetworkFunctionRecord,
vnfcInstance);
}
}
} else if (scripts instanceof Set) {
Iterable<Script> scriptSet = (Set<Script>) scripts;
for (Script script : scriptSet) {
log.debug("Sending script encoded base64 ");
String base64String = Base64.encodeBase64String(script.getPayload());
log.trace("The base64 string is: " + base64String);
JsonObject jsonMessage =
getJsonObjectForScript("SAVE_SCRIPTS", base64String, script.getName(), this.scriptPath);
for (VirtualDeploymentUnit virtualDeploymentUnit : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : virtualDeploymentUnit.getVnfc_instance()) {
executeActionOnEMS(
vnfcInstance.getHostname(),
jsonMessage.toString(),
virtualNetworkFunctionRecord,
vnfcInstance);
}
}
}
}
}
// When the EMS reveive a script which terminate the vnf, the EMS is still running.
// Once the vnf is terminated NFVO requests deletion of resources (MANO B.5) and the EMS will be
// terminated.
@Override
public VirtualNetworkFunctionRecord terminate(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord) throws Exception {
log.debug("Termination of VNF: " + virtualNetworkFunctionRecord.getName());
if (VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.TERMINATE)
!= null) {
String output = "\n--------------------\n--------------------\n";
for (String result : executeScriptsForEvent(virtualNetworkFunctionRecord, Event.TERMINATE)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for TERMINATE. Output was: \n\n" + output);
}
return virtualNetworkFunctionRecord;
}
@Override
protected void fillSpecificProvides(VirtualNetworkFunctionRecord virtualNetworkFunctionRecord) {
for (ConfigurationParameter configurationParameter :
virtualNetworkFunctionRecord.getProvides().getConfigurationParameters()) {
if (!configurationParameter.getConfKey().startsWith("#nfvo:")) {
configurationParameter.setValue(String.valueOf((int) (Math.random() * 100)));
log.debug(
"Setting: "
+ configurationParameter.getConfKey()
+ " with value: "
+ configurationParameter.getValue());
}
}
}
@Override
public void handleError(VirtualNetworkFunctionRecord virtualNetworkFunctionRecord) {
log.error("Received Error for VNFR " + virtualNetworkFunctionRecord.getName());
if (VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), Event.ERROR)
!= null) {
String output = "\n--------------------\n--------------------\n";
try {
for (String result : executeScriptsForEvent(virtualNetworkFunctionRecord, Event.ERROR)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
} catch (Exception e) {
e.printStackTrace();
log.error("Exception executing Error handling");
}
output += "\n--------------------\n";
log.info("Executed script for ERROR. Output was: \n\n" + output);
}
}
private VirtualNetworkFunctionRecord createVirtualNetworkFunctionRecord() {
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord = new VirtualNetworkFunctionRecord();
virtualNetworkFunctionRecord.setMonitoring_parameter(
new HashSet<String>() {
{
add("monitor1");
add("monitor2");
add("monitor3");
}
});
VNFDeploymentFlavour vdf = new VNFDeploymentFlavour();
vdf.setExtId("mocked_vdu_ext_id");
vdf.setFlavour_key("mocked_flavor_name_1");
virtualNetworkFunctionRecord.setName("mocked_vnfr");
virtualNetworkFunctionRecord.setDeployment_flavour_key(vdf.getFlavour_key());
virtualNetworkFunctionRecord.setVdu(new HashSet<VirtualDeploymentUnit>());
VimInstance vimInstance = createVimInstance();
for (int i = 1; i <= 3; i++) {
virtualNetworkFunctionRecord.getVdu().add(createVDU(i, vimInstance));
}
return virtualNetworkFunctionRecord;
}
public static VirtualNetworkFunctionRecord createVirtualNetworkFunctionRecord(
VirtualNetworkFunctionDescriptor vnfd,
String flavourKey,
String nsr_id,
Set<VirtualLinkRecord> vlr,
Map<String, Collection<VimInstance>> vimInstances)
throws NotFoundException, BadFormatException {
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord = new VirtualNetworkFunctionRecord();
virtualNetworkFunctionRecord.setLifecycle_event_history(
new LinkedList<HistoryLifecycleEvent>());
virtualNetworkFunctionRecord.setParent_ns_id(nsr_id);
virtualNetworkFunctionRecord.setName(vnfd.getName());
virtualNetworkFunctionRecord.setType(vnfd.getType());
Configuration configuration = new Configuration();
if (vnfd.getConfigurations() != null) {
configuration.setName(vnfd.getConfigurations().getName());
} else configuration.setName(virtualNetworkFunctionRecord.getName());
configuration.setConfigurationParameters(new HashSet<ConfigurationParameter>());
if (vnfd.getConfigurations() != null) {
for (ConfigurationParameter configurationParameter :
vnfd.getConfigurations().getConfigurationParameters()) {
ConfigurationParameter cp = new ConfigurationParameter();
cp.setConfKey(configurationParameter.getConfKey());
cp.setValue(configurationParameter.getValue());
configuration.getConfigurationParameters().add(cp);
}
}
virtualNetworkFunctionRecord.setConfigurations(configuration);
virtualNetworkFunctionRecord.setCyclicDependency(vnfd.hasCyclicDependency());
Configuration requires = new Configuration();
requires.setName("requires");
requires.setConfigurationParameters(new HashSet<ConfigurationParameter>());
virtualNetworkFunctionRecord.setRequires(requires);
if (vnfd.getRequires() != null) {
for (String vnfdName : vnfd.getRequires().keySet()) {
for (String key : vnfd.getRequires().get(vnfdName).getParameters()) {
ConfigurationParameter configurationParameter = new ConfigurationParameter();
log.debug("Adding " + key + " to requires");
configurationParameter.setConfKey(key);
virtualNetworkFunctionRecord
.getRequires()
.getConfigurationParameters()
.add(configurationParameter);
}
}
}
Configuration provides = new Configuration();
provides.setConfigurationParameters(new HashSet<ConfigurationParameter>());
provides.setName("provides");
virtualNetworkFunctionRecord.setProvides(provides);
if (vnfd.getProvides() != null) {
for (String key : vnfd.getProvides()) {
ConfigurationParameter configurationParameter = new ConfigurationParameter();
log.debug("Adding " + key + " to provides");
configurationParameter.setConfKey(key);
virtualNetworkFunctionRecord
.getProvides()
.getConfigurationParameters()
.add(configurationParameter);
}
}
// if (vnfd.getVnfPackageLocation() != null) {
// VNFPackage vnfPackage = new VNFPackage();
// vnfPackage.setImageLink(vnfd.getVnfPackageLocation().getImageLink());
// vnfPackage.setScriptsLink(vnfd.getVnfPackageLocation().getScriptsLink());
// vnfPackage.setName(vnfd.getVnfPackageLocation().getName());
//
// //TODO check for ordering
// vnfPackage.setScripts(new HashSet<Script>());
//
// for (Script script : vnfd.getVnfPackageLocation().getScripts()) {
// Script s = new Script();
// s.setName(script.getName());
// s.setPayload(script.getPayload());
// vnfPackage.getScripts().add(s);
// }
//
// vnfPackage.setImage(vnfd.getVnfPackageLocation().getImage());
// }
virtualNetworkFunctionRecord.setPackageId(vnfd.getVnfPackageLocation());
if (vnfd.getEndpoint() != null) {
virtualNetworkFunctionRecord.setEndpoint(vnfd.getEndpoint());
} else virtualNetworkFunctionRecord.setEndpoint(vnfd.getType());
virtualNetworkFunctionRecord.setMonitoring_parameter(new HashSet<String>());
virtualNetworkFunctionRecord.getMonitoring_parameter().addAll(vnfd.getMonitoring_parameter());
virtualNetworkFunctionRecord.setVendor(vnfd.getVendor());
virtualNetworkFunctionRecord.setAuto_scale_policy(new HashSet<AutoScalePolicy>());
for (AutoScalePolicy autoScalePolicy : vnfd.getAuto_scale_policy()) {
AutoScalePolicy newAutoScalePolicy = new AutoScalePolicy();
newAutoScalePolicy.setName(autoScalePolicy.getName());
newAutoScalePolicy.setType(autoScalePolicy.getType());
newAutoScalePolicy.setCooldown(autoScalePolicy.getCooldown());
newAutoScalePolicy.setPeriod(autoScalePolicy.getPeriod());
newAutoScalePolicy.setComparisonOperator(autoScalePolicy.getComparisonOperator());
newAutoScalePolicy.setThreshold(autoScalePolicy.getThreshold());
newAutoScalePolicy.setMode(autoScalePolicy.getMode());
newAutoScalePolicy.setActions(new HashSet<ScalingAction>());
for (ScalingAction action : autoScalePolicy.getActions()) {
ScalingAction newAction = new ScalingAction();
newAction.setValue(action.getValue());
newAction.setType(action.getType());
if (action.getTarget() == null || action.getTarget().equals("")) {
newAction.setTarget(vnfd.getType());
} else {
newAction.setTarget(action.getTarget());
}
newAutoScalePolicy.getActions().add(newAction);
}
newAutoScalePolicy.setAlarms(new HashSet<ScalingAlarm>());
for (ScalingAlarm alarm : autoScalePolicy.getAlarms()) {
ScalingAlarm newAlarm = new ScalingAlarm();
newAlarm.setComparisonOperator(alarm.getComparisonOperator());
newAlarm.setMetric(alarm.getMetric());
newAlarm.setStatistic(alarm.getStatistic());
newAlarm.setThreshold(alarm.getThreshold());
newAlarm.setWeight(alarm.getWeight());
newAutoScalePolicy.getAlarms().add(newAlarm);
}
virtualNetworkFunctionRecord.getAuto_scale_policy().add(newAutoScalePolicy);
}
// TODO mange the VirtualLinks and links...
//
// virtualNetworkFunctionRecord.setConnected_external_virtual_link(vnfd.getVirtual_link());
virtualNetworkFunctionRecord.setVdu(new HashSet<VirtualDeploymentUnit>());
for (VirtualDeploymentUnit virtualDeploymentUnit : vnfd.getVdu()) {
VirtualDeploymentUnit vdu_new = new VirtualDeploymentUnit();
vdu_new.setParent_vdu(virtualDeploymentUnit.getId());
HashSet<VNFComponent> vnfComponents = new HashSet<>();
for (VNFComponent component : virtualDeploymentUnit.getVnfc()) {
VNFComponent component_new = new VNFComponent();
HashSet<VNFDConnectionPoint> connectionPoints = new HashSet<>();
for (VNFDConnectionPoint connectionPoint : component.getConnection_point()) {
VNFDConnectionPoint connectionPoint_new = new VNFDConnectionPoint();
connectionPoint_new.setVirtual_link_reference(
connectionPoint.getVirtual_link_reference());
connectionPoint_new.setType(connectionPoint.getType());
connectionPoint_new.setFloatingIp(connectionPoint.getFloatingIp());
connectionPoints.add(connectionPoint_new);
}
component_new.setConnection_point(connectionPoints);
vnfComponents.add(component_new);
}
vdu_new.setVnfc(vnfComponents);
vdu_new.setVnfc_instance(new HashSet<VNFCInstance>());
HashSet<LifecycleEvent> lifecycleEvents = new HashSet<>();
for (LifecycleEvent lifecycleEvent : virtualDeploymentUnit.getLifecycle_event()) {
LifecycleEvent lifecycleEvent_new = new LifecycleEvent();
lifecycleEvent_new.setEvent(lifecycleEvent.getEvent());
lifecycleEvent_new.setLifecycle_events(lifecycleEvent.getLifecycle_events());
lifecycleEvents.add(lifecycleEvent_new);
}
vdu_new.setLifecycle_event(lifecycleEvents);
vdu_new.setVimInstanceName(virtualDeploymentUnit.getVimInstanceName());
vdu_new.setHostname(virtualDeploymentUnit.getHostname());
vdu_new.setHigh_availability(virtualDeploymentUnit.getHigh_availability());
vdu_new.setComputation_requirement(virtualDeploymentUnit.getComputation_requirement());
vdu_new.setScale_in_out(virtualDeploymentUnit.getScale_in_out());
HashSet<String> monitoringParameters = new HashSet<>();
monitoringParameters.addAll(virtualDeploymentUnit.getMonitoring_parameter());
vdu_new.setMonitoring_parameter(monitoringParameters);
vdu_new.setVdu_constraint(virtualDeploymentUnit.getVdu_constraint());
// Set Faultmanagement policies
Set<VRFaultManagementPolicy> vrFaultManagementPolicies = new HashSet<>();
if (virtualDeploymentUnit.getFault_management_policy() != null) {
log.debug(
"Adding the fault management policies: "
+ virtualDeploymentUnit.getFault_management_policy());
for (VRFaultManagementPolicy vrfmp : virtualDeploymentUnit.getFault_management_policy()) {
vrFaultManagementPolicies.add(vrfmp);
}
}
vdu_new.setFault_management_policy(vrFaultManagementPolicies);
// Set Faultmanagement policies end
HashSet<String> vmImages = new HashSet<>();
vmImages.addAll(virtualDeploymentUnit.getVm_image());
vdu_new.setVm_image(vmImages);
vdu_new.setVirtual_network_bandwidth_resource(
virtualDeploymentUnit.getVirtual_network_bandwidth_resource());
vdu_new.setVirtual_memory_resource_element(
virtualDeploymentUnit.getVirtual_memory_resource_element());
virtualNetworkFunctionRecord.getVdu().add(vdu_new);
}
virtualNetworkFunctionRecord.setVersion(vnfd.getVersion());
virtualNetworkFunctionRecord.setConnection_point(new HashSet<ConnectionPoint>());
virtualNetworkFunctionRecord.getConnection_point().addAll(vnfd.getConnection_point());
// TODO find a way to choose between deployment flavors and create the new one
virtualNetworkFunctionRecord.setDeployment_flavour_key(flavourKey);
for (VirtualDeploymentUnit virtualDeploymentUnit : vnfd.getVdu()) {
for (VimInstance vi : vimInstances.get(virtualDeploymentUnit.getId())) {
for (String name : virtualDeploymentUnit.getVimInstanceName()) {
if (name.equals(vi.getName())) {
if (!existsDeploymentFlavor(
virtualNetworkFunctionRecord.getDeployment_flavour_key(), vi)) {
throw new BadFormatException(
"no key "
+ virtualNetworkFunctionRecord.getDeployment_flavour_key()
+ " found in vim instance: "
+ vi);
}
}
}
}
}
virtualNetworkFunctionRecord.setDescriptor_reference(vnfd.getId());
virtualNetworkFunctionRecord.setLifecycle_event(new LinkedHashSet<LifecycleEvent>());
HashSet<LifecycleEvent> lifecycleEvents = new HashSet<>();
for (LifecycleEvent lifecycleEvent : vnfd.getLifecycle_event()) {
LifecycleEvent lifecycleEvent_new = new LifecycleEvent();
lifecycleEvent_new.setEvent(lifecycleEvent.getEvent());
lifecycleEvent_new.setLifecycle_events(new ArrayList<String>());
for (String event : lifecycleEvent.getLifecycle_events()) {
lifecycleEvent_new.getLifecycle_events().add(event);
}
log.debug(
"Found SCRIPTS for EVENT "
+ lifecycleEvent_new.getEvent()
+ ": "
+ lifecycleEvent_new.getLifecycle_events().size());
lifecycleEvents.add(lifecycleEvent_new);
}
virtualNetworkFunctionRecord.setLifecycle_event(lifecycleEvents);
virtualNetworkFunctionRecord.setVirtual_link(new HashSet<InternalVirtualLink>());
HashSet<InternalVirtualLink> internalVirtualLinks = new HashSet<>();
for (InternalVirtualLink internalVirtualLink : vnfd.getVirtual_link()) {
InternalVirtualLink internalVirtualLink_new = new InternalVirtualLink();
internalVirtualLink_new.setName(internalVirtualLink.getName());
for (VirtualLinkRecord virtualLinkRecord : vlr) {
if (virtualLinkRecord.getName().equals(internalVirtualLink_new.getName())) {
internalVirtualLink_new.setExtId(virtualLinkRecord.getExtId());
}
}
internalVirtualLink_new.setLeaf_requirement(internalVirtualLink.getLeaf_requirement());
internalVirtualLink_new.setRoot_requirement(internalVirtualLink.getRoot_requirement());
internalVirtualLink_new.setConnection_points_references(new HashSet<String>());
for (String conn : internalVirtualLink.getConnection_points_references()) {
internalVirtualLink_new.getConnection_points_references().add(conn);
}
internalVirtualLink_new.setQos(new HashSet<String>());
for (String qos : internalVirtualLink.getQos()) {
internalVirtualLink_new.getQos().add(qos);
}
internalVirtualLink_new.setTest_access(new HashSet<String>());
for (String test : internalVirtualLink.getTest_access()) {
internalVirtualLink_new.getTest_access().add(test);
}
internalVirtualLink_new.setConnectivity_type(internalVirtualLink.getConnectivity_type());
internalVirtualLinks.add(internalVirtualLink_new);
}
virtualNetworkFunctionRecord.getVirtual_link().addAll(internalVirtualLinks);
virtualNetworkFunctionRecord.setVnf_address(new HashSet<String>());
virtualNetworkFunctionRecord.setStatus(Status.NULL);
return virtualNetworkFunctionRecord;
}
public Iterable<String> executeScriptsForEvent(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord,
Event event,
VNFRecordDependency dependency)
throws Exception {
Map<String, String> env = getMap(virtualNetworkFunctionRecord);
LifecycleEvent le =
VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), event);
List<String> res = new ArrayList<>();
if (le != null) {
for (String script : le.getLifecycle_events()) {
String type = null;
if (script.contains("_")) {
type = script.substring(0, script.indexOf('_'));
log.info(
"Sending command: "
+ script
+ " to adding relation with type: "
+ type
+ " from VirtualNetworkFunctionRecord "
+ virtualNetworkFunctionRecord.getName());
}
for (VirtualDeploymentUnit vdu : virtualNetworkFunctionRecord.getVdu()) {
for (VNFCInstance vnfcInstance : vdu.getVnfc_instance()) {
if (dependency.getVnfcParameters().get(type) != null) {
for (String vnfcId :
dependency.getVnfcParameters().get(type).getParameters().keySet()) {
Map<String, String> tempEnv = new HashMap<>();
// Adding own ips
for (Ip ip : vnfcInstance.getIps()) {
log.debug("Adding net: " + ip.getNetName() + " with value: " + ip.getIp());
tempEnv.put(ip.getNetName(), ip.getIp());
}
// Adding own floating ip
for (Ip fip : vnfcInstance.getFloatingIps()) {
log.debug("adding floatingIp: " + fip.getNetName() + " = " + fip.getIp());
tempEnv.put(fip.getNetName() + "_floatingIp", fip.getIp());
}
if (script.contains("_")) {
// Adding foreign parameters such as ip
log.debug("Fetching parameter from dependency of type: " + type);
Map<String, String> parameters =
dependency.getParameters().get(type).getParameters();
for (Map.Entry<String, String> param : parameters.entrySet()) {
log.debug(
"adding param: " + type + "_" + param.getKey() + " = " + param.getValue());
tempEnv.put(type + "_" + param.getKey(), param.getValue());
}
Map<String, String> parametersVNFC =
dependency
.getVnfcParameters()
.get(type)
.getParameters()
.get(vnfcId)
.getParameters();
for (Map.Entry<String, String> param : parametersVNFC.entrySet()) {
log.debug(
"adding param: " + type + "_" + param.getKey() + " = " + param.getValue());
tempEnv.put(type + "_" + param.getKey(), param.getValue());
}
}
tempEnv.put("hostname", vnfcInstance.getHostname());
tempEnv = modifyUnsafeEnvVarNames(tempEnv);
env.putAll(tempEnv);
log.info("Environment Variables are: " + env);
String command = getJsonObject("EXECUTE", script, env).toString();
String output =
executeActionOnEMS(
vnfcInstance.getHostname(),
command,
virtualNetworkFunctionRecord,
vnfcInstance);
res.add(output);
saveLogToFile(virtualNetworkFunctionRecord, script, vnfcInstance, output);
for (String key : tempEnv.keySet()) {
env.remove(key);
}
}
}
}
}
}
}
return res;
}
private void saveLogToFile(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord,
String script,
VNFCInstance vnfcInstance1,
String output,
boolean error)
throws IOException {
if (this.old > 0) {
String path = "";
if (!error) {
path =
this.scriptsLogPath
+ virtualNetworkFunctionRecord.getName()
+ "/"
+ vnfcInstance1.getHostname()
+ ".log";
} else {
path =
this.scriptsLogPath
+ virtualNetworkFunctionRecord.getName()
+ "/"
+ vnfcInstance1.getHostname()
+ "-error.log";
}
File f = new File(path);
if (!f.exists()) {
f.getParentFile().mkdirs();
f.createNewFile();
}
if (!error) {
Files.write(
Paths.get(path),
("Output of Script : " + script + "\n\n").getBytes(),
StandardOpenOption.APPEND);
Files.write(
Paths.get(path),
this.parser
.fromJson(output, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n")
.getBytes(),
StandardOpenOption.APPEND);
} else {
Files.write(
Paths.get(path),
("Error log of Script : " + script + "\n\n").getBytes(),
StandardOpenOption.APPEND);
Files.write(
Paths.get(path),
this.parser
.fromJson(output, JsonObject.class)
.get("err")
.getAsString()
.replaceAll("\\\\n", "\n")
.getBytes(),
StandardOpenOption.APPEND);
}
Files.write(
Paths.get(path),
"\n\n\n~~~~~~~~~~~~~~~~~~~~~~~~~\n#########################\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n"
.getBytes(),
StandardOpenOption.APPEND);
}
}
@Override
public VirtualNetworkFunctionRecord scale(
Action scaleInOrOut,
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord,
VNFComponent component,
Object scripts,
VNFRecordDependency dependency)
throws Exception {
VNFCInstance vnfcInstance = (VNFCInstance) component;
if (scaleInOrOut.ordinal() == Action.SCALE_OUT.ordinal()) {
log.info("Created VNFComponent");
saveScriptOnEms(vnfcInstance, scripts, virtualNetworkFunctionRecord);
String output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEvent(virtualNetworkFunctionRecord, vnfcInstance, Event.INSTANTIATE)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for INSTANTIATE. Output was: \n\n" + output);
if (dependency != null) {
output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEvent(
virtualNetworkFunctionRecord, vnfcInstance, Event.CONFIGURE, dependency)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for CONFIGURE. Output was: \n\n" + output);
}
if ((vnfcInstance.getState() == null) || !vnfcInstance.getState().equals("STANDBY")) {
if (VnfmUtils.getLifecycleEvent(
virtualNetworkFunctionRecord.getLifecycle_event(), Event.START)
!= null) {
output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEvent(virtualNetworkFunctionRecord, vnfcInstance, Event.START)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for START. Output was: \n\n" + output);
}
}
log.trace("HB_VERSION == " + virtualNetworkFunctionRecord.getHb_version());
return virtualNetworkFunctionRecord;
} else { // SCALE_IN
String output = "\n--------------------\n--------------------\n";
for (String result :
executeScriptsForEventOnVnfr(
virtualNetworkFunctionRecord, vnfcInstance, Event.SCALE_IN)) {
output +=
this.parser
.fromJson(result, JsonObject.class)
.get("output")
.getAsString()
.replaceAll("\\\\n", "\n");
output += "\n--------------------\n";
}
output += "\n--------------------\n";
log.info("Executed script for SCALE_IN. Output was: \n\n" + output);
return virtualNetworkFunctionRecord;
}
}
private Iterable<String> executeScriptsForEvent(
VirtualNetworkFunctionRecord virtualNetworkFunctionRecord,
VNFCInstance vnfcInstance,
Event event,
VNFRecordDependency dependency)
throws Exception {
Map<String, String> env = getMap(virtualNetworkFunctionRecord);
List<String> res = new ArrayList<>();
LifecycleEvent le =
VnfmUtils.getLifecycleEvent(virtualNetworkFunctionRecord.getLifecycle_event(), event);
log.trace(
"The number of scripts for "
+ virtualNetworkFunctionRecord.getName()
+ " are: "
+ le.getLifecycle_events());
log.debug("DEPENDENCY IS: " + dependency);
if (le != null) {
for (String script : le.getLifecycle_events()) {
int indexOf = script.indexOf('_');
VNFCDependencyParameters vnfcDependencyParameters = null;
String type = null;
if (indexOf != -1) {
type = script.substring(0, indexOf);
vnfcDependencyParameters = dependency.getVnfcParameters().get(type);
}
if (vnfcDependencyParameters != null) {
log.debug(
"There are "
+ vnfcDependencyParameters.getParameters().size()
+ " VNFCInstanceForeign");
for (String vnfcForeignId : vnfcDependencyParameters.getParameters().keySet()) {
log.info("Running script: " + script + " for VNFCInstance foreign id " + vnfcForeignId);
log.info(
"Sending command: "
+ script
+ " to adding relation with type: "
+ type
+ " from VirtualNetworkFunctionRecord "
+ virtualNetworkFunctionRecord.getName());
Map<String, String> tempEnv = new HashMap<>();
// Adding own ips
for (Ip ip : vnfcInstance.getIps()) {
log.debug("Adding net: " + ip.getNetName() + " with value: " + ip.getIp());
tempEnv.put(ip.getNetName(), ip.getIp());
}
// Adding own floating ip
log.debug("adding floatingIp: " + vnfcInstance.getFloatingIps());
for (Ip fip : vnfcInstance.getFloatingIps()) {
tempEnv.put(fip.getNetName() + "_floatingIp", fip.getIp());
}
// Adding foreign parameters such as ip
if (script.contains("_")) {
// Adding foreign parameters such as ip
Map<String, String> parameters = dependency.getParameters().get(type).getParameters();
for (Entry<String, String> param : parameters.entrySet()) {
tempEnv.put(type + "_" + param.getKey(), param.getValue());
}
Map<String, String> parametersVNFC =
vnfcDependencyParameters.getParameters().get(vnfcForeignId).getParameters();
for (Entry<String, String> param : parametersVNFC.entrySet()) {
tempEnv.put(type + "_" + param.getKey(), param.getValue());
}
}
tempEnv.put("hostname", vnfcInstance.getHostname());
tempEnv = modifyUnsafeEnvVarNames(tempEnv);
env.putAll(tempEnv);
log.info("The Environment Variables for script " + script + " are: " + env);
String command = getJsonObject("EXECUTE", script, env).toString();
String output =
executeActionOnEMS(
vnfcInstance.getHostname(),
command,
virtualNetworkFunctionRecord,
vnfcInstance);
res.add(output);
saveLogToFile(virtualNetworkFunctionRecord, script, vnfcInstance, output);
for (String key : tempEnv.keySet()) {
env.remove(key);
}
}
}
}
}
return res;
}
