You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by ro...@apache.org on 2018/03/14 11:47:40 UTC
[cloudstack] branch 4.11 updated: CLOUDSTACK-10303 : Refactor test
data to nuage_test_data.py runnable against simulator (#2483)
This is an automated email from the ASF dual-hosted git repository.
rohit pushed a commit to branch 4.11
in repository https://gitbox.apache.org/repos/asf/cloudstack.git
The following commit(s) were added to refs/heads/4.11 by this push:
new 19d6578 CLOUDSTACK-10303 : Refactor test data to nuage_test_data.py runnable against simulator (#2483)
19d6578 is described below
commit 19d6578732311872d8232276e248e509bf730a82
Author: Raf Smeets <Ra...@nuagenetworks.net>
AuthorDate: Wed Mar 14 12:47:36 2018 +0100
CLOUDSTACK-10303 : Refactor test data to nuage_test_data.py runnable against simulator (#2483)
* Refactored nuage tests
Added simulator support for ConfigDrive
Allow all nuage tests to run against simulator
Refactored nuage tests to remove code duplication
* Move test data from test_data.py to nuage_test_data.py
Nuage test data is now contained in nuage_test_data.py instead of
test_data.py
Removed all nuage test data from nuage_test_data.py
* CLOUD-1252 fixed cleanup of vpc tier network
* Import libVSD into the codebase
* CLOUDSTACK-1253: Volumes are not expunged in simulator
* Fixed some merge issues in test_nuage_vsp_mngd_subnets test
* Implement GetVolumeStatsCommand in Simulator
* Add vspk as marvin nuagevsp dependency, after removing libVSD dependency
* correct libVSD files for license purposes
pep8 pyflakes compliant
---
.../storage/endpoint/DefaultEndPointSelector.java | 4 +-
.../cloud/agent/manager/MockStorageManager.java | 6 +
.../agent/manager/MockStorageManagerImpl.java | 91 +-
.../cloud/agent/manager/SimulatorManagerImpl.java | 17 +-
.../cloud/resource/SimulatorStorageProcessor.java | 2 +-
.../network/element/ConfigDriveNetworkElement.java | 13 +-
.../plugins/nuagevsp/libVSD/__init__.py | 22 +
test/integration/plugins/nuagevsp/libVSD/client.py | 135 ++
.../integration/plugins/nuagevsp/libVSD/helpers.py | 602 ++++++
test/integration/plugins/nuagevsp/nuageTestCase.py | 319 ++-
.../plugins/nuagevsp/nuage_test_data.py | 2177 ++++----------------
.../plugins/nuagevsp/test_nuage_configdrive.py | 173 +-
.../plugins/nuagevsp/test_nuage_extra_dhcp.py | 26 +-
.../plugins/nuagevsp/test_nuage_internal_dns.py | 400 +---
.../nuagevsp/test_nuage_network_migration.py | 24 -
.../plugins/nuagevsp/test_nuage_password_reset.py | 11 +-
.../test_nuage_public_sharednetwork_userdata.py | 13 +-
.../plugins/nuagevsp/test_nuage_source_nat.py | 19 +-
.../plugins/nuagevsp/test_nuage_static_nat.py | 19 +-
.../plugins/nuagevsp/test_nuage_vpc_internal_lb.py | 250 +--
.../nuagevsp/test_nuage_vsp_domain_template.py | 4 +
.../nuagevsp/test_nuage_vsp_mngd_subnets.py | 157 +-
tools/marvin/marvin/config/test_data.py | 876 ++------
tools/marvin/setup.py | 2 +-
24 files changed, 1957 insertions(+), 3405 deletions(-)
diff --git a/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java b/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java
index 64d74d7..292ef43 100644
--- a/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java
+++ b/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java
@@ -128,14 +128,14 @@ public class DefaultEndPointSelector implements EndPointSelector {
String sql = sbuilder.toString();
HostVO host = null;
TransactionLegacy txn = TransactionLegacy.currentTxn();
- try(PreparedStatement pstmt = txn.prepareStatement(sql);) {
+ try (PreparedStatement pstmt = txn.prepareStatement(sql)) {
pstmt.setLong(1, poolId);
try(ResultSet rs = pstmt.executeQuery();) {
while (rs.next()) {
long id = rs.getLong(1);
host = hostDao.findById(id);
}
- }catch (SQLException e) {
+ } catch (SQLException e) {
s_logger.warn("can't find endpoint", e);
}
} catch (SQLException e) {
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
index f60e133..70066dc 100644
--- a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
@@ -33,6 +33,9 @@ import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
import com.cloud.agent.api.DeleteStoragePoolCommand;
import com.cloud.agent.api.GetStorageStatsAnswer;
import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.GetVolumeStatsAnswer;
+import com.cloud.agent.api.GetVolumeStatsCommand;
+import com.cloud.agent.api.HandleConfigDriveIsoCommand;
import com.cloud.agent.api.ManageSnapshotCommand;
import com.cloud.agent.api.ModifyStoragePoolCommand;
import com.cloud.agent.api.SecStorageSetupCommand;
@@ -77,6 +80,8 @@ public interface MockStorageManager extends Manager {
public Answer DownloadProcess(DownloadProgressCommand cmd);
+ GetVolumeStatsAnswer getVolumeStats(GetVolumeStatsCommand cmd);
+
public GetStorageStatsAnswer GetStorageStats(GetStorageStatsCommand cmd);
public Answer ManageSnapshot(ManageSnapshotCommand cmd);
@@ -107,4 +112,5 @@ public interface MockStorageManager extends Manager {
public UploadStatusAnswer getUploadStatus(UploadStatusCommand cmd);
+ Answer handleConfigDriveIso(HandleConfigDriveIsoCommand cmd);
}
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
index dba9059..de12f3b 100644
--- a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
@@ -26,6 +26,8 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
+import java.util.function.Function;
+import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
@@ -38,6 +40,7 @@ import org.apache.cloudstack.storage.command.DownloadProgressCommand;
import org.apache.cloudstack.storage.command.UploadStatusAnswer;
import org.apache.cloudstack.storage.command.UploadStatusAnswer.UploadStatus;
import org.apache.cloudstack.storage.command.UploadStatusCommand;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.AttachIsoCommand;
@@ -52,6 +55,9 @@ import com.cloud.agent.api.CreateVolumeFromSnapshotCommand;
import com.cloud.agent.api.DeleteStoragePoolCommand;
import com.cloud.agent.api.GetStorageStatsAnswer;
import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.GetVolumeStatsAnswer;
+import com.cloud.agent.api.GetVolumeStatsCommand;
+import com.cloud.agent.api.HandleConfigDriveIsoCommand;
import com.cloud.agent.api.ManageSnapshotAnswer;
import com.cloud.agent.api.ManageSnapshotCommand;
import com.cloud.agent.api.ModifyStoragePoolAnswer;
@@ -60,6 +66,7 @@ import com.cloud.agent.api.SecStorageSetupAnswer;
import com.cloud.agent.api.SecStorageSetupCommand;
import com.cloud.agent.api.SecStorageVMSetupCommand;
import com.cloud.agent.api.StoragePoolInfo;
+import com.cloud.agent.api.VolumeStatsEntry;
import com.cloud.agent.api.storage.CopyVolumeAnswer;
import com.cloud.agent.api.storage.CopyVolumeCommand;
import com.cloud.agent.api.storage.CreateAnswer;
@@ -579,6 +586,37 @@ public class MockStorageManagerImpl extends ManagerBase implements MockStorageMa
}
@Override
+ public GetVolumeStatsAnswer getVolumeStats(final GetVolumeStatsCommand cmd) {
+ HashMap<String, VolumeStatsEntry> volumeStats =
+ cmd.getVolumeUuids()
+ .stream()
+ .collect(Collectors.toMap(Function.identity(),
+ this::getVolumeStat,
+ (v1, v2) -> v1, HashMap::new));
+
+ return new GetVolumeStatsAnswer(cmd, "", volumeStats);
+ }
+
+ private VolumeStatsEntry getVolumeStat(final String volumeUuid) {
+ TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
+
+ try {
+ txn.start();
+ MockVolumeVO volume = _mockVolumeDao.findByUuid(volumeUuid);
+ txn.commit();
+ return new VolumeStatsEntry(volumeUuid, volume.getSize(), volume.getSize());
+ } catch (Exception ex) {
+ txn.rollback();
+ throw new CloudRuntimeException("Error when finding volume " + volumeUuid, ex);
+ } finally {
+ txn.close();
+ txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);
+ txn.close();
+ }
+
+ }
+
+ @Override
public GetStorageStatsAnswer GetStorageStats(GetStorageStatsCommand cmd) {
String uuid = cmd.getStorageId();
TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
@@ -786,9 +824,13 @@ public class MockStorageManagerImpl extends ManagerBase implements MockStorageMa
txn.start();
MockVolumeVO template = _mockVolumeDao.findByStoragePathAndType(cmd.getData().getPath());
if (template == null) {
- return new Answer(cmd, false, "can't find object to delete:" + cmd.getData().getPath());
+ if(!((VolumeObjectTO)cmd.getData()).getName().startsWith("ROOT-")) {
+ return new Answer(cmd, false, "can't find object to delete:" + cmd.getData()
+ .getPath());
+ }
+ } else {
+ _mockVolumeDao.remove(template.getId());
}
- _mockVolumeDao.remove(template.getId());
txn.commit();
} catch (Exception ex) {
txn.rollback();
@@ -1228,4 +1270,49 @@ public class MockStorageManagerImpl extends ManagerBase implements MockStorageMa
public UploadStatusAnswer getUploadStatus(UploadStatusCommand cmd) {
return new UploadStatusAnswer(cmd, UploadStatus.COMPLETED);
}
+
+ @Override public Answer handleConfigDriveIso(HandleConfigDriveIsoCommand cmd) {
+ TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
+ MockSecStorageVO sec;
+ try {
+ txn.start();
+ sec = _mockSecStorageDao.findByUrl(cmd.getDestStore().getUrl());
+ if (sec == null) {
+ return new Answer(cmd, false, "can't find secondary storage");
+ }
+
+ txn.commit();
+ } catch (Exception ex) {
+ txn.rollback();
+ throw new CloudRuntimeException("Error when creating config drive.");
+ } finally {
+ txn.close();
+ txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);
+ txn.close();
+ }
+
+ MockVolumeVO template = new MockVolumeVO();
+ String uuid = UUID.randomUUID().toString();
+ template.setName(uuid);
+ template.setPath(sec.getMountPoint() + cmd.getIsoFile());
+ template.setPoolId(sec.getId());
+ template.setSize((long)(Math.random() * 200L) + 200L);
+ template.setStatus(Status.DOWNLOADED);
+ template.setType(MockVolumeType.ISO);
+ txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
+ try {
+ txn.start();
+ template = _mockVolumeDao.persist(template);
+ txn.commit();
+ } catch (Exception ex) {
+ txn.rollback();
+ throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when persisting config drive " + template.getName(), ex);
+ } finally {
+ txn.close();
+ txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);
+ txn.close();
+ }
+
+ return new Answer(cmd);
+ }
}
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java
index 38c2a8e..7297773 100644
--- a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java
@@ -64,6 +64,8 @@ import com.cloud.agent.api.GetHostStatsCommand;
import com.cloud.agent.api.GetStorageStatsCommand;
import com.cloud.agent.api.GetVmStatsCommand;
import com.cloud.agent.api.GetVncPortCommand;
+import com.cloud.agent.api.GetVolumeStatsCommand;
+import com.cloud.agent.api.HandleConfigDriveIsoCommand;
import com.cloud.agent.api.MaintainCommand;
import com.cloud.agent.api.ManageSnapshotCommand;
import com.cloud.agent.api.MigrateCommand;
@@ -206,6 +208,7 @@ public class SimulatorManagerImpl extends ManagerBase implements SimulatorManage
@DB
@Override
public Answer simulate(final Command cmd, final String hostGuid) {
+ s_logger.debug("Simulate command " + cmd);
Answer answer = null;
Exception exception = null;
TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
@@ -363,6 +366,8 @@ public class SimulatorManagerImpl extends ManagerBase implements SimulatorManage
answer = _mockStorageMgr.Download((DownloadCommand)cmd);
} else if (cmd instanceof GetStorageStatsCommand) {
answer = _mockStorageMgr.GetStorageStats((GetStorageStatsCommand)cmd);
+ } else if (cmd instanceof GetVolumeStatsCommand) {
+ answer = _mockStorageMgr.getVolumeStats((GetVolumeStatsCommand)cmd);
} else if (cmd instanceof ManageSnapshotCommand) {
answer = _mockStorageMgr.ManageSnapshot((ManageSnapshotCommand)cmd);
} else if (cmd instanceof BackupSnapshotCommand) {
@@ -431,8 +436,14 @@ public class SimulatorManagerImpl extends ManagerBase implements SimulatorManage
answer = storageHandler.handleStorageCommands((StorageSubSystemCommand)cmd);
} else if (cmd instanceof FenceCommand) {
answer = _mockVmMgr.fence((FenceCommand)cmd);
- } else if (cmd instanceof GetRouterAlertsCommand || cmd instanceof VpnUsersCfgCommand || cmd instanceof RemoteAccessVpnCfgCommand || cmd instanceof SetMonitorServiceCommand || cmd instanceof AggregationControlCommand ||
- cmd instanceof SecStorageFirewallCfgCommand) {
+ } else if (cmd instanceof HandleConfigDriveIsoCommand) {
+ answer = _mockStorageMgr.handleConfigDriveIso((HandleConfigDriveIsoCommand)cmd);
+ } else if (cmd instanceof GetRouterAlertsCommand
+ || cmd instanceof VpnUsersCfgCommand
+ || cmd instanceof RemoteAccessVpnCfgCommand
+ || cmd instanceof SetMonitorServiceCommand
+ || cmd instanceof AggregationControlCommand
+ || cmd instanceof SecStorageFirewallCfgCommand) {
answer = new Answer(cmd);
} else {
s_logger.error("Simulator does not implement command of type " + cmd.toString());
@@ -447,6 +458,8 @@ public class SimulatorManagerImpl extends ManagerBase implements SimulatorManage
}
}
+ s_logger.debug("Finished simulate command " + cmd);
+
return answer;
} catch (final Exception e) {
s_logger.error("Failed execute cmd: ", e);
diff --git a/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java b/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java
old mode 100755
new mode 100644
index 30cad8f..c2dfdbd
--- a/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java
@@ -85,7 +85,7 @@ public class SimulatorStorageProcessor implements StorageProcessor {
public Answer copyTemplateToPrimaryStorage(CopyCommand cmd) {
TemplateObjectTO template = new TemplateObjectTO();
template.setPath(UUID.randomUUID().toString());
- template.setSize(new Long(100));
+ template.setSize(100L);
template.setFormat(Storage.ImageFormat.RAW);
return new CopyCmdAnswer(template);
}
diff --git a/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java b/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java
index 8c0f500..37a30ef 100644
--- a/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java
+++ b/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java
@@ -118,9 +118,9 @@ public class ConfigDriveNetworkElement extends AdapterBase implements NetworkEle
@Inject
VolumeOrchestrationService _volumeMgr;
- public final static String CONFIGDRIVEFILENAME = "configdrive.iso";
- public final static String CONFIGDRIVEDIR= "ConfigDrive";
- public final static Integer CONFIGDRIVEDISKSEQ= new Integer(4);
+ private final static String CONFIGDRIVEFILENAME = "configdrive.iso";
+ private final static String CONFIGDRIVEDIR = "ConfigDrive";
+ private final static Integer CONFIGDRIVEDISKSEQ = 4;
private boolean canHandle(TrafficType trafficType) {
return trafficType.equals(TrafficType.Guest);
@@ -320,9 +320,10 @@ public class ConfigDriveNetworkElement extends AdapterBase implements NetworkEle
s_logger.debug(String.format("%s config drive ISO for vm %s in host %s",
(update?"update":"create"), profile.getInstanceName(), _hostDao.findById(hostId).getName()));
EndPoint endpoint = _ep.select(secondaryStore);
- if (endpoint == null )
- throw new ResourceUnavailableException(String.format("%s failed, secondary store not available",
- (update?"Update":"Create")),secondaryStore.getClass(),secondaryStore.getId());
+ if (endpoint == null) {
+ throw new ResourceUnavailableException(String.format("%s failed, secondary store not available", (update ? "Update" : "Create")), secondaryStore.getClass(),
+ secondaryStore.getId());
+ }
String isoPath = CONFIGDRIVEDIR + "/" + profile.getInstanceName() + "/" + CONFIGDRIVEFILENAME;
HandleConfigDriveIsoCommand configDriveIsoCommand = new HandleConfigDriveIsoCommand(profile.getVmData(),
profile.getConfigDriveLabel(), secondaryStore.getTO(), isoPath, true, update);
diff --git a/test/integration/plugins/nuagevsp/libVSD/__init__.py b/test/integration/plugins/nuagevsp/libVSD/__init__.py
new file mode 100644
index 0000000..3377d9c
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/libVSD/__init__.py
@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+
+from .client import ApiClient
+from .helpers import VSDHelpers
+
+__version__ = "1.0"
+__all__ = ['ApiClient', 'VSDHelpers']
diff --git a/test/integration/plugins/nuagevsp/libVSD/client.py b/test/integration/plugins/nuagevsp/libVSD/client.py
new file mode 100644
index 0000000..38ab6f0
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/libVSD/client.py
@@ -0,0 +1,135 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+
+import bambou
+import importlib
+
+
+class ApiClient(object):
+ """
+ This class provides utilities to instantiate an API client using vspk.
+ Args:
+ address (str): ip address or hostname where the VSD API is exposed.
+ user (str): username to authenticate on the API.
+ password (str): password to authenticate on the API.
+ enterprise (str): VSD organization to use to authenticate on the API.
+ version (str): version of the API to use.
+ """
+
+ def __init__(self, address, port='8443', user='csproot',
+ password='csproot', enterprise='csp', version=None):
+ if not version:
+ version = '5.0'
+ self.url = 'https://{}:{}'.format(address, port)
+ self.version = version
+ self.user = user
+ self.password = password
+ self.enterprise = enterprise
+ self.last_pushes = []
+ self.session = None
+
+ @staticmethod
+ def import_vspk(version):
+ """
+ Return the vspk module corresponding to a given version of the API.
+ Args:
+ version (str): version of the API
+ """
+ version = 'v{}'.format(str(version).replace('.', '_'))
+ try:
+ vsdk = importlib.import_module('vspk.%s' % version)
+ except:
+ vsdk = importlib.import_module('vspk.vsdk.%s' % version)
+ return vsdk
+
+ def import_vsdenvs(self):
+ """
+ Return the root class a `vsdenvs`.
+ """
+ if not self.session:
+ raise Exception('You must have an active session to use vsdenvs')
+ self.vsdenvs = __import__('vsdenvs', globals(), locals(), [], -1)
+ self.vsdenvs.NUCsprootEnvironment.instance = self.session.user
+
+ def new_session(self):
+ """
+ Start a new API session via vspk an return the corresponding
+ `vspk.NUVSDSession` object. Note that this object is also exposed as
+ `self.session`
+ """
+ vspk = self.import_vspk(self.version)
+ self.session = vspk.NUVSDSession(
+ username=self.user,
+ password=self.password,
+ enterprise=self.enterprise,
+ api_url=self.url)
+ self.session.start()
+ return self.session
+
+ def start_push_center(self, callback=None):
+ """
+ Add a vspk push center to the current session.
+ """
+ if not callback:
+ callback = self.default_callback
+ self.session.push_center.add_delegate(callback)
+ self.session.push_center.start()
+
+ def stop_push_center(self, callback=None):
+ """
+ Stop the vpsk push center for the current session.
+ """
+ self.session.push_center.stop()
+
+ def default_callback(self, data):
+ """
+ Default callback for the push center. It just stores the new event in
+ a LILO queue exposed as `self.last_pushe`
+ """
+ self.last_pushes.append(data)
+ # keep only the last 10 events
+ if len(self.last_pushes) == 100:
+ del self.last_pushes[-1]
+
+ def __call__(self):
+ if not self.session:
+ return self.new_session()
+ return self.session
+
+ def add_license(self):
+ """
+ Add a license to the VSD
+ """
+ vspk = self.import_vspk(self.version)
+ self.session.license = vspk.NULicense(license=self.license)
+ try:
+ self.session.user.create_child(self.session.license)
+ except bambou.exceptions.BambouHTTPError:
+ pass
+ else:
+ self.session.user.add_child(self.session.license)
+
+ def delete_license(self):
+ """
+ Delete license on the VSD
+ """
+ self.session.user.licenses.fetch()
+ for license in self.session.user.licenses:
+ try:
+ license.delete()
+ except bambou.exceptions.BambouHTTPError:
+ pass
diff --git a/test/integration/plugins/nuagevsp/libVSD/helpers.py b/test/integration/plugins/nuagevsp/libVSD/helpers.py
new file mode 100644
index 0000000..cdc0e63
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/libVSD/helpers.py
@@ -0,0 +1,602 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+
+import logging
+import functools
+import bambou
+
+LOG = logging.getLogger()
+
+
+class recreate_session_on_timeout(object):
+ def __init__(self, method):
+ self.method = method
+
+ def __get__(self, obj=None, objtype=None):
+ @functools.wraps(self.method)
+ def _wrapper(*args, **kwargs):
+ try:
+ return self.method(obj, *args, **kwargs)
+ except bambou.exceptions.BambouHTTPError as e:
+ if e.connection.response.status_code == 401:
+ obj.session = obj.api_client.new_session()
+ return self.method(obj, *args, **kwargs)
+ else:
+ raise e
+
+ return _wrapper
+
+
+class VSDHelpers(object):
+
+ def __init__(self, api_client):
+ """
+ Create a wrapper
+ provide a cspsession and a vpsk object, all from the VSD object
+ """
+ self.api_client = api_client
+ self.session = api_client.session
+ self.vspk = api_client.import_vspk(api_client.version)
+
+ def update_vsd_session(self, api_client=None):
+ """
+ This method is used when Helper is
+ initialized before we create a new_session.
+ """
+ if api_client:
+ self.session = api_client.session
+ self.vspk = api_client.import_vspk(api_client.version)
+ else:
+ self.session = self.api_client.session
+
+ @recreate_session_on_timeout
+ def add_user_to_group(self, enterprise, user=None, group=None,
+ usr_filter=None, grp_filter=None):
+ """
+ Add user to a group on VSD.
+ For example: Add csproot to cms group
+ Here you can couple of things:
+ 1. enterprise can be id or NURest Object
+ 2. And User group both need to be NURest object
+ or both can be filters.
+ """
+ if not isinstance(enterprise, self.vspk.NUEnterprise):
+ enterprise = self.vspk.NUEnterprise(id=enterprise)
+ if isinstance(group, self.vspk.NUGroup):
+ if isinstance(user, self.vspk.NUUser):
+ all_users = group.users.get()
+ all_users.append(user)
+ group.assign(all_users, self.vspk.NUUser)
+ elif usr_filter and grp_filter:
+ group = enterprise.groups.get_first(filter=grp_filter)
+ all_users = group.users.get()
+ user = enterprise.users.get_first(filter=usr_filter)
+ if not group:
+ LOG.error('could not fetch the group matching the filter "{}"'
+ .format(grp_filter))
+ return
+ if not user:
+ LOG.error('could not fetch the user matching the filter "{}"'
+ .format(usr_filter))
+ return
+ all_users.append(user)
+ group.assign(all_users, self.vspk.NUUser)
+
+ def set_name_filter(self, name):
+ """ set name filter for vsd query
+ @param: name: string name
+ @return: filter string
+ """
+ return 'name is "{}"'.format(name)
+
+ def set_externalID_filter(self, id):
+ """ set externalID filter for vsd query
+ @param: id: string externalID
+ @return: filter string
+ """
+ return 'externalID is "{}"'.format(id)
+
+ @recreate_session_on_timeout
+ def get_enterprise(self, filter):
+ """ get_enterprise
+ @params: enterprise filter following vspk filter structure
+ @return: enterprise object
+ @Example:
+ self.vsd.get_enterprise(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ enterprise = self.session.user.enterprises.get_first(filter=filter)
+ if not enterprise:
+ LOG.error('could not fetch the enterprise matching the filter "{}"'
+ .format(filter))
+ return enterprise
+
+ @recreate_session_on_timeout
+ def get_l2domain(self, enterprise=None, filter=None):
+ """ get_l2domain
+ @params: enterprise object or enterprise id
+ filter following vspk filter structure
+ @return l2 domain object
+ @Example:
+ self.vsd.get_l2domain(enterprise=enterprise,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_l2domain(enterprise=enterprise_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_l2domain(filter='externalID == "{}"'.format(ext_id))
+ """
+ l2_domain = None
+ if enterprise:
+ if not isinstance(enterprise, self.vspk.NUEnterprise):
+ enterprise = self.vspk.NUEnterprise(id=enterprise)
+ l2_domain = enterprise.l2_domains.get_first(filter=filter)
+ elif filter:
+ l2_domain = self.session.user.l2_domains.get_first(filter=filter)
+ if not l2_domain:
+ LOG.error('could not fetch the l2 domain matching the filter "{}"'
+ .format(filter))
+ return l2_domain
+
+ @recreate_session_on_timeout
+ def get_domain(self, enterprise=None, filter=None):
+ """ get_domain
+ @params: enterprise object or enterprise id
+ filter following vspk filter structure
+ @return: domain object
+ @Example:
+ self.vsd.get_domain(enterprise=enterprise,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_domain(enterprise=enterprise_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_domain(filter='externalID == "{}"'.format(ext_id))
+ """
+ domain = None
+ if enterprise:
+ if not isinstance(enterprise, self.vspk.NUEnterprise):
+ enterprise = self.vspk.NUEnterprise(id=enterprise)
+ domain = enterprise.domains.get_first(filter=filter)
+ elif filter:
+ domain = self.session.user.domains.get_first(filter=filter)
+ if not domain:
+ LOG.error('could not fetch the domain matching the filter "{}"'
+ .format(filter))
+ return domain
+
+ @recreate_session_on_timeout
+ def get_domain_template(self, enterprise=None, filter=None):
+ """ get_domain
+ @params: enterprise object or enterprise id
+ filter following vspk filter structure
+ @return: domain object
+ @Example:
+ self.vsd.get_domain(enterprise=enterprise,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_domain(enterprise=enterprise_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_domain(filter='externalID == "{}"'.format(ext_id))
+ """
+ domain = None
+ if enterprise:
+ if not isinstance(enterprise, self.vspk.NUEnterprise):
+ enterprise = self.vspk.NUEnterprise(id=enterprise)
+ domain = enterprise.domain_templates.get_first(filter=filter)
+ elif filter:
+ domain = \
+ self.session.user.domain_templates.get_first(filter=filter)
+ if not domain:
+ LOG.error('could not fetch the domain template '
+ 'matching the filter "{}"'
+ .format(filter))
+ return domain
+
+ @recreate_session_on_timeout
+ def get_zone(self, domain=None, filter=None):
+ """ get_zone
+ @params: domain object or domain id
+ filter following vspk filter structure
+ @return: zone object
+ @Example:
+ self.vsd.get_zone(domain=domain,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_zone(domain=domain_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_zone(filter='externalID == "{}"'.format(ext_id))
+ """
+ zone = None
+ if domain:
+ if not isinstance(domain, self.vspk.NUDomain):
+ domain = self.vspk.NUDomain(id=domain)
+ zone = domain.zones.get_first(filter=filter)
+ elif filter:
+ zone = self.session.user.zones.get_first(filter=filter)
+ if not zone:
+ LOG.error('could not fetch the zone matching the filter "{}"'
+ .format(filter))
+ return zone
+
+ @recreate_session_on_timeout
+ def get_subnet(self, zone=None, filter=None):
+ """ get_subnet
+ @params: zone object or zone id
+ filter following vspk filter structure
+ @return: subnet object
+ @Example:
+ self.vsd.get_subnet(zone=zone,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_subnet(zone=zone_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_subnet(filter='externalID == "{}"'.format(ext_id))
+ """
+ subnet = None
+ if zone:
+ if not isinstance(zone, self.vspk.NUZone):
+ zone = self.vspk.NUZone(id=zone)
+ subnet = zone.subnets.get_first(filter=filter)
+ elif filter:
+ subnet = self.session.user.subnets.get_first(filter=filter)
+ if not subnet:
+ LOG.error('could not fetch the subnet matching the filter "{}"'
+ .format(filter))
+ return subnet
+
+ @recreate_session_on_timeout
+ def get_subnet_from_domain(self, domain=None, filter=None):
+ """ get_subnet
+ @params: domain object or domain id
+ filter following vspk filter structure
+ @return: subnet object
+ @Example:
+ self.vsd.get_subnet(domain=domain,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_subnet(domain=domain_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_subnet(filter='externalID == "{}"'.format(ext_id))
+ """
+ subnet = None
+ if domain:
+ if not isinstance(domain, self.vspk.NUDomain):
+ domain = self.vspk.NUDomain(id=domain)
+ subnet = domain.subnets.get_first(filter=filter)
+ elif filter:
+ subnet = self.session.user.subnets.get_first(filter=filter)
+ if not subnet:
+ LOG.error('could not fetch the subnet matching the filter "{}"'
+ .format(filter))
+ return subnet
+
+ @recreate_session_on_timeout
+ def get_vm(self, subnet=None, filter=None):
+ """ get_vm
+ @params: subnet object or subnet id
+ filter following vspk filter structure
+ @return: vm object
+ @Example:
+ self.vsd.get_vm(subnet=subnet,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_vm(subnet=subnet_id,
+ filter='name == "{}"'.format(name))
+ self.vsd.get_vm(filter='externalID == "{}"'.format(ext_id))
+ """
+ vm = None
+ if subnet:
+ if not isinstance(subnet, self.vspk.NUSubnet):
+ subnet = self.vspk.NUSubnet(id=subnet)
+ vm = subnet.vms.get_first(filter=filter)
+ elif filter:
+ vm = self.session.user.vms.get_first(filter=filter)
+ if not vm:
+ LOG.error('could not fetch the vm matching the filter "{}"'
+ .format(filter))
+ return vm
+
+ @recreate_session_on_timeout
+ def get_subnet_dhcpoptions(self, subnet=None, filter=None):
+ """ get_subnet_dhcpoptions
+ @params: subnet object or
+ subnet filter following vspk filter structure
+ @return: subnet dhcpoptions object
+ @Example:
+ self.vsd.get_subnet_dhcpoptions(subnet=subnet)
+ self.vsd.get_subnet_dhcpoptions(
+ filter='externalID == "{}"'.format(subnet_externalID))
+ """
+ if not isinstance(subnet, self.vspk.NUSubnet):
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ subnet = self.session.user.subnets.get_first(filter=filter)
+ dhcp_options = subnet.dhcp_options.get()
+ if not dhcp_options:
+ if filter:
+ LOG.error('could not fetch the dhcp options on the subnet '
+ 'matching the filter "{}"'
+ .format(filter))
+ else:
+ LOG.error('could not fetch the dhcp options on the subnet')
+ return dhcp_options
+
+ @recreate_session_on_timeout
+ def get_vport(self, subnet, filter):
+ """ get_vport
+ @params: subnet object
+ vport filter following vspk filter structure
+ @return: vport object
+ @Example:
+ self.vsd.get_vport(subnet=subnet,
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not isinstance(subnet, self.vspk.NUSubnet):
+ LOG.error('a subnet is required')
+ return None
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ vport = subnet.vports.get_first(filter=filter)
+ if not vport:
+ LOG.error('could not fetch the vport from the subnet '
+ 'matching the filter "{}"'
+ .format(filter))
+ return vport
+
+ @recreate_session_on_timeout
+ def get_vm_interface(self, filter):
+ """ get_vm_interface
+ @params: vm interface filter following vspk filter structure
+ @return: vm interface object
+ @Example:
+ self.vsd.get_vm_interface(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ vm_interface = self.session.user.vm_interfaces.get_first(filter=filter)
+ if not vm_interface:
+ LOG.error('could not fetch the vm interface '
+ 'matching the filter "{}"'
+ .format(filter))
+ return vm_interface
+
+ @recreate_session_on_timeout
+ def get_vm_interface_policydecisions(self, vm_interface=None, filter=None):
+ """ get_vm_interface_policydecisions
+ @params: vm interface object or
+ vm interface filter following vspk filter structure
+ @return: vm interface policydecisions object
+ @Example:
+ self.vsd.get_vm_interface_policydecisions(vm_interface=interface)
+ self.vsd.get_vm_interface_policydecisions(
+ filter='externalID == "{}"'.format(vm_interface_externalID))
+ """
+ if not isinstance(vm_interface, self.vspk.NUVMInterface):
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ vm_interface = \
+ self.session.user.vm_interfaces.get_first(filter=filter)
+ policy_decisions = self.vspk.NUPolicyDecision(
+ id=vm_interface.policy_decision_id).fetch()
+ if not policy_decisions:
+ if filter:
+ LOG.error('could not fetch the policy decisions on the '
+ 'vm interface matching the filter "{}"'
+ .format(filter))
+ else:
+ LOG.error('could not fetch the policy decisions '
+ 'on the vm interface')
+ return policy_decisions
+
+ @recreate_session_on_timeout
+ def get_vm_interface_dhcpoptions(self, vm_interface=None, filter=None):
+ """ get_vm_interface_dhcpoptions
+ @params: vm interface object or
+ vm interface filter following vspk filter structure
+ @return: vm interface dhcpoptions object
+ @Example:
+ self.vsd.get_vm_interface_dhcpoptions(vm_interface=vm_interface)
+ self.vsd.get_vm_interface_dhcpoptions(
+ filter='externalID == "{}"'.format(vm_interface_externalID))
+ """
+ if not isinstance(vm_interface, self.vspk.NUVMInterface):
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ vm_interface = self.session.user.vm_interfaces.get_first(
+ filter=filter)
+ dhcp_options = vm_interface.dhcp_options.get()
+ if not dhcp_options:
+ if filter:
+ LOG.error('could not fetch the dhcp options on the '
+ 'vm interface matching the filter "{}"'
+ .format(filter))
+ else:
+ LOG.error('could not fetch the dhcp options on the '
+ 'vm interface')
+ return dhcp_options
+
+ @recreate_session_on_timeout
+ def get_ingress_acl_entry(self, filter):
+ """ get_ingress_acl_entry
+ @params: ingress acl entry filter following vspk filter structure
+ @return: ingress acl entry object
+ @Example:
+ self.vsd.get_ingress_acl_entry(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ acl = self.session.user.ingress_acl_entry_templates.get_first(
+ filter=filter)
+ if not acl:
+ LOG.error('could not fetch the ingress acl entry '
+ 'matching the filter "{}"'
+ .format(filter))
+ return acl
+
+ @recreate_session_on_timeout
+ def get_egress_acl_entry(self, filter):
+ """ get_egress_acl_entry
+ @params: egress acl entry filter following vspk filter structure
+ @return: egress acl entry object
+ @Example:
+ self.vsd.get_egress_acl_entry(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ acl = self.session.user.egress_acl_entry_templates.get_first(
+ filter=filter)
+ if not acl:
+ LOG.error('could not fetch the egress acl entry '
+ 'matching the filter "{}"'
+ .format(filter))
+ return acl
+
+ @recreate_session_on_timeout
+ def get_qoss(self, vport):
+ """ get_qoss
+ @params: vport object
+ @return: qoss object
+ @Example:
+ self.vsd.get_qoss(vport=vport)
+ """
+ if not isinstance(vport, self.vspk.NUVPort):
+ LOG.error('a vport is required')
+ return None
+ qoss = vport.qoss.get()
+ if not qoss:
+ LOG.error('could not fetch the qoss from the vport')
+ return qoss
+
+ @recreate_session_on_timeout
+ def get_floating_ip(self, filter):
+ """ get_floating_ip
+ @params: floating ip filter following vspk filter structure
+ @return: floating ip object
+ @Example:
+ self.vsd.get_floating_ip(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ floating_ip = self.session.user.floating_ips.get_first(filter=filter)
+ if not floating_ip:
+ LOG.error('could not fetch the floating ip '
+ 'matching the filter "{}"'
+ .format(filter))
+ return floating_ip
+
+ @recreate_session_on_timeout
+ def get_ingress_acl_entries(self, filter):
+ """ get_ingress_acl_entries
+ @params: ingress acl entries (templates) filter following vspk
+ filter structure
+ @return: ingress acl entries (objects) list
+ @Example:
+ self.vsd.get_ingress_acl_entries(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ templates = self.session.user.ingress_acl_templates.get(filter=filter)
+ if not templates:
+ LOG.error('could not fetch the ingress acl entries (templates) '
+ 'matching the filter "{}"'
+ .format(filter))
+ return None
+ acls = []
+ for template in templates:
+ tmp = self.vspk.NUIngressACLTemplate(id=template.id)
+ acl = tmp.ingress_acl_entry_templates.get()
+ acls.append(acl)
+ return acls
+
+ @recreate_session_on_timeout
+ def get_egress_acl_entries(self, filter):
+ """ get_egress_acl_entries
+ @params: egress acl entries (templates) filter
+ following vspk filter structure
+ @return: egress acl entries (objects) list
+ @Example:
+ self.vsd.get_egress_acl_entries(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ templates = self.session.user.egress_acl_templates.get(filter=filter)
+ if not templates:
+ LOG.error('could not fetch the egress acl entries (templates) '
+ 'matching the filter "{}"'
+ .format(filter))
+ return None
+ acls = []
+ for template in templates:
+ tmp = self.vspk.NUEgressACLTemplate(id=template.id)
+ acl = tmp.egress_acl_entry_templates.get()
+ acls.append(acl)
+ return acls
+
+ @recreate_session_on_timeout
+ def get_shared_network_resource(self, filter):
+ """ get_shared_network_resource
+ @params: shared network resource filter
+ following vspk filter structure
+ @return: shared network resource object
+ @Example:
+ self.vsd.get_shared_network_resource(
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ shared_network_resource = \
+ self.session.user.shared_network_resources.get_first(filter=filter)
+ if not shared_network_resource:
+ LOG.error('could not fetch the shared network resource '
+ 'matching the filter "{}"'
+ .format(filter))
+ return shared_network_resource
+
+ @recreate_session_on_timeout
+ def get_virtualip(self, vport, filter):
+ """ get_virtualip
+ @params: vport object
+ virtualip filter following vspk filter structure
+ @return: virtualip object
+ @Example:
+ self.vsd.get_virtualip(vport=vport,
+ filter='externalID == "{}"'.format(ext_id))
+ """
+ if not isinstance(vport, self.vspk.NUVPort):
+ LOG.error('a vport is required')
+ return None
+ if not filter:
+ LOG.error('a filter is required')
+ return None
+ virtualip = vport.virtual_ips.get_first(filter=filter)
+
+ if not virtualip:
+ LOG.error('could not fetch the virtualip matching the filter "{}"'
+ .format(filter))
+ return virtualip
diff --git a/test/integration/plugins/nuagevsp/nuageTestCase.py b/test/integration/plugins/nuagevsp/nuageTestCase.py
index 5300e6e..7e6468b 100644
--- a/test/integration/plugins/nuagevsp/nuageTestCase.py
+++ b/test/integration/plugins/nuagevsp/nuageTestCase.py
@@ -48,6 +48,10 @@ from marvin.cloudstackAPI import (restartVPC,
enableNuageUnderlayVlanIpRange,
disableNuageUnderlayVlanIpRange,
listNuageUnderlayVlanIpRanges)
+
+from nuage_test_data import nuage_test_data
+from nuage_vsp_statistics import VsdDataCollector
+
# Import System Modules
from retry import retry
import importlib
@@ -56,10 +60,12 @@ import logging
import socket
import time
import sys
-from nuage_vsp_statistics import VsdDataCollector
class needscleanup(object):
+ """
+ Decorator to add the returned object automatically to the cleanup list.
+ """
def __init__(self, method):
self.method = method
@@ -84,6 +90,9 @@ class needscleanup(object):
class gherkin(object):
+ """Decorator to mark a method as Gherkin style.
+ Add extra colored logging
+ """
BLACK = "\033[0;30m"
BLUE = "\033[0;34m"
GREEN = "\033[0;32m"
@@ -127,6 +136,7 @@ class nuageTestCase(cloudstackTestCase):
cls.api_client = cls.test_client.getApiClient()
cls.db_client = cls.test_client.getDbConnection()
cls.test_data = cls.test_client.getParsedTestDataConfig()
+ cls.test_data.update(nuage_test_data)
# Get Zones and Domains
cls.zones = Zone.list(cls.api_client)
@@ -150,7 +160,7 @@ class nuageTestCase(cloudstackTestCase):
@classmethod
def getZoneDetails(cls, zone=None):
- # Get Zone details
+ """Get Zone details"""
cls.zone = zone if zone else get_zone(
cls.api_client,
zone_name=cls.test_client.getZoneForTests()
@@ -275,12 +285,13 @@ class nuageTestCase(cloudstackTestCase):
log_handler.setFormatter(formatter)
root.addHandler(log_handler)
vsd_info = cls.nuage_vsp_device.__dict__
+
cls.debug("Nuage VSP device (VSD) details - %s" % vsd_info)
vsd_api_client = ApiClient(
- address=vsd_info["hostname"],
- user=vsd_info["username"],
- password=vsd_info["password"],
- version=vsd_info["apiversion"][1] + "." + vsd_info["apiversion"][3]
+ address=cls.nuage_vsp_device.hostname,
+ user=cls.nuage_vsp_device.username,
+ password=cls.nuage_vsp_device.password,
+ version=cls.nuage_vsp_device.apiversion[1] + "." + cls.nuage_vsp_device.apiversion[3]
)
vsd_api_client.new_session()
cls.vsd = VSDHelpers(vsd_api_client)
@@ -293,7 +304,7 @@ class nuageTestCase(cloudstackTestCase):
@classmethod
def tearDownClass(cls):
# Cleanup resources used
- cls.debug("Cleaning up the resources")
+ cls.debug("Cleaning up the class resources")
for obj in reversed(cls._cleanup):
try:
if isinstance(obj, VirtualMachine):
@@ -304,12 +315,12 @@ class nuageTestCase(cloudstackTestCase):
cls.error("Failed to cleanup %s, got %s" % (obj, e))
# cleanup_resources(cls.api_client, cls._cleanup)
cls._cleanup = []
- cls.debug("Cleanup complete!")
+ cls.debug("Cleanup class complete!")
return
def tearDown(self):
# Cleanup resources used
- self.debug("Cleaning up the resources")
+ self.debug("Cleaning up the test resources")
for obj in reversed(self.cleanup):
try:
if isinstance(obj, VirtualMachine):
@@ -322,20 +333,28 @@ class nuageTestCase(cloudstackTestCase):
self.error("Failed to cleanup %s, got %s" % (obj, e))
# cleanup_resources(self.api_client, self.cleanup)
self.cleanup = []
- self.debug("Cleanup complete!")
+ self.debug("Cleanup test complete!")
return
- # enable_NuageUnderlayPublicIpRange - Enables/configures underlay
- # networking for the given public IP range in Nuage VSP
def enable_NuageUnderlayPublicIpRange(self, vlanid):
+ """Enables/configures underlay networking
+ for the given public IP range in Nuage VSP
+
+ :param vlanid: Vlan ID
+ :type vlanid: marvin.lib.base.PublicIpRange.vlan
+ """
cmd = enableNuageUnderlayVlanIpRange. \
enableNuageUnderlayVlanIpRangeCmd()
cmd.id = vlanid
self.api_client.enableNuageUnderlayVlanIpRange(cmd)
- # disable_NuageUnderlayPublicIpRange - Disables/de-configures underlay
- # networking for the given public IP range in Nuage VSP
def disable_NuageUnderlayPublicIpRange(self, public_ip_range):
+ """Disables underlay networking
+ for the given public IP range in Nuage VSP
+
+ :param public_ip_range: Public IP range
+ :type public_ip_range: marvin.lib.base.PublicIpRange
+ """
cmd = disableNuageUnderlayVlanIpRange. \
disableNuageUnderlayVlanIpRangeCmd()
cmd.id = public_ip_range.vlan.id
@@ -344,6 +363,11 @@ class nuageTestCase(cloudstackTestCase):
# list_NuageUnderlayPublicIpRanges - Lists underlay networking
# enabled/configured public IP ranges in Nuage VSP
def list_NuageUnderlayPublicIpRanges(self, public_ip_range=None):
+ """Lists Vlan IP ranges that have the nuage underlay flag set to True
+
+ :param public_ip_range: Optionally filter by Public IP range
+ :type public_ip_range: marvin.lib.base.PublicIpRange
+ """
cmd = listNuageUnderlayVlanIpRanges.listNuageUnderlayVlanIpRangesCmd()
if public_ip_range:
cmd.id = public_ip_range.vlan.id
@@ -353,6 +377,7 @@ class nuageTestCase(cloudstackTestCase):
# create_VpcOffering - Creates VPC offering
@needscleanup
def create_VpcOffering(cls, vpc_offering, suffix=None):
+ """Creates VPC offering"""
cls.debug("Creating VPC offering")
if suffix:
vpc_offering["name"] = "VPC_OFF-" + str(suffix)
@@ -368,6 +393,16 @@ class nuageTestCase(cloudstackTestCase):
@needscleanup
def create_Vpc(cls, vpc_offering, cidr='10.1.0.0/16', testdata=None,
account=None, networkDomain=None):
+ """Creates VPC with the given VPC offering
+ :param vpc_offering: vpc offering
+ :type vpc_offering: VpcOffering
+ :param cidr: CIDR
+ :param testdata: vpc details
+ :param account: Account which will be the owner.
+ :param networkDomain:
+ :return: created VPC
+ :rtype: VPC
+ """
if not account:
account = cls.account
cls.debug("Creating a VPC in the account - %s" % account.name)
@@ -389,6 +424,12 @@ class nuageTestCase(cloudstackTestCase):
# restart_Vpc - Restarts the given VPC with/without cleanup
def restart_Vpc(self, vpc, cleanup=False):
+ """Restarts the given VPC with/without cleanup
+ :param vpc: vpc to restart
+ :type vpc: VPC
+ :param cleanup: whether to restart with cleanup
+ :type cleanup: bool
+ """
self.debug("Restarting VPC with ID - %s" % vpc.id)
cmd = restartVPC.restartVPCCmd()
cmd.id = vpc.id
@@ -401,6 +442,14 @@ class nuageTestCase(cloudstackTestCase):
@needscleanup
def create_NetworkOffering(cls, net_offering, suffix=None,
conserve_mode=False):
+ """Creates a Network Offering
+ :param net_offering: offering details
+ :type net_offering: object
+ :param suffix: string to append to the offering name
+ :param conserve_mode:
+ :return: created Network Offering
+ :rtype: NetworkOffering
+ """
cls.debug("Creating Network offering")
if suffix:
net_offering["name"] = "NET_OFF-" + str(suffix)
@@ -418,6 +467,23 @@ class nuageTestCase(cloudstackTestCase):
def create_Network(cls, nw_off, gateway="10.1.1.1",
netmask="255.255.255.0", vpc=None, acl_list=None,
testdata=None, account=None, vlan=None, externalid=None):
+ """Creates Network with the given Network offering
+ :param nw_off: Network offering
+ :type nw_off: NetworkOffering
+ :param gateway: gateway
+ :param netmask: netmask
+ :param vpc: in case of a VPC tier, the parent VPC
+ :type vpc: VPC
+ :param acl_list: in case of a VPC tier, the acl list
+ :type acl_list: NetworkACLList
+ :param testdata: Network details
+ :param account: Account which will be the owner.
+ :param vlan: vlan id
+ :param externalid: external id, in case of VSD managed networks
+
+ :return: created Network
+ :rtype: Network
+ """
if not account:
account = cls.account
cls.debug("Creating a network in the account - %s" % account.name)
@@ -669,6 +735,10 @@ class nuageTestCase(cloudstackTestCase):
# ssh_into_VM - Gets into the shell of the given VM using its public IP
def ssh_into_VM(self, vm, public_ip, reconnect=True, negative_test=False):
+ if self.isSimulator:
+ self.debug("Simulator Environment: Skipping ssh into VM")
+ return
+
self.debug("SSH into VM with ID - %s on public IP address - %s" %
(vm.id, public_ip.ipaddress.ipaddress))
tries = 1 if negative_test else 3
@@ -687,8 +757,15 @@ class nuageTestCase(cloudstackTestCase):
return retry_ssh()
- # execute_cmd - Executes the given command on the given ssh client
def execute_cmd(self, ssh_client, cmd):
+ """Executes the given command on the given ssh client
+
+ :param ssh_client: SSH session to the remote machine
+ :type ssh_client: marvin.SshClient
+ :param cmd: Command to run on the remote machine
+ :type cmd: str
+ :return: command output
+ """
self.debug("SSH client executing command - %s" % cmd)
ret_data = ""
out_list = ssh_client.execute(cmd)
@@ -699,10 +776,18 @@ class nuageTestCase(cloudstackTestCase):
self.debug("SSH client executed command result is None")
return ret_data
- # wget_from_server - Fetches file with the given file name from a web
- # server listening on the given public IP address and port
+
def wget_from_server(self, public_ip, port=80, file_name="index.html",
disable_system_proxies=True):
+ """Fetches file with the given file name from a web server
+
+ :param public_ip: HTTP server IP
+ :type public_ip: PublicIPAddress
+ :param port: HTTP server port
+ :param file_name: URL path
+ :param disable_system_proxies: whether to bypass system proxy
+ :return: filename, headers
+ """
import urllib
if disable_system_proxies:
urllib.getproxies = lambda: {}
@@ -719,12 +804,15 @@ class nuageTestCase(cloudstackTestCase):
(file_name, public_ip.ipaddress.ipaddress, port))
return filename, headers
- # validate_NetworkServiceProvider - Validates the given Network Service
- # Provider in the Nuage VSP Physical Network, matches the given provider
- # name and state against the list of providers fetched
def validate_NetworkServiceProvider(self, provider_name, state=None):
"""Validates the Network Service Provider in the Nuage VSP Physical
- Network"""
+ Network.
+
+ :param provider_name Provider name
+ :param state Expected state
+ :raises AssertionError when provider isn't found,
+ or has an incorrect state.
+ """
self.debug("Validating the creation and state of Network Service "
"Provider - %s" % provider_name)
providers = NetworkServiceProvider.list(
@@ -748,11 +836,19 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the creation and state of Network "
"Service Provider - %s" % provider_name)
- # validate_VpcOffering - Validates the given VPC offering, matches the
- # given VPC offering name and state against the list of VPC offerings
- # fetched
def validate_VpcOffering(self, vpc_offering, state=None):
- """Validates the VPC offering"""
+ """Validates the VPC offering
+
+ Fetches the Vpc offering by id,
+ verifies that the name is correct,
+ and if en expected state is given, verifies that it is correct.
+
+ :param vpc_offering: cs object
+ :type vpc_offering: VpcOffering
+ :param state: optional state
+ :raise AssertionError when VPC offering isn't found,
+ or has an incorrect state.
+ """
self.debug("Validating the creation and state of VPC offering - %s" %
vpc_offering.name)
vpc_offs = VpcOffering.list(self.api_client,
@@ -772,10 +868,18 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the creation and state of VPC "
"offering - %s" % vpc_offering.name)
- # validate_Vpc - Validates the given VPC, matches the given VPC name and
- # state against the list of VPCs fetched
def validate_Vpc(self, vpc, state=None):
- """Validates the VPC"""
+ """Validates the VPC
+
+ Fetches the vpc by id,
+ verifies that the name is correct,
+ and if en expected state is given, verifies that it is correct.
+
+ :param vpc: cs object
+ :type vpc: Vpc
+ :param state: optional state
+ :raise AssertionError when vpc isn't found,
+ or has an incorrect state."""
self.debug("Validating the creation and state of VPC - %s" % vpc.name)
vpcs = VPC.list(self.api_client,
id=vpc.id
@@ -794,11 +898,19 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the creation and state of VPC - %s"
% vpc.name)
- # validate_NetworkOffering - Validates the given Network offering, matches
- # the given network offering name and state against the list of network
- # offerings fetched
def validate_NetworkOffering(self, net_offering, state=None):
- """Validates the Network offering"""
+ """Validates the Network offering
+
+ Fetches the Network offering by id,
+ verifies that the name is correct,
+ and if en expected state is given, verifies that it is correct.
+
+ :param net_offering: cs object
+ :type net_offering: NetworkOffering
+ :param state: optional state
+ :raise AssertionError when network offering isn't found,
+ or has an incorrect state."""
+
self.debug("Validating the creation and state of Network offering - %s"
% net_offering.name)
net_offs = NetworkOffering.list(self.api_client,
@@ -818,10 +930,18 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the creation and state of Network "
"offering - %s" % net_offering.name)
- # validate_Network - Validates the given network, matches the given network
- # name and state against the list of networks fetched
def validate_Network(self, network, state=None):
- """Validates the network"""
+ """Validates the network
+
+ Fetches the Network by id,
+ verifies that the name is correct,
+ and if en expected state is given, verifies that it is correct.
+
+ :param network: cs object
+ :type network: Network
+ :param state: optional state
+ :raise AssertionError when network isn't found,
+ or has an incorrect state."""
self.debug("Validating the creation and state of Network - %s" %
network.name)
networks = Network.list(self.api_client,
@@ -841,10 +961,14 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the creation and state of Network "
"- %s" % network.name)
- # check_VM_state - Checks if the given VM is in the expected state form the
- # list of fetched VMs
def check_VM_state(self, vm, state=None):
- """Validates the VM state"""
+ """Validates the VM state
+ :param vm: cs object
+ :type vm: VirtualMachine
+ :param state: optional state
+ :raise AssertionError when vm isn't found,
+ or has an incorrect state."""
+
self.debug("Validating the deployment and state of VM - %s" % vm.name)
vms = VirtualMachine.list(self.api_client,
id=vm.id,
@@ -860,10 +984,14 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the deployment and state of VM - %s"
% vm.name)
- # check_Router_state - Checks if the given router is in the expected state
- # form the list of fetched routers
def check_Router_state(self, router, state=None):
- """Validates the Router state"""
+ """Validates the Router state
+ :param router: cs object
+ :type router: Router
+ :param state: optional state
+ :raise AssertionError when router isn't found,
+ or has an incorrect state."""
+
self.debug("Validating the deployment and state of Router - %s" %
router.name)
routers = Router.list(self.api_client,
@@ -880,11 +1008,20 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the deployment and state of Router "
"- %s" % router.name)
- # validate_PublicIPAddress - Validates if the given public IP address is in
- # the expected state form the list of fetched public IP addresses
def validate_PublicIPAddress(self, public_ip, network, static_nat=False,
vm=None):
- """Validates the Public IP Address"""
+ """Validates the Public IP Address
+ :param public_ip: cs object
+ :type public_ip: PublicIPAddress
+ :param network: cs object
+ :type network: Network
+ :param static_nat: optional state
+ :type static_nat: bool
+ :param vm: Virtual machine the public ip should be forwarding to.
+ :type vm: VirtualMachine
+ :raise AssertionError when Public IP isn't found, isn't Allocated
+ or has an incorrect ip address."""
+
self.debug("Validating the assignment and state of public IP address "
"- %s" % public_ip.ipaddress.ipaddress)
public_ips = PublicIPAddress.list(self.api_client,
@@ -913,10 +1050,14 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully validated the assignment and state of public "
"IP address - %s" % public_ip.ipaddress.ipaddress)
- # verify_VRWithoutPublicIPNIC - Verifies that the given Virtual Router has
- # no public IP and NIC
def verify_VRWithoutPublicIPNIC(self, vr):
- """Verifies VR without Public IP and NIC"""
+ """Verifies that the given Virtual Router has no public IP nor NIC
+ :param vr: cs object
+ :type vr: Router
+ :raise AssertionError when router isn't found,
+ has an incorrect name, has a public ip for source nat
+ or has a nic in the public network."""
+
self.debug("Verifies that there is no public IP and NIC in Virtual "
"Router - %s" % vr.name)
self.assertEqual(vr.publicip, None,
@@ -930,6 +1071,11 @@ class nuageTestCase(cloudstackTestCase):
"in Virtual Router - %s" % vr.name)
def verify_vpc_has_no_src_nat(self, vpc, account=None):
+ """Verifies that the given Vpc has no public IP nor NIC
+ :param vpc: cs object
+ :type vpc: VPC
+ :raise AssertionError when the VPC has a public ip for source nat.
+ """
if not account:
account = self.account
self.debug("Verify that there is no src NAT ip address "
@@ -944,9 +1090,14 @@ class nuageTestCase(cloudstackTestCase):
# VSD verifications; VSD is a programmable policy and analytics engine of
# Nuage VSP SDN platform
- # get_externalID_filter - Returns corresponding external ID filter of the
- # given object in VSD
def get_externalID_filter(self, object_id):
+ """Builds a VSD filter to search by external ID
+
+ :param object_id: Cloudstack UUID
+ :type object_id: str
+ :rtype: str
+ :return: filter
+ """
ext_id = object_id + "@" + self.cms_id
return self.vsd.set_externalID_filter(ext_id)
@@ -963,24 +1114,45 @@ class nuageTestCase(cloudstackTestCase):
:param cs_objects: Cloudstack objects to take the UUID from.
:return: the VSPK object having the correct externalID
"""
- return fetcher.get_first(filter="externalID BEGINSWITH '%s'" %
- ":".join([o.id for o in cs_objects]))
+ object_id = ":".join([o.id for o in cs_objects])
+ ext_id = object_id + "@" + self.cms_id
+ return fetcher.get_first(filter="externalID is '%s'" % ext_id)
- # verify_vsd_network - Verifies the given CloudStack domain and network/VPC
- # against the corresponding installed enterprise, domain, zone, and subnet
- # in VSD
- def verify_vsd_network(self, domain_id, network, vpc=None,
- domain_template_name=None):
- self.debug("Verifying the creation and state of Network - %s in VSD" %
- network.name)
+ def fetch_vsd_objects(self, domain_id, network, vpc=None):
vsd_enterprise = self.vsd.get_enterprise(
filter=self.get_externalID_filter(domain_id))
+
ext_network_filter = self.get_externalID_filter(vpc.id) if vpc \
else self.get_externalID_filter(network.id)
vsd_domain = self.vsd.get_domain(filter=ext_network_filter)
vsd_zone = self.vsd.get_zone(filter=ext_network_filter)
vsd_subnet = self.vsd.get_subnet(
filter=self.get_externalID_filter(network.id))
+
+ return [
+ ext_network_filter,
+ vsd_enterprise,
+ vsd_domain,
+ vsd_zone,
+ vsd_subnet
+ ]
+
+ # verify_vsd_network - Verifies the given CloudStack domain and network/VPC
+ # against the corresponding installed enterprise, domain, zone, and subnet
+ # in VSD
+ def verify_vsd_network(self, domain_id, network, vpc=None,
+ domain_template_name=None):
+ self.debug("Verifying the creation and state of Network - %s in VSD" %
+ network.name)
+
+ [
+ ext_network_filter,
+ vsd_enterprise,
+ vsd_domain,
+ vsd_zone,
+ vsd_subnet
+ ] = self.fetch_vsd_objects(domain_id, network, vpc)
+
self.assertEqual(vsd_enterprise.name, domain_id,
"VSD enterprise name should match CloudStack domain "
"uuid"
@@ -1039,14 +1211,23 @@ class nuageTestCase(cloudstackTestCase):
filter=self.get_externalID_filter(network.id))
self.assertEqual(vsd_subnet, None, "Network is present on the vsd.")
- # get_subnet_id - Calculates and returns the subnet ID in VSD with the
- # given CloudStack network ID and subnet gateway
def get_subnet_id(self, network_id, gateway):
+ """ Calculates the subnet ID in VSD with
+ the given CloudStack network ID and subnet gateway
+
+ :param gateway: Gateway
+ :type gateway: str
+ :type network_id: str
+ :rtype: str
+ :return: Expected Subnet UUID
+
+ """
try:
import uuid
class NULL_NAMESPACE:
bytes = b''
+
# The UUID of the shared network in ACS
# The gateway IP of the address range
network_id = str(network_id)
@@ -1059,11 +1240,12 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Failed to get the subnet id due to %s" % e)
self.fail("Unable to get the subnet id, failing the test case")
- # verify_vsd_shared_network - Verifies the given CloudStack domain and
- # shared network against the corresponding installed enterprise, domain,
- # zone, subnet, and shared network resource in VSD
+
def verify_vsd_shared_network(self, domain_id, network,
gateway="10.1.1.1"):
+ """Verifies the given CloudStack domain and
+ shared network against the corresponding installed enterprise,
+ domain, zone, subnet, and shared network resource in VSD"""
self.debug("Verifying the creation and state of Shared Network - %s "
"in VSD" % network.name)
vsd_enterprise = self.vsd.get_enterprise(
@@ -1074,6 +1256,7 @@ class nuageTestCase(cloudstackTestCase):
subnet_id = self.get_subnet_id(network.id, gateway)
vsd_subnet = self.vsd.get_subnet(
filter=self.get_externalID_filter(subnet_id))
+
self.assertNotEqual(vsd_enterprise, None,
"VSD enterprise (CloudStack domain) data format "
"should not be of type None"
@@ -1099,9 +1282,13 @@ class nuageTestCase(cloudstackTestCase):
self.debug("Successfully verified the creation and state of Shared "
"Network - %s in VSD" % network.name)
- # verify_vsd_object_status - Verifies the given CloudStack object status in
- # VSD
def verify_vsd_object_status(self, cs_object, stopped):
+ """ Verifies the VM status in VSD for a given Cloudstack VM,
+ retrying every 5 seconds for 10 minutes.
+
+ :param cs_object: Cloudstack VM
+ :param stopped: boolean: specifying if the vm is stopped.
+ """
vsd_object = self.vsd.get_vm(
filter=self.get_externalID_filter(cs_object.id))
expected_status = cs_object.state.upper() if not stopped \
@@ -1280,6 +1467,7 @@ class nuageTestCase(cloudstackTestCase):
public_ipaddress.vlanid)
vsd_fip_subnet = self.vsd.get_shared_network_resource(
filter=ext_fip_subnet_filter)
+
if self.isNuageInfraUnderlay:
self.assertEqual(vsd_fip_subnet.underlay, True,
"Floating IP subnet in VSD should be underlay "
@@ -1290,6 +1478,7 @@ class nuageTestCase(cloudstackTestCase):
"Floating IP subnet in VSD should be underlay "
"disabled"
)
+
ext_network_filter = self.get_externalID_filter(vpc.id) if vpc \
else self.get_externalID_filter(network.id)
vsd_domain = self.vsd.get_domain(filter=ext_network_filter)
diff --git a/test/integration/plugins/nuagevsp/nuage_test_data.py b/test/integration/plugins/nuagevsp/nuage_test_data.py
index 691e103..d3b87d2 100644
--- a/test/integration/plugins/nuagevsp/nuage_test_data.py
+++ b/test/integration/plugins/nuagevsp/nuage_test_data.py
@@ -15,829 +15,7 @@
# specific language governing permissions and limitations
# under the License.
-test_data = {
- "region": {
- "regionid": "2",
- "regionname": "Region2",
- "regionendpoint": "http://region2:8080/client"
- },
- "zone": "NA",
- "hypervisor": "XenServer",
- "deleteDC": True,
- "vdomain": {
- "name": "domain"
- },
- "domain": {"name": "domain"},
- "email": "test@test.com",
- "gateway": "172.1.1.1",
- "netmask": "255.255.255.0",
- "startip": "172.1.1.10",
- "endip": "172.1.1.20",
- "regionid": "1",
- "vlan": "10",
- "isportable": "true",
-
- "project": {
- "name": "Project",
- "displaytext": "Test project"
- },
- "publiciprange": {
- "gateway": "",
- "netmask": "",
- "startip": "",
- "endip": "",
- "forvirtualnetwork": "true",
- "vlan": "",
- "zoneid": ""
- },
- "private_gateway": {
- "ipaddress": "172.16.1.2",
- "gateway": "172.16.1.1",
- "netmask": "255.255.255.0",
- "vlan": "10",
- "name": "test_private_gateway"
- },
- "account": {
- "email": "test-account@test.com",
- "firstname": "test",
- "lastname": "test",
- "username": "test-account",
- "password": "password"
- },
- "account2": {
- "email": "test-account2@test.com",
- "firstname": "test2",
- "lastname": "test2",
- "username": "test-account2",
- "password": "password"
- },
- "small": {
- "displayname": "testserver",
- "username": "root",
- "password": "password",
- "ssh_port": 22,
- "hypervisor": "XenServer",
- "privateport": 22,
- "publicport": 22,
- "protocol": 'TCP',
- },
- "service_offering": {
- "name": "Tiny Instance",
- "displaytext": "Tiny Instance",
- "cpunumber": 1,
- "cpuspeed": 256, # in MHz
- "memory": 256, # In MBs
- },
- "service_offerings": {
- "tiny": {
- "name": "Tiny Instance",
- "displaytext": "Tiny Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 128,
- },
- "small": {
- "name": "Small Instance",
- "displaytext": "Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256
- },
- "medium": {
- "name": "Medium Instance",
- "displaytext": "Medium Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- },
- "big": {
- "name": "BigInstance",
- "displaytext": "BigInstance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 512,
- },
- "large": {
- "name": "LargeInstance",
- "displaytext": "LargeInstance",
- "cpunumber": 1,
- "cpuspeed": 1024,
- "memory": 2048,
- },
- "hasmall": {
- "name": "HA Small Instance",
- "displaytext": "HA Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- "hosttags": "ha",
- "offerha": True,
- },
- "taggedsmall": {
- "name": "Tagged Small Instance",
- "displaytext": "Tagged Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- "hosttags": "vmsync",
- },
- },
- "service_offering_h1": {
- "name": "Tagged h1 Small Instance",
- "displaytext": "Tagged h1 Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- "hosttags": "h1"
- },
- "service_offering_h2": {
- "name": "Tagged h2 Small Instance",
- "displaytext": "Tagged h2 Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- "hosttags": "h2"
- },
- "disk_offering": {
- "name": "Disk offering",
- "displaytext": "Disk offering",
- "disksize": 1
- },
- 'resized_disk_offering': {
- "displaytext": "Resized",
- "name": "Resized",
- "disksize": 3
- },
- 'disk_offering_shared_5GB': {
- "displaytext": "disk_offering_shared_5GB",
- "name": "disk_offering_shared_5GB",
- "disksize": 5
- },
- 'disk_offering_shared_15GB': {
- "displaytext": "disk_offering_shared_5GB",
- "name": "disk_offering_shared_5GB",
- "disksize": 15
- },
- "network": {
- "name": "Test Network",
- "displaytext": "Test Network",
- "acltype": "Account",
- },
- "network2": {
- "name": "Test Network Shared",
- "displaytext": "Test Network Shared",
- "vlan": 1201,
- "gateway": "172.16.15.1",
- "netmask": "255.255.255.0",
- "startip": "172.16.15.21",
- "endip": "172.16.15.41",
- "acltype": "Account",
- },
- "network_offering": {
- "name": 'Test Network offering',
- "displaytext": 'Test Network offering',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- },
- },
- "nw_off_isolated_netscaler": {
- "name": 'Netscaler',
- "displaytext": 'Netscaler',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- "Vpn": 'VirtualRouter',
- "Firewall": 'VirtualRouter',
- "Lb": 'Netscaler',
- "UserData": 'VirtualRouter',
- "StaticNat": 'VirtualRouter',
- },
- },
- "nw_off_isolated_persistent": {
- "name": 'Test Nw off isolated persistent',
- "displaytext": 'Test Nw off isolated persistent',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
- "traffictype": 'GUEST',
- "ispersistent": 'True',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- },
- },
- "nw_off_isolated_persistent_lb": {
- "name": 'Test Nw off isolated persistent',
- "displaytext": 'Test Nw off isolated persistent',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Lb',
- "traffictype": 'GUEST',
- "ispersistent": 'True',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- "Lb": "VirtualRouter"
- },
- },
- "isolated_network_offering": {
- "name": "Network offering-DA services",
- "displaytext": "Network offering-DA services",
- "guestiptype": "Isolated",
- "supportedservices":
- "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat",
- "traffictype": "GUEST",
- "availability": "Optional'",
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "SourceNat": "VirtualRouter",
- "PortForwarding": "VirtualRouter",
- "Vpn": "VirtualRouter",
- "Firewall": "VirtualRouter",
- "Lb": "VirtualRouter",
- "UserData": "VirtualRouter",
- "StaticNat": "VirtualRouter"
- }
- },
- "network_offering_vlan": {
- "name": 'Test Network offering',
- "displaytext": 'Test Network offering',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
- "traffictype": 'GUEST',
- "specifyvlan": 'False',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- },
- },
- "network_offering_without_sourcenat": {
- "name": 'Test Network offering',
- "displaytext": 'Test Network offering',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,UserData',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "UserData": 'VirtualRouter',
- },
- },
- "isolated_network": {
- "name": "Isolated Network",
- "displaytext": "Isolated Network"
- },
- "netscaler_VPX": {
- "ipaddress": "10.223.240.174",
- "username": "nsroot",
- "password": "nsroot",
- "networkdevicetype": "NetscalerVPXLoadBalancer",
- "publicinterface": "1/1",
- "privateinterface": "1/2",
- "numretries": 2,
- "lbdevicededicated": "True",
- "lbdevicecapacity": 2,
- "port": 22
- },
- "netscaler_network": {
- "name": "Netscaler",
- "displaytext": "Netscaler",
- },
- "network_without_acl": {
- "name": "TestNetwork",
- "displaytext": "TestNetwork",
- },
- "virtual_machine": {
- "displayname": "Test VM",
- "username": "root",
- "password": "password",
- "ssh_port": 22,
- "privateport": 22,
- "publicport": 22,
- "protocol": "TCP",
- "affinity": {
- "name": "webvms",
- "type": "host anti-affinity",
- }
- },
- "virtual_machine_userdata": {
- "displayname": "Test VM",
- "username": "root",
- "password": "password",
- "ssh_port": 22,
- "privateport": 22,
- "publicport": 22,
- "protocol": "TCP",
- "affinity": {
- "name": "webvms",
- "type": "host anti-affinity",
- },
- "userdata": "This is sample data"
- },
- "virtual_machine2": {
- "name": "testvm2",
- "displayname": "Test VM2",
- },
- "virtual_machine3": {
- "name": "testvm3",
- "displayname": "Test VM3",
- },
- "shared_network": {
- "name": "MySharedNetwork - Test",
- "displaytext": "MySharedNetwork",
- "vlan": "",
- "gateway": "",
- "netmask": "",
- "startip": "",
- "endip": "",
- "acltype": "Domain",
- "scope": "all"
- },
- "shared_network_offering": {
- "name": "MySharedOffering-shared",
- "displaytext": "MySharedOffering",
- "guestiptype": "Shared",
- "supportedservices": "Dhcp,Dns,UserData",
- "specifyVlan": "False",
- "specifyIpRanges": "False",
- "traffictype": "GUEST",
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "UserData": "VirtualRouter"
- }
- },
- "shared_network_offering_all_services": {
- "name": "shared network offering with services enabled",
- "displaytext": "Shared network offering",
- "guestiptype": "Shared",
- "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat",
- "specifyVlan": "False",
- "specifyIpRanges": "False",
- "traffictype": "GUEST",
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "UserData": "VirtualRouter",
- "SourceNat": "VirtualRouter",
- "PortForwarding": "VirtualRouter",
- "Vpn": "VirtualRouter",
- "Firewall": "VirtualRouter",
- "Lb": "VirtualRouter",
- "UserData": "VirtualRouter",
- "StaticNat": "VirtualRouter"
- }
- },
- "shared_network_offering_sg": {
- "name": "MySharedOffering-sg",
- "displaytext": "MySharedOffering-sg",
- "guestiptype": "Shared",
- "supportedservices": "Dhcp,Dns,UserData,SecurityGroup",
- "specifyVlan": "False",
- "specifyIpRanges": "False",
- "traffictype": "GUEST",
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "UserData": "VirtualRouter",
- "SecurityGroup": "SecurityGroupProvider"
- }
- },
- "shared_network_sg": {
- "name": "Shared-Network-SG-Test",
- "displaytext": "Shared-Network_SG-Test",
- "networkofferingid": "1",
- "vlan": "",
- "gateway": "",
- "netmask": "255.255.255.0",
- "startip": "",
- "endip": "",
- "acltype": "Domain",
- "scope": "all"
- },
- "vpc_offering": {
- "name": "VPC off",
- "displaytext": "VPC off",
- "supportedservices":
- "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL"
- },
- "vpc_offering_multi_lb": {
- "name": "VPC offering with multiple Lb service providers",
- "displaytext": "VPC offering with multiple Lb service providers",
- "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL",
- "serviceProviderList": {
- "Vpn": 'VpcVirtualRouter',
- "Dhcp": 'VpcVirtualRouter',
- "Dns": 'VpcVirtualRouter',
- "SourceNat": 'VpcVirtualRouter',
- "Lb": ["InternalLbVm", "VpcVirtualRouter"],
- "PortForwarding": 'VpcVirtualRouter',
- "UserData": 'VpcVirtualRouter',
- "StaticNat": 'VpcVirtualRouter',
- "NetworkACL": 'VpcVirtualRouter'
- }
- },
- "vpc": {
- "name": "TestVPC",
- "displaytext": "TestVPC",
- "cidr": "10.0.0.1/24"
- },
- "vpc_network_domain": {
- "name": "TestVPC",
- "displaytext": "TestVPC",
- "cidr": '10.0.0.1/24',
- "network_domain": "TestVPC"
- },
- "clusters": {
- 0: {
- "clustername": "Xen Cluster",
- "clustertype": "CloudManaged",
- "hypervisor": "XenServer",
- },
- 1: {
- "clustername": "KVM Cluster",
- "clustertype": "CloudManaged",
- "hypervisor": "KVM",
- },
- 2: {
- "hypervisor": 'VMware',
- "clustertype": 'ExternalManaged',
- "username": 'administrator',
- "password": 'fr3sca',
- "url": 'http://192.168.100.17/CloudStack-Clogeny-Pune/Pune-1',
- "clustername": 'VMWare Cluster',
- },
- },
- "hosts": {
- "xenserver": {
- "hypervisor": 'XenServer',
- "clustertype": 'CloudManaged',
- "url": 'http://192.168.100.211',
- "username": "root",
- "password": "fr3sca",
- },
- "kvm": {
- "hypervisor": 'KVM',
- "clustertype": 'CloudManaged',
- "url": 'http://192.168.100.212',
- "username": "root",
- "password": "fr3sca",
- },
- "vmware": {
- "hypervisor": 'VMware',
- "clustertype": 'ExternalManaged',
- "url": 'http://192.168.100.203',
- "username": "administrator",
- "password": "fr3sca",
- },
- },
- "network_offering_shared": {
- "name": 'Test Network offering shared',
- "displaytext": 'Test Network offering Shared',
- "guestiptype": 'Shared',
- "supportedservices": 'Dhcp,Dns,UserData',
- "traffictype": 'GUEST',
- "specifyVlan": "True",
- "specifyIpRanges": "True",
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "UserData": 'VirtualRouter',
- },
- },
- "nw_off_isolated_RVR": {
- "name": "Network offering-RVR services",
- "displaytext": "Network off-RVR services",
- "guestiptype": "Isolated",
- "supportedservices": "Vpn,Dhcp,Dns,SourceNat,PortForwarding,Firewall,Lb,UserData,StaticNat",
- "traffictype": "GUEST",
- "availability": "Optional",
- "ispersistent": "False",
- "serviceProviderList": {
- "Vpn": "VirtualRouter",
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "SourceNat": "VirtualRouter",
- "PortForwarding": "VirtualRouter",
- "Firewall": "VirtualRouter",
- "Lb": "VirtualRouter",
- "UserData": "VirtualRouter",
- "StaticNat": "VirtualRouter"
- },
- "serviceCapabilityList": {
- "SourceNat": {
- "SupportedSourceNatTypes": "peraccount",
- "RedundantRouter": "true"
- },
- "lb": {
- "SupportedLbIsolation": "dedicated"
- }
- }
- },
- "nw_off_persistent_RVR": {
- "name": 'Network offering-RVR services',
- "displaytext": 'Network off-RVR services',
- "guestiptype": 'Isolated',
- "supportedservices":
- 'Vpn,Dhcp,Dns,SourceNat,PortForwarding,Firewall,Lb,UserData,StaticNat',
- "traffictype": 'GUEST',
- "ispersistent": 'True',
- "availability": 'Optional',
- "serviceProviderList": {
- "Vpn": 'VirtualRouter',
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- "Firewall": 'VirtualRouter',
- "Lb": 'VirtualRouter',
- "UserData": 'VirtualRouter',
- "StaticNat": 'VirtualRouter',
- },
- "serviceCapabilityList": {
- "SourceNat": {
- "SupportedSourceNatTypes": "peraccount",
- "RedundantRouter": "true",
- },
- "lb": {
- "SupportedLbIsolation": "dedicated"
- },
- },
- },
- "nw_offering_isolated_vpc": {
- "name": "Isolated Network for VPC",
- "displaytext": "Isolated Network for VPC",
- "guestiptype": "Isolated",
- "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,UserData,StaticNat,NetworkACL,Lb",
- "traffictype": "GUEST",
- "availability": "Optional",
- "ispersistent": "False",
- "useVpc": "on",
- "serviceProviderList": {
- "Dhcp": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter",
- "SourceNat": "VpcVirtualRouter",
- "PortForwarding": "VpcVirtualRouter",
- "Vpn": "VpcVirtualRouter",
- "UserData": "VpcVirtualRouter",
- "StaticNat": "VpcVirtualRouter",
- "NetworkACL": "VpcVirtualRouter",
- "Lb": "VpcVirtualRouter"
- }
- },
- "nw_off_persistent_VPCVR_LB": {
- "name": "Persistent Network VPC with LB",
- "displaytext": "Persistent Network VPC No LB",
- "guestiptype": "Isolated",
- "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL",
- "traffictype": "GUEST",
- "availability": "Optional",
- "ispersistent": "True",
- "useVpc": "on",
- "serviceProviderList": {
- "Dhcp": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter",
- "SourceNat": "VpcVirtualRouter",
- "PortForwarding": "VpcVirtualRouter",
- "Vpn": "VpcVirtualRouter",
- "Lb": "VpcVirtualRouter",
- "UserData": "VpcVirtualRouter",
- "StaticNat": "VpcVirtualRouter",
- "NetworkACL": "VpcVirtualRouter"
- }
- },
- "nw_off_persistent_VPCVR_NoLB": {
- "name": "Persistent Network VPC No LB",
- "displaytext": "Persistent Network VPC No LB",
- "guestiptype": "Isolated",
- "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,UserData,StaticNat,NetworkACL",
- "traffictype": "GUEST",
- "availability": "Optional",
- "ispersistent": "True",
- "useVpc": "on",
- "serviceProviderList": {
- "Dhcp": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter",
- "SourceNat": "VpcVirtualRouter",
- "PortForwarding": "VpcVirtualRouter",
- "Vpn": "VpcVirtualRouter",
- "UserData": "VpcVirtualRouter",
- "StaticNat": "VpcVirtualRouter",
- "NetworkACL": "VpcVirtualRouter"
- }
- },
- "nw_offering_shared_persistent": {
- "name": "Network offering for Shared Persistent Network",
- "displaytext": "Network offering-DA services",
- "guestiptype": "Shared",
- "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat",
- "traffictype": "GUEST",
- "availability": "Optional",
- "ispersistent": "True",
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "SourceNat": "VirtualRouter",
- "PortForwarding": "VirtualRouter",
- "Vpn": "VirtualRouter",
- "Firewall": "VirtualRouter",
- "Lb": "VirtualRouter",
- "UserData": "VirtualRouter",
- "StaticNat": "VirtualRouter"
- }
- },
- "fwrule": {
- "startport": 22,
- "endport": 22,
- "cidr": "0.0.0.0/0",
- "protocol": "TCP"
- },
- "nw_off_ncc_SharedSP": {
- "name": 'SharedSP',
- "displaytext": 'SharedSP',
- "guestiptype": 'Isolated',
- "supportedservices":
- 'Dhcp,Dns,SourceNat,Lb,StaticNat',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "Lb": 'Netscaler',
- "StaticNat": 'VirtualRouter'
- }
- },
- "nw_off_ncc_DedicatedSP": {
- "name": 'DedicatedSP',
- "displaytext": 'DedicatedSP',
- "guestiptype": 'Isolated',
- "supportedservices":
- 'Dhcp,Dns,SourceNat,Lb,StaticNat',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "Lb": 'Netscaler',
- "StaticNat": 'VirtualRouter'
- }
- },
- "NCC": {
- "NCCIP": '10.102.195.215',
- },
- "NSShared": {
- "NSIP": '10.102.195.210',
- },
- "NSDedicated": {
- "NSIP": '10.102.195.212'
- },
- "servicepackage_shared": {
- "name": "SharedSP",
- },
- "servicepackage_dedicated": {
- "name": "DedicatedSP",
- },
-
- "nw_off_isolated_persistent_netscaler": {
- "name": 'Netscaler',
- "displaytext": 'Netscaler',
- "guestiptype": 'Isolated',
- "supportedservices":
- 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
- "traffictype": 'GUEST',
- "ispersistent": 'True',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- "Vpn": 'VirtualRouter',
- "Firewall": 'VirtualRouter',
- "Lb": 'Netscaler',
- "UserData": 'VirtualRouter',
- "StaticNat": 'VirtualRouter',
- },
-
- },
- "network_acl_rule": {
- "protocol": "TCP",
- "traffictype": "ingress",
- "cidrlist": "0.0.0.0/0",
- "startport": "1",
- "endport": "1"
- },
- "network_offering_internal_lb": {
- "name": "Network offering for internal lb service",
- "displaytext": "Network offering for internal lb service",
- "guestiptype": "Isolated",
- "traffictype": "Guest",
- "supportedservices":
- "Vpn,Dhcp,Dns,Lb,UserData,SourceNat,StaticNat,PortForwarding,NetworkACL",
- "serviceProviderList": {
- "Dhcp": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter",
- "Vpn": "VpcVirtualRouter",
- "UserData": "VpcVirtualRouter",
- "Lb": "InternalLbVM",
- "SourceNat": "VpcVirtualRouter",
- "StaticNat": "VpcVirtualRouter",
- "PortForwarding": "VpcVirtualRouter",
- "NetworkACL": "VpcVirtualRouter",
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "peraccount"},
- "Lb": {"lbSchemes": "internal", "SupportedLbIsolation": "dedicated"}
- }
- },
- "natrule": {
- "privateport": 22,
- "publicport": 22,
- "protocol": "TCP"
- },
- "natrulerange": {
- "privateport": 70,
- "privateendport": 75,
- "publicport": 70,
- "publicendport": 75,
- "protocol": "TCP"
- },
- "updatenatrulerange": {
- "privateport": 50,
- "privateendport": 55,
- },
- "egress_80": {
- "startport": 80,
- "endport": 80,
- "protocol": "TCP",
- "cidrlist": ["0.0.0.0/0"]
- },
- "lbrule": {
- "name": "SSH",
- "alg": "roundrobin",
- "privateport": 22,
- "publicport": 2222,
- "protocol": 'TCP'
- },
- "vpclbrule": {
- "name": "SSH",
- "alg": "roundrobin",
- "privateport": 22,
- "publicport": 22,
- "protocol": 'TCP'
- },
- "internal_lbrule": {
- "name": "SSH",
- "algorithm": "roundrobin",
- # Algorithm used for load balancing
- "sourceport": 22,
- "instanceport": 22,
- "scheme": "internal",
- "protocol": "TCP",
- "cidrlist": '0.0.0.0/0',
- },
- "internal_lbrule_http": {
- "name": "HTTP",
- "algorithm": "roundrobin",
- # Algorithm used for load balancing
- "sourceport": 80,
- "instanceport": 80,
- "scheme": "internal",
- "protocol": "TCP",
- "cidrlist": '0.0.0.0/0',
- },
- "http_rule": {
- "privateport": 80,
- "publicport": 80,
- "startport": 80,
- "endport": 80,
- "protocol": "TCP",
- "cidrlist": '0.0.0.0/0',
- },
+nuage_test_data = {
"dns_rule": {
"privateport": 53,
"publicport": 53,
@@ -846,1012 +24,64 @@ test_data = {
"protocol": "UDP",
"cidrlist": '0.0.0.0/0',
},
- "icmprule": {
- "icmptype": -1,
- "icmpcode": -1,
- "cidrlist": "0.0.0.0/0",
- "protocol": "ICMP"
- },
- "iso": {
- "displaytext": "Test ISO",
- "name": "ISO",
- "url": "http://people.apache.org/~tsp/dummy.iso",
- "bootable": False,
- "ispublic": False,
- "ostype": "Other (64-bit)",
- },
- "iso1": {
- "displaytext": "Test ISO 1",
- "name": "ISO 1",
- "url": "http://people.apache.org/~tsp/dummy.iso",
- "isextractable": True,
- "isfeatured": True,
- "ispublic": True,
- "ostype": "CentOS 5.6 (64-bit)",
- },
- "iso2": {
- "displaytext": "Test ISO 2",
- "name": "ISO 2",
- "url": "http://people.apache.org/~tsp/dummy.iso",
- "isextractable": True,
- "isfeatured": True,
- "ispublic": True,
- "ostype": "CentOS 5.6 (64-bit)",
- "mode": 'HTTP_DOWNLOAD',
- },
- "isfeatured": True,
- "ispublic": True,
- "isextractable": True,
- "bootable": True,
- "passwordenabled": True,
-
- "template": {
- "displaytext": "xs",
- "name": "xs",
- "passwordenabled": False,
- "ostype": "CentOS 5.6 (64-bit)"
-
- },
- "coreos_volume": {
- "diskname": "Volume_core",
- "urlvmware":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-vmware.ova",
- "urlxen":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-xen.vhd.bz2",
- "urlkvm": "http://dl.openvm.eu/cloudstack/coreos/x86_64/" \
- "coreos_production_cloudstack_image-kvm.qcow2.bz2",
- "urlhyperv":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-hyperv.vhd.zip"
- },
- "CentOS6.3template": {
- "displaytext": "Centos",
- "name": "Centos",
- "passwordenabled": False,
- "ostype": "CentOS 6.3 (64-bit)",
- "url": "http://people.apache.org/~sanjeev/centos63.ova",
- "format": "OVA",
- "ispublic": "true"
- },
- "CentOS7template": {
- "displaytext": "Centos",
- "name": "Centos",
- "passwordenabled": False,
- "isdynamicallyscalable":True,
- "ostype": "CentOS 7",
- "url": "http://dl.openvm.eu/cloudstack/centos/vanilla/7/x86_64/CentOS-7-x86_64-vanilla-xen.vhd.bz2",
- "format": "VHD",
- "ispublic": "true",
- "hypervisor":"Xenserver"
- },
- "Rhel7template": {
- "displaytext": "Rhel",
- "name": "Rhel",
- "passwordenabled": False,
- "ostype": "Red Hat Enterprise Linux 7",
- "format": "OVA",
- "ispublic": "true"
- },
- "template_2": {
- "displaytext": "Public Template",
- "name": "Public template",
- "ostype": "CentOS 5.6 (64-bit)",
- "isfeatured": True,
- "ispublic": True,
- "isextractable": True,
- "mode": "HTTP_DOWNLOAD",
- "templatefilter": "self"
- },
- "Windows 7 (64-bit)": {
- "displaytext": "Windows 7 (64-bit)",
- "name": "Windows 7 (64-bit)",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/windows7.vhd",
- "format": "VHD",
- "ostype": "Windows 7 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
- "Windows Server 2012": {
- "displaytext": "Windows Server 2012",
- "name": "Windows Server 2012",
- "passwordenabled": False,
- "format": "OVA",
- "ostype": "Windows Server 2012 (64-bit)",
- "ispublic": "true",
- "hypervisor": "Vmware"
- },
- "privatetemplate": {
- "displaytext": "Public Template",
- "name": "Public template",
- "ostype": "CentOS 5.6 (64-bit)",
- "isfeatured": True,
- "ispublic": False,
- "isextractable": True,
- "mode": "HTTP_DOWNLOAD",
- "templatefilter": "self"
- },
- "volume_from_snapshot": {
- "diskname": 'Volume from snapshot',
- "size": "1",
- "zoneid": ""
- },
- "templatefilter": 'self',
- "templates": {
- "displaytext": 'Template',
- "name": 'Template',
- "ostype": "CentOS 5.3 (64-bit)",
- "templatefilter": 'self',
- },
- "win2012template": {
- "displaytext": "win2012",
- "name": "win2012",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/new-test-win.ova",
- "format": "OVA",
- "ostype": "Windows 8 (64-bit)",
- },
- "rhel60template": {
- "displaytext": "Rhel60",
- "name": "Rhel60",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/Rhel6-64bit.ova",
- "format": "OVA",
- "ostype": "Red Hat Enterprise Linux 6.0 (64-bit)"
- },
- "security_group": {"name": "custom_Sec_Grp"},
- "ingress_rule": {
- "protocol": "TCP",
- "startport": "22",
- "endport": "22",
- "cidrlist": "0.0.0.0/0"
- },
- "ingress_rule_ICMP": {
- "name": 'ICMP',
- "protocol": 'ICMP',
- "startport": -1,
- "endport": -1,
- "cidrlist": '0.0.0.0/0',
- },
- "vpncustomergateway": {
- "ipsecpsk": "secreatKey",
- "ikepolicy": "aes128-sha1",
- "ikelifetime": "86400",
- "esppolicy": "aes128-sha1",
- "epslifetime": "3600",
- "dpd": "false"
- },
- "vlan_ip_range": {
- "startip": "",
- "endip": "",
- "netmask": "",
- "gateway": "",
- "forvirtualnetwork": "false",
- "vlan": "untagged",
- },
- "ostype": "CoreOS",
- "sleep": 90,
- "timeout": 10,
- "page": 1,
- "pagesize": 2,
- "listall": 'true',
- "advanced_sg": {
- "zone": {
- "name": "",
- "dns1": "8.8.8.8",
- "internaldns1": "192.168.100.1",
- "networktype": "Advanced",
- "securitygroupenabled": "true"
- },
- "securitygroupenabled": "true"
- },
- "vlan": "10",
- "portableiprange_vlan": {
- "part": ["4090-4091", "4092-4095"],
- "full": "4090-4095"
- },
- "nfs": {
- "url": "nfs://nfs/export/automation/1/testprimary",
- "name": "Primary XEN"
- },
- "nfs2": {
- "url": "nfs://nfs/export/automation/1/testprimary2",
- "name": "Primary XEN 2"
- },
- "iscsi": {
- "url":
- "iscsi://192.168.100.21/iqn.2012-01.localdomain.clo-cstack-cos6:iser/1",
- "name": "Primary iSCSI"
- },
- "volume": {"diskname": "Test Volume",
- "size": 1
- },
- "volume_write_path": {
- "diskname": "APP Data Volume",
- "size": 1, # in GBs
- "xenserver": {"rootdiskdevice":"/dev/xvda",
- "datadiskdevice_1": '/dev/xvdb',
- "datadiskdevice_2": '/dev/xvdc', # Data Disk
- },
- "kvm": {"rootdiskdevice": "/dev/vda",
- "datadiskdevice_1": "/dev/vdb",
- "datadiskdevice_2": "/dev/vdc"
- },
- "vmware": {"rootdiskdevice": "/dev/hda",
- "datadiskdevice_1": "/dev/hdb",
- "datadiskdevice_2": "/dev/hdc"
- }
- },
- "data_write_paths": {
- "mount_dir": "/mnt/tmp",
- "sub_dir": "test",
- "sub_lvl_dir1": "test1",
- "sub_lvl_dir2": "test2",
- "random_data": "random.data",
- },
- "custom_volume": {
- "customdisksize": 1,
- "diskname": "Custom disk",
- },
- "recurring_snapshot": {
- "maxsnaps": 2,
- "timezone": "US/Arizona",
- "schedule": 1
- },
- "volume_offerings": {
- 0: {"diskname": "TestDiskServ"},
- },
- "diskdevice": ['/dev/vdc', '/dev/vdb', '/dev/hdb', '/dev/hdc',
- '/dev/xvdd', '/dev/cdrom', '/dev/sr0', '/dev/cdrom1'],
-
- # test_vpc_vpn.py
- "vpn_user": {
- "username": "test",
- "password": "password",
- },
- "vpc": {
- "name": "vpc_vpn",
- "displaytext": "vpc-vpn",
- "cidr": "10.1.1.0/24"
- },
- "ntwk": {
- "name": "tier1",
- "displaytext": "vpc-tier1",
- "gateway": "10.1.1.1",
- "netmask": "255.255.255.192"
- },
- "vpc2": {
- "name": "vpc2_vpn",
- "displaytext": "vpc2-vpn",
- "cidr": "10.2.1.0/24"
- },
- "ntwk2": {
- "name": "tier2",
- "displaytext": "vpc-tier2",
- "gateway": "10.2.1.1",
- "netmask": "255.255.255.192"
- },
- "privateport": 22,
- "publicport": 22,
- "protocol": 'TCP',
- "forvirtualnetwork": "true",
- "customdisksize": 1,
- "diskname": "Test Volume",
- "sparse": {
- "name": "Sparse Type Disk offering",
- "displaytext":
- "Sparse Type Disk offering",
- "disksize": 1, # in GB
- "provisioningtype": "sparse"
- },
- "fat": {
- "name": "Fat Type Disk offering",
- "displaytext":
- "Fat Type Disk offering",
- "disksize": 1, # in GB
- "provisioningtype": "fat"
- },
- "sparse_disk_offering": {
- "displaytext": "Sparse",
- "name": "Sparse",
- "provisioningtype": "sparse",
- "disksize": 1
- },
- "host_anti_affinity": {
- "name": "hostantiaffinity",
- "type": "host anti-affinity",
- },
- "vgpu": {
- "disk_offering": {
- "displaytext": "Small",
- "name": "Small",
- "disksize": 1
- },
- "templateregister1": {
- "displaytext": "win8withpv",
- "name": "win8withpv",
- "passwordenabled": False,
- "url": "http://pleaseupdateURL/dummy.vhd",
- "format": "VHD",
- "ostype": "Windows 8 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
- "Windows 8 (64-bit)": {
- "displaytext": "Windows 8 (64-bit)",
- "name": "win8withpv",
- "passwordenabled": False,
- "url": "http://pleaseupdateURL/dummy.vhd",
- "format": "VHD",
- "ostype": "Windows 8 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
- "Windows Server 2012 (64-bit)": {
- "displaytext": "Windows Server 2012 (64-bit)",
- "name": "Windows Server 2012 (64-bit)",
- "passwordenabled": False,
- "url": "http://pleaseupdateURL/dummy.vhd",
- "format": "VHD",
- "ostype": "Windows Server 2012 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
-
- "Windows 7 (64-bit)": {
- "displaytext": "Windows 7 (64-bit)",
- "name": "Windows 7 (64-bit)",
- "passwordenabled": False,
- "url": "http://pleaseupdateURL/dummy.vhd",
- "format": "VHD",
- "ostype": "Windows 7 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
- "RHEL 7 (64-bit)": {
- "displaytext": "RHEL7 (64-bit)",
- "name": "RHEL 7 Insta1",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/RHEL764bitwithtools.vhd",
- "format": "VHD" ,
- "ostype": "RHEL 7 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
- "clusters": {
- "clustername": "Xen Cluster Vgpu",
- "clustertype": "CloudManaged",
- "hypervisor": "XenServer"
- },
- "hosts": {
- "nonvgpuxenserver": {
- "hypervisor": 'XenServer',
- "clustertype": 'CloudManaged',
- "url": 'http://10.102.192.57',
- "username": "root",
- "password": "freebsd",
- },
- },
- "account": {
- "email": "test@test.com",
- "firstname": "Test",
- "lastname": "User",
- "username": "test",
- # Random characters are appended in create account to
- # ensure unique username generated each time
- "password": "password",
- },
- "service_offerings":
- {
- "GRID K260Q":
- {
- "name": "vGPU260Q",
- "displaytext": "vGPU260Q",
- "cpunumber": 2,
- "cpuspeed": 1600, # in MHz
- "memory": 3072, # In MBs
- },
- "GRID K240Q":
- {
- "name": "vGPU240Q",
- "displaytext": "vGPU240Q",
- "cpunumber": 2,
- "cpuspeed": 1600, # in MHz
- "memory": 3072, # In MBs
- },
- "GRID K220Q":
- {
- "name": "vGPU220Q",
- "displaytext": "vGPU220Q",
- "cpunumber": 2,
- "cpuspeed": 1600, # in MHz
- "memory": 3072, # In MBs
- },
- "GRID K200":
- {
- "name": "vGPU200",
- "displaytext": "vGPU200",
- "cpunumber": 2,
- "cpuspeed": 1600, # in MHz
- "memory": 3072, # In MBs
- },
- "passthrough":
- {
- "name": "vGPU passthrough",
- "displaytext": "vGPU passthrough",
- "cpunumber": 2,
- "cpuspeed": 1600, # in MHz
- "memory": 3072, # In MBs
- },
- "GRID K140Q":
- {
- # Small service offering ID to for change VM
- # service offering from medium to small
- "name": "vGPU140Q",
- "displaytext": "vGPU140Q",
- "cpunumber": 2,
- "cpuspeed": 1600,
- "memory": 3072,
- },
- "GRID K120Q":
- {
- "name": "vGPU120Q",
- "displaytext": "vGPU120Q",
- "cpunumber": 2,
- "cpuspeed": 1600,
- "memory": 3072,
- },
- "GRID K100":
- {
- "name": "vGPU100",
- "displaytext": "vGPU100",
- "cpunumber": 2,
- "cpuspeed": 1600,
- "memory": 3072,
- },
- "nonvgpuoffering":
- {
- "name": "nonvgpuoffering",
- "displaytext": "nonvgpuoffering",
- "cpunumber": 2,
- "cpuspeed": 1600,
- "memory": 3072,
- }
-
- },
- "diskdevice": ['/dev/vdc', '/dev/vdb', '/dev/hdb', '/dev/hdc', '/dev/xvdd', '/dev/cdrom', '/dev/sr0',
- '/dev/cdrom1'],
- # Disk device where ISO is attached to instance
- "mount_dir": "/mnt/tmp",
- "sleep": 180,
- "timeout": 60,
- "ostype": 'Windows 8 (64-bit)',
- "nongpu_host_ip": "10.102.192.57"
- },
- "acl": {
- #data for domains and accounts
- "domain1": {
- "name": "D1",
- },
- "accountD1": {
- "email": "testD1@test.com",
- "firstname": "testD1",
- "lastname": "Admin",
- "username": "testD1",
- "password": "password",
- "accounttype": "1",
- },
- "accountD1A": {
- "email": "testD1A@test.com",
- "firstname": "testD1A",
- "lastname": "User",
- "username": "testD1A",
- "password": "password",
- },
- "accountD1B": {
- "email": "testD1B@test.com",
- "firstname": "testD1B",
- "lastname": "User",
- "username": "testD1B",
- "password": "password",
- },
- "domain11": {
- "name": "D11",
- },
- "accountD11": {
- "email": "testD11@test.com",
- "firstname": "testD11",
- "lastname": "Admin",
- "username": "testD11",
- "password": "password",
- "accounttype": "1",
- },
- "accountD11A": {
- "email": "testD11A@test.com",
- "firstname": "testD11A",
- "lastname": "User",
- "username": "testD11A",
- "password": "password",
- },
- "accountD11B": {
- "email": "test11B@test.com",
- "firstname": "testD11B",
- "lastname": "User",
- "username": "testD11B",
- "password": "password",
- },
- "domain111": {
- "name": "D111",
- },
- "accountD111": {
- "email": "testD111@test.com",
- "firstname": "testD111",
- "lastname": "Admin",
- "username": "testD111",
- "password": "password",
- },
- "accountD111A": {
- "email": "testD111A@test.com",
- "firstname": "testD111A",
- "lastname": "User",
- "username": "testD111A",
- "password": "password",
- },
- "accountD111B": {
- "email": "testD111B@test.com",
- "firstname": "testD111B",
- "lastname": "User",
- "username": "testD111B",
- "password": "password",
- },
- "domain12": {
- "name": "D12",
- },
- "accountD12A": {
- "email": "testD12A@test.com",
- "firstname": "testD12A",
- "lastname": "User",
- "username": "testD12A",
- "password": "password",
- },
- "accountD12B": {
- "email": "testD12B@test.com",
- "firstname": "testD12B",
- "lastname": "User",
- "username": "testD12B",
- "password": "password",
- },
- "domain2": {
- "name": "D2",
- },
- "accountD2": {
- "email": "testD2@test.com",
- "firstname": "testD2",
- "lastname": "User",
- "username": "testD2",
- "password": "password",
- "accounttype": "1",
- },
- "accountD2A": {
- "email": "testD2A@test.com",
- "firstname": "testD2A",
- "lastname": "User",
- "username": "testD2A",
- "password": "password",
- },
- "accountROOTA": {
- "email": "testROOTA@test.com",
- "firstname": "testROOTA",
- "lastname": "User",
- "username": "testROOTA",
- "password": "password",
- },
-
- "accountROOT": {
- "email": "testROOTA@test.com",
- "firstname": "testROOT",
- "lastname": "admin",
- "username": "testROOT",
- "password": "password",
- },
- #data reqd for virtual machine creation
- "vmD1": {
- "name": "d1",
- "displayname": "d1",
- },
- "vmD1A": {
- "name": "d1a",
- "displayname": "d1a",
- },
- "vmD1B": {
- "name": "d1b",
- "displayname": "d1b",
- },
- "vmD11": {
- "name": "d11",
- "displayname": "d11",
- },
- "vmD11A": {
- "name": "d11a",
- "displayname": "d11a",
- },
- "vmD11B": {
- "name": "d11b",
- "displayname": "d11b",
- },
- "vmD111": {
- "name": "d111",
- "displayname": "d111",
- },
- "vmD111A": {
- "name": "d111a",
- "displayname": "d111a",
- },
- "vmD111B": {
- "name": "d111b",
- "displayname": "d111b",
- },
- "vmD12A": {
- "name": "d12a",
- "displayname": "d12a",
- },
- "vmD12B": {
- "name": "d12b",
- "displayname": "d12b",
- },
- "vmD2A": {
- "name": "d2a",
- "displayname": "d2a",
- },
-
- "vmROOTA": {
- "name": "roota",
- "displayname": "roota",
- },
- "vmROOT": {
- "name": "root",
- "displayname": "root",
- },
-
- #data reqd for Network creation
- "network_all": {
- "name": "SharedNetwork-All",
- "displaytext": "SharedNetwork-All",
- "vlan": "4001",
- "gateway": "10.223.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.223.1.2",
- "endip": "10.223.1.100",
- "acltype": "Domain"
- },
- "network_domain_with_no_subdomain_access": {
- "name": "SharedNetwork-Domain-nosubdomain",
- "displaytext": "SharedNetwork-Domain-nosubdomain",
- "vlan": "4002",
- "gateway": "10.223.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.223.1.2",
- "endip": "10.223.1.100",
- "acltype": "Domain",
- "subdomainaccess": "false"
- },
- "network_domain_with_subdomain_access": {
- "name": "SharedNetwork-Domain-withsubdomain",
- "displaytext": "SharedNetwork-Domain-withsubdomain",
- "vlan": "4003",
- "gateway": "10.223.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.223.1.2",
- "endip": "10.223.1.100",
- "acltype": "Domain",
- "subdomainaccess": "true"
- },
- "network_account": {
- "name": "SharedNetwork-Account",
- "displaytext": "SharedNetwork-Account",
- "vlan": "4004",
- "gateway": "10.223.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.223.1.2",
- "endip": "10.223.1.100",
- "acltype": "Account"
- },
-
- "network": {
- "name": "Network-",
- "displaytext": "Network-",
- "gateway": "10.223.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.223.59.200",
- "endip": "10.223.59.240",
- "vlan": "1000"
- },
- "netscaler": {
- "ipaddress": "",
- "username": "",
- "password": "",
- "networkdevicetype": "",
- "publicinterface": "",
- "privateinterface": "",
- "numretries": "",
- "lbdevicededicated": "False",
- "lbdevicecapacity": 2,
- "port": 22
- },
- "iscsi": {
- "url": "",
- "name": "Primary iSCSI"
- },
- "host": {
- "publicport": 22,
- "username": "root",
- "password": "password",
- },
- "ldap_account": {
- "email": "",
- "firstname": "",
- "lastname": "",
- "username": "",
- "password": "",
- },
- "ldap_configuration": {
- "basedn": "",
- "emailAttribute": "",
- "userObject": "",
- "usernameAttribute": "",
- "hostname": "",
- "port": "",
- "ldapUsername": "",
- "ldapPassword": ""
- },
- "systemVmDelay": 120,
- "setUsageConfigurationThroughTestCase": False,
- "vmware_cluster" : {
- "hypervisor": 'VMware',
- "clustertype": 'ExternalManaged',
- "username": '',
- "password": '',
- "url": '',
- "clustername": 'VMWare Cluster with Space in DC name',
- "startip": "10.223.1.2",
- "endip": "10.223.1.100",
- },
- #small service offering
- "service_offering": {
- "small": {
- "name": "Small Instance",
- "displaytext": "Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 128,
- },
- },
- "ostype": 'CentOS 5.6 (64-bit)',
+ "vpc_offering_reduced": {
+ "name": "VPC reduced off",
+ "displaytext": "VPC reduced off",
+ "supportedservices":
+ "Dhcp,Dns,SourceNat,UserData,StaticNat,NetworkACL"
},
- "test_34_DeployVM_in_SecondSGNetwork": {
- "zone": "advsg",
- "config": "D:\ACS-Repo\setup\dev\\advancedsg.cfg", #Absolute path to cfg file
- #For sample configuration please refer to <ACS repo>/setup/dev/advancedsg.cfg
- "template": "CentOS 5.3(64-bit) no GUI (Simulator)",
- "dbSvr": {
- "dbSvr": "10.146.0.133",
- "passwd": "cloud",
- "db": "cloud",
- "port": 3306,
- "user": "cloud"
- },
- "mgtSvr": [
- {
- "mgtSvrIp": "10.146.0.133",
- "passwd": "password",
- "user": "root",
- "port": 8096
- }
- ],
- "ipranges": [
- {
- "startip": "10.147.32.150",
- "endip": "10.147.32.153",
- "netmask": "255.255.255.0",
- "vlan": "32",
- "gateway": "10.147.32.1"
- }
- ]
+ "shared_network_config_drive_offering": {
+ "name": 'shared_network_config_drive_offering',
+ "displaytext": 'shared_network_config_drive_offering',
+ "guestiptype": 'shared',
+ "supportedservices": 'Dhcp,UserData',
+ "traffictype": 'GUEST',
+ "specifyVlan": "True",
+ "specifyIpRanges": "True",
+ "availability": 'Optional',
+ "serviceProviderList": {
+ "Dhcp": "VirtualRouter",
+ "UserData": 'ConfigDrive'
+ }
},
-
- "interop":
- {
- "VHD":
- {
- "displaytext": "Windows 8 (64-bit)",
- "name": "win8withpvxen",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
- "format": "VHD" ,
- "ostype": "Windows 8 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
-
- },
- "OVA":
- {
- "displaytext": "Windows 8 (64-bit)",
- "name": "win8withpvvmware",
- "passwordenabled": False,
- "url": "http://pleaseupdateURL/",
- "format": "OVA" ,
- "ostype": "Windows 8 (64-bit)",
- "ispublic": "true",
- "hypervisor": "VMware"
- },
- "template": {
- "displaytext": "windowsxdtemplate",
- "name": "windowsxdtemplate",
- "passwordenabled": False,
- "ostype": "Windows 8 (64-bit)"
- },
- },
-
- "browser_upload_volume":{
- "VHD": {
- "diskname": "XenUploadVol",
- "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.vhd",
- "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
- },
- "OVA": {
- "diskname": "VMwareUploadVol",
- "url": "http://people.apache.org/~sanjeev/CentOS5.5(64bit)-vmware-autoscale.ova",
- "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
- },
- "QCOW2": {
- "diskname": "KVMUploadVol",
- "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.qcow2",
- "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
- },
- 'browser_resized_disk_offering': {
- "displaytext": "Resizeddisk",
- "name": "Resizeddisk",
- "disksize": 3,
+ "isolated_staticnat_network_offering": {
+ "name": 'isolated_staticnat_net_off_marvin',
+ "displaytext": 'isolated_staticnat_net_off_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,StaticNat,UserData,Firewall,Dns',
+ "traffictype": 'GUEST',
+ "ispersistent": 'True',
+ "availability": 'Optional',
+ "tags": 'native',
+ "serviceProviderList": {
+ "Dhcp": 'VirtualRouter',
+ "StaticNat": 'VirtualRouter',
+ "SourceNat": 'VirtualRouter',
+ "Firewall": 'VirtualRouter',
+ "UserData": 'VirtualRouter',
+ "Dns": 'VirtualRouter'
}
},
- "browser_upload_template": {
- "VHD": {
- "templatename": "XenUploadtemplate",
- "displaytext": "XenUploadtemplate",
- "url": "http://people.apache.org/~sanjeev/centos56-x86_64.vhd.bz2",
- "hypervisor":"XenServer",
- "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
- "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
- },
- "OVA": {
- "templatename": "VMwareUploadtemplate",
- "displaytext": "VMwareUploadtemplate",
- "url": "http://people.apache.org/~sanjeev/CentOS5.3-x86_64.ova",
- "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
- "hypervisor":"VMware",
- "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
- },
- "QCOW2": {
- "templatename": "KVMUploadtemplate",
- "displaytext": "VMwareUploadtemplate",
- "url": "http://people.apache.org/~sanjeev/eec2209b-9875-3c8d-92be-c001bd8a0faf.qcow2.bz2",
- "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
- "hypervisor":"KVM",
- "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
- },
+ "nw_offering_reduced_vpc": {
+ "name": 'Reduced Network for VPC',
+ "displaytext": 'Reduced Network for VPC',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,UserData,'
+ 'Dns',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "tags": "native",
+ "useVpc": 'on',
+ "ispersistent": 'True',
+ "serviceProviderList": {
+ "Dhcp": "VpcVirtualRouter",
+ "StaticNat": "VpcVirtualRouter",
+ "SourceNat": "VpcVirtualRouter",
+ "NetworkACL": "VpcVirtualRouter",
+ "UserData": "VpcVirtualRouter",
+ "Dns": "VpcVirtualRouter"
+ }
},
- "configurableData":
- {
- "portableIpRange": {
- "gateway": "10.223.59.1",
- "netmask": "255.255.255.0",
- "startip": "10.223.59.200",
- "endip": "10.223.59.240",
- "vlan": "1000"
- },
- "netscaler": {
- "ipaddress": "",
- "username": "",
- "password": "",
- "networkdevicetype": "",
- "publicinterface": "",
- "privateinterface": "",
- "numretries": "",
- "lbdevicededicated": "False",
- "lbdevicecapacity": 2,
- "port": 22
- },
- "iscsi": {
- "url": "",
- "name": "Primary iSCSI"
- },
- "host": {
- "publicport": 22,
- "username": "root",
- "password": "password",
- },
- "ldap_account": {
- "email": "",
- "firstname": "",
- "lastname": "",
- "username": "",
- "password": "",
- },
- "link_ldap_details": {
- "domain_name": "",
- "accounttype": "",
- "name": "",
- "type": "",
- "admin": "",
- "linkLdapUsername": "",
- "linkLdapPassword": "",
- "linkLdapNestedUser": "",
- "linkLdapNestedPassword": ""
-
- },
- "ldap_configuration": {
- "basedn": "",
- "emailAttribute": "",
- "userObject": "",
- "usernameAttribute": "",
- "hostname": "",
- "port": "",
- "ldapUsername": "",
- "ldapPassword": ""
- },
- "systemVmDelay": 120,
- "setUsageConfigurationThroughTestCase": True,
- "vmware_cluster": {
- "hypervisor": 'VMware',
- "clustertype": 'ExternalManaged',
- "username": '',
- "password": '',
- "url": '',
- "clustername": 'VMWare Cluster with Space in DC name',
- },
- "upload_volume": {
- "diskname": "UploadVol",
- "format": "VHD",
- "url": "http://download.cloudstack.org/releases/2.0.0/UbuntuServer-10-04-64bit.vhd.bz2",
- "checksum": "",
- },
- "bootableIso":
- {
- "displaytext": "Test Bootable ISO",
- "name": "testISO",
- "bootable": True,
- "ispublic": False,
- "url": "http://people.apache.org/~sanjeev/CentOS-6.3-x86_64-bin-DVD1.iso",
- "ostype": 'CentOS 6.3 (64-bit)',
- "mode": 'HTTP_DOWNLOAD'
- },
- "setHostConfigurationForIngressRule": False,
- "restartManagementServerThroughTestCase": False,
- "vmxnet3template": {
- "displaytext": "VMXNET3 Template",
- "name": "VMXNET3 template",
- "ostype": "CentOS 5.6 (64-bit)",
- "isfeatured": True,
- "ispublic": False,
- "isextractable": True,
- "mode": "HTTP_DOWNLOAD",
- "templatefilter": "self",
- "url": "http://people.apache.org/~sanjeev/systemvm64template-2014-09-30-4.3-vmware.ova",
- "hypervisor": "vmware",
- "format": "OVA",
- "nicadapter": "vmxnet3",
- "kvm": {
- "url": ""
- },
- "vmware": {
- "url": ""
- },
- "xenserver": {
- "url": ""
- },
- "hyperv": {
- "url": ""
- },
- "ostype": 'CentOS 5.3 (64-bit)',
- "mode": 'HTTP_DOWNLOAD'
- }
- },
# Nuage VSP SDN plugin specific test data
"nuagevsp": {
# Services supported by the Nuage VSP plugin for Isolated networks
@@ -1862,6 +92,53 @@ test_data = {
"supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
"traffictype": 'GUEST',
"availability": 'Optional',
+ "tags": "nuage",
+ "serviceProviderList": {
+ "Dhcp": 'NuageVsp',
+ "StaticNat": 'NuageVsp',
+ "SourceNat": 'NuageVsp',
+ "Firewall": 'NuageVsp',
+ "Connectivity": 'NuageVsp',
+ "UserData": 'VirtualRouter',
+ "Dns": 'VirtualRouter'
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ # Persistent services supported by the Nuage VSP plugin for Isolated networks
+ "isolated_network_offering_persistent": {
+ "name": 'nuage_marvin',
+ "displaytext": 'nuage_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "ispersistent": 'True',
+ "tags": "nuage",
+ "serviceProviderList": {
+ "Dhcp": 'NuageVsp',
+ "StaticNat": 'NuageVsp',
+ "SourceNat": 'NuageVsp',
+ "Firewall": 'NuageVsp',
+ "Connectivity": 'NuageVsp',
+ "UserData": 'VirtualRouter',
+ "Dns": 'VirtualRouter'
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ # Persistent services supported by the Nuage VSP plugin for Isolated networks
+ "isolated_network_offering_persistent": {
+ "name": 'nuage_marvin',
+ "displaytext": 'nuage_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "ispersistent": 'True',
+ "tags": "nuage",
"serviceProviderList": {
"Dhcp": 'NuageVsp',
"StaticNat": 'NuageVsp',
@@ -1875,6 +152,47 @@ test_data = {
"SourceNat": {"SupportedSourceNatTypes": "perzone"}
}
},
+ # Purely nuage network offering
+ "isolated_network_offering_without_vr": {
+ "name": 'nuage_marvin',
+ "displaytext": 'nuage_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
+ "traffictype": 'GUEST',
+ "availabiliy": 'Optional',
+ "tags": "nuage",
+ "serviceProviderList": {
+ "Dhcp": 'NuageVsp',
+ "StaticNat": 'NuageVsp',
+ "SourceNat": 'NuageVsp',
+ "Firewall": 'NuageVsp',
+ "Connectivity": 'NuageVsp'
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ # Purely persistent nuage network offering
+ "isolated_network_offering_without_vr_persistent": {
+ "name": 'nuage_marvin',
+ "displaytext": 'nuage_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "tags": "nuage",
+ "ispersistent": 'True',
+ "serviceProviderList": {
+ "Dhcp": 'NuageVsp',
+ "StaticNat": 'NuageVsp',
+ "SourceNat": 'NuageVsp',
+ "Firewall": 'NuageVsp',
+ "Connectivity": 'NuageVsp'
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
# Services supported by the Nuage VSP plugin for VPC networks
"vpc_network_offering": {
"name": 'nuage_vpc_marvin',
@@ -1885,6 +203,7 @@ test_data = {
"availability": 'Optional',
"useVpc": 'on',
"ispersistent": 'True',
+ "tags": "nuage",
"serviceProviderList": {
"Dhcp": "NuageVsp",
"StaticNat": "NuageVsp",
@@ -1905,6 +224,7 @@ test_data = {
"supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
"traffictype": 'GUEST',
"availability": 'Optional',
+ "tags": "nuage",
"useVpc": 'on',
"ispersistent": 'True',
"serviceProviderList": {
@@ -1952,6 +272,180 @@ test_data = {
"Dns": "VpcVirtualRouter"
}
},
+ # Services supported by the Nuage VSP plugin for VPC without userdata
+ "vpc_network_offering_nuage_dhcp": {
+ "name": 'nuage_vpc_marvin',
+ "displaytext": 'nuage_vpc_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "useVpc": 'on',
+ "ispersistent": 'True',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "StaticNat": "NuageVsp",
+ "SourceNat": "NuageVsp",
+ "NetworkACL": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "Dns": "VpcVirtualRouter",
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ "isolated_configdrive_network_offering_withoutdns" : {
+ "name": 'nuage_configdrive_withoutDns_marvin',
+ "displaytext": 'nuage_configdrive_withoutDns_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "serviceProviderList": {
+ "Dhcp": 'NuageVsp',
+ "StaticNat": 'NuageVsp',
+ "SourceNat": 'NuageVsp',
+ "Firewall": 'NuageVsp',
+ "Connectivity": 'NuageVsp',
+ "UserData": 'ConfigDrive'
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ "isolated_configdrive_network_offering": {
+ "name": 'nuage_configdrive_marvin',
+ "displaytext": 'nuage_configdrive_marvin',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "serviceProviderList": {
+ "Dhcp": 'NuageVsp',
+ "StaticNat": 'NuageVsp',
+ "SourceNat": 'NuageVsp',
+ "Firewall": 'NuageVsp',
+ "Connectivity": 'NuageVsp',
+ "UserData": 'ConfigDrive',
+ "Dns": 'VirtualRouter'
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ "vpc_network_offering_configdrive_withoutdns" : {
+ "name": 'nuage_vpc_marvin_configdrive_withoutdns',
+ "displaytext": 'nuage_vpc_marvin_configdrive_withoutdns',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "useVpc": 'on',
+ "ispersistent": 'True',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "StaticNat": "NuageVsp",
+ "SourceNat": "NuageVsp",
+ "NetworkACL": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "UserData": "ConfigDrive"
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ "vpc_network_offering_configdrive_withdns" : {
+ "name": 'nuage_vpc_marvin_configdrive_withdns',
+ "displaytext": 'nuage_vpc_marvin_configdrive_withdns',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "useVpc": 'on',
+ "ispersistent": 'True',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "StaticNat": "NuageVsp",
+ "SourceNat": "NuageVsp",
+ "NetworkACL": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "UserData": "ConfigDrive",
+ "Dns": "VpcVirtualRouter"
+ },
+ "serviceCapabilityList": {
+ "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+ }
+ },
+ "vpc_offering_configdrive_withoutdns" : {
+ "name": 'Nuage VSP VPC offering ConfigDrive',
+ "displaytext": 'Nuage VSP VPC offering ConfigDrive',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "StaticNat": "NuageVsp",
+ "SourceNat": "NuageVsp",
+ "NetworkACL": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "UserData": "ConfigDrive"
+ }
+ },
+ "vpc_offering_configdrive_withdns" :{
+ "name": 'Nuage VSP VPC offering ConfigDrive withVR',
+ "displaytext": 'Nuage VSP VPC offering ConfigDrive withVR',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "StaticNat": "NuageVsp",
+ "SourceNat": "NuageVsp",
+ "NetworkACL": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "UserData": "ConfigDrive",
+ "Dns": "VpcVirtualRouter"
+ }
+ },
+ "shared_nuage_network_config_drive_offering" : {
+ "name": 'nuage_marvin',
+ "displaytext": 'nuage_marvin',
+ "guestiptype": 'shared',
+ "supportedservices": 'Dhcp,Connectivity,UserData',
+ "traffictype": 'GUEST',
+ "specifyVlan": "False",
+ "specifyIpRanges": "True",
+ "availability": 'Optional',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "UserData": 'ConfigDrive'
+ },
+ "serviceCapabilityList": {
+ "Connectivity": {
+ "PublicAccess": "true"
+ }
+ }
+ },
+ "network_all2" : {
+ "name": "SharedNetwork2-All-nuage",
+ "displaytext": "SharedNetwork2-All-nuage",
+ "gateway": "10.200.200.1",
+ "netmask": "255.255.255.0",
+ "startip": "10.200.200.21",
+ "endip": "10.200.200.100",
+ "acltype": "Domain"
+ },
+ # Services supported by the Nuage VSP plugin for VPCs
+ "vpc_offering_nuage_dhcp": {
+ "name": 'Nuage VSP VPC offering',
+ "displaytext": 'Nuage VSP VPC offering',
+ "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
+ "serviceProviderList": {
+ "Dhcp": "NuageVsp",
+ "StaticNat": "NuageVsp",
+ "SourceNat": "NuageVsp",
+ "NetworkACL": "NuageVsp",
+ "Connectivity": "NuageVsp",
+ "Dns": "VpcVirtualRouter",
+ }
+ },
"shared_nuage_network_offering": {
"name": 'nuage_marvin',
"displaytext": 'nuage_marvin',
@@ -1961,6 +455,7 @@ test_data = {
"specifyVlan": "False",
"specifyIpRanges": "True",
"availability": 'Optional',
+ "tags": "nuage",
"serviceProviderList": {
"Dhcp": "NuageVsp",
"Connectivity": "NuageVsp"
@@ -1975,6 +470,7 @@ test_data = {
"specifyVlan": "False",
"specifyIpRanges": "True",
"availability": 'Optional',
+ "tags": "nuage",
"serviceProviderList": {
"Dhcp": "NuageVsp",
"Connectivity": "NuageVsp"
@@ -1990,10 +486,10 @@ test_data = {
"network_all": {
"name": "SharedNetwork-All-nuage",
"displaytext": "SharedNetwork-All-nuage",
- "gateway": "10.223.1.1",
+ "gateway": "10.200.100.1",
"netmask": "255.255.255.0",
- "startip": "10.223.1.21",
- "endip": "10.223.1.100",
+ "startip": "10.200.100.21",
+ "endip": "10.200.100.100",
"acltype": "Domain"
},
"network_domain_with_no_subdomain_access": {
@@ -2025,11 +521,26 @@ test_data = {
"endip": "10.220.1.100",
"acltype": "Account"
},
+ "shared_network_offering": {
+ "name": "MySharedOffering-shared",
+ "displaytext": "MySharedOffering",
+ "guestiptype": "Shared",
+ "supportedservices": "Dhcp,Dns,UserData",
+ "specifyVlan": "True",
+ "specifyIpRanges": "True",
+ "traffictype": "GUEST",
+ "tags": "native",
+ "serviceProviderList": {
+ "Dhcp": "VirtualRouter",
+ "Dns": "VirtualRouter",
+ "UserData": "VirtualRouter"
+ }
+ },
"publiciprange1": {
- "gateway": "10.223.1.1",
+ "gateway": "10.200.100.1",
"netmask": "255.255.255.0",
- "startip": "10.223.1.101",
- "endip": "10.223.1.105",
+ "startip": "10.200.100.101",
+ "endip": "10.200.100.105",
"forvirtualnetwork": "false"
},
"publiciprange2": {
@@ -2040,10 +551,10 @@ test_data = {
"forvirtualnetwork": "false"
},
"publiciprange3": {
- "gateway": "10.223.1.1",
+ "gateway": "10.200.100.1",
"netmask": "255.255.255.0",
- "startip": "10.223.1.2",
- "endip": "10.223.1.20",
+ "startip": "10.200.100.2",
+ "endip": "10.200.100.20",
"forvirtualnetwork": "false"
}
}
diff --git a/test/integration/plugins/nuagevsp/test_nuage_configdrive.py b/test/integration/plugins/nuagevsp/test_nuage_configdrive.py
index 7832122..a7b80b1 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_configdrive.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_configdrive.py
@@ -76,153 +76,6 @@ class MySSHKeyPair:
apiclient.deleteSSHKeyPair(cmd)
-class Services:
- """Test Add Remove Network Services
- """
-
- def __init__(self):
- self.services = {
- "isolated_configdrive_network_offering_withoutdns" : {
- "name": 'nuage_configdrive_withoutDns_marvin',
- "displaytext": 'nuage_configdrive_withoutDns_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp',
- "UserData": 'ConfigDrive'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- "isolated_configdrive_network_offering": {
- "name": 'nuage_configdrive_marvin',
- "displaytext": 'nuage_configdrive_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp',
- "UserData": 'ConfigDrive',
- "Dns": 'VirtualRouter'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- "vpc_network_offering_configdrive_withoutdns" : {
- "name": 'nuage_vpc_marvin_configdrive_withoutdns',
- "displaytext": 'nuage_vpc_marvin_configdrive_withoutdns',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "useVpc": 'on',
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "ConfigDrive"
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- "vpc_network_offering_configdrive_withdns" : {
- "name": 'nuage_vpc_marvin_configdrive_withdns',
- "displaytext": 'nuage_vpc_marvin_configdrive_withdns',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "useVpc": 'on',
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "ConfigDrive",
- "Dns": "VpcVirtualRouter"
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- "vpc_offering_configdrive_withoutdns" : {
- "name": 'Nuage VSP VPC offering ConfigDrive',
- "displaytext": 'Nuage VSP VPC offering ConfigDrive',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "ConfigDrive"
- }
- },
- "vpc_offering_configdrive_withdns" :{
- "name": 'Nuage VSP VPC offering ConfigDrive withVR',
- "displaytext": 'Nuage VSP VPC offering ConfigDrive withVR',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "ConfigDrive",
- "Dns": "VpcVirtualRouter"
- }
- },
- "shared_nuage_network_config_drive_offering" : {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'shared',
- "supportedservices": 'Dhcp,Connectivity,UserData',
- "traffictype": 'GUEST',
- "specifyVlan": "False",
- "specifyIpRanges": "True",
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": 'ConfigDrive'
- },
- "serviceCapabilityList": {
- "Connectivity": {
- "PublicAccess": "true"
- }
- }
- },
- "network_all2" : {
- "name": "SharedNetwork2-All-nuage",
- "displaytext": "SharedNetwork2-All-nuage",
- "gateway": "10.200.200.1",
- "netmask": "255.255.255.0",
- "startip": "10.200.200.21",
- "endip": "10.200.200.100",
- "acltype": "Domain"
- }
- }
-
-
class TestNuageConfigDrive(nuageTestCase):
"""Test user data and password reset functionality
using configDrive with Nuage VSP SDN plugin
@@ -308,6 +161,7 @@ class TestNuageConfigDrive(nuageTestCase):
def run(self):
self.expected_user_data = "hello world vm %s" % self.vm.name
user_data = base64.b64encode(self.expected_user_data)
+ self.end = None
self.start = datetime.now()
self.vm.update(self.nuagetestcase.api_client, userdata=user_data)
self.end = datetime.now()
@@ -321,6 +175,8 @@ class TestNuageConfigDrive(nuageTestCase):
return self.vm
def get_timestamps(self):
+ if not self.end:
+ self.end = datetime.now()
return [self.start, self.end]
def get_userdata(self):
@@ -356,6 +212,8 @@ class TestNuageConfigDrive(nuageTestCase):
return self.vm
def get_timestamps(self):
+ if not self.end:
+ self.end = datetime.now()
return [self.start, self.end]
def get_password(self):
@@ -368,7 +226,6 @@ class TestNuageConfigDrive(nuageTestCase):
@classmethod
def setUpClass(cls):
super(TestNuageConfigDrive, cls).setUpClass()
- cls.test_data["nuagevsp"].update(Services().services)
return
def setUp(self):
@@ -480,7 +337,7 @@ class TestNuageConfigDrive(nuageTestCase):
'Userdata found: %s is not equal to expected: %s'
% (vmuserdata, userdata))
- def verifyPassword(self, vm, ssh, iso_path, password):
+ def verifyPassword(self, ssh, iso_path, password):
self.debug("Expected VM password is %s " % password.password)
password_file = iso_path+"/cloudstack/password/vm_password.txt"
cmd = "cat %s" % password_file
@@ -520,11 +377,7 @@ class TestNuageConfigDrive(nuageTestCase):
res = ssh.execute(cmd)
metadata[file] = res
- metadata_files = ["availability-zone.txt",
- "instance-id.txt",
- "service-offering.txt",
- "vm-id.txt"]
- for mfile in metadata_files:
+ for mfile in vm_files:
if mfile not in metadata:
self.fail("{} file is not found in vm metadata".format(mfile))
self.assertEqual(
@@ -546,7 +399,7 @@ class TestNuageConfigDrive(nuageTestCase):
)
return
- def verifyOpenStackData(self, vm, ssh, iso_path):
+ def verifyOpenStackData(self, ssh, iso_path):
openstackdata_dir = iso_path+"/openstack/latest/"
openstackdata = {}
@@ -658,6 +511,10 @@ class TestNuageConfigDrive(nuageTestCase):
metadata=False,
sshkey=None,
ssh_client=None):
+ if self.isSimulator:
+ self.debug("Simulator Environment: Skipping Config Drive content verification")
+ return
+
self.debug("SSHing into the VM %s" % vm.name)
if ssh_client is None:
ssh = self.ssh_into_VM(vm, public_ip)
@@ -672,7 +529,7 @@ class TestNuageConfigDrive(nuageTestCase):
self.debug("Verifying metadata for vm: %s" % vm.name)
self.verifyMetaData(vm, ssh, config_drive_path)
self.debug("Verifying openstackdata for vm: %s" % vm.name)
- self.verifyOpenStackData(vm, ssh, config_drive_path)
+ self.verifyOpenStackData(ssh, config_drive_path)
if userdata is not None:
self.debug("Verifying userdata for vm: %s" % vm.name)
@@ -680,7 +537,7 @@ class TestNuageConfigDrive(nuageTestCase):
self.verifyOpenStackUserData(ssh, config_drive_path, userdata)
if password_test.test_presence:
self.debug("Verifying password for vm: %s" % vm.name)
- test_result = self.verifyPassword(vm, ssh, config_drive_path,
+ test_result = self.verifyPassword(ssh, config_drive_path,
password_test)
self.assertEqual(test_result[0], password_test.presence,
"Expected is that password is present: %s "
@@ -769,7 +626,7 @@ class TestNuageConfigDrive(nuageTestCase):
cmd.keypair = keypair
cmd.account = account
cmd.domainid = domainid
- return(self.api_client.resetSSHKeyForVirtualMachine(cmd))
+ return self.api_client.resetSSHKeyForVirtualMachine(cmd)
def update_sshkeypair(self, vm):
vm.stop(self.api_client)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py b/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py
index cabba0c..e167dde 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py
@@ -98,12 +98,9 @@ class TestNuageExtraDhcp(nuageTestCase):
cls.expected_dhcp_options_on_vm = {}
cls.dhcp_options_map_keys = [1, 16, 28, 41, 64, 93]
- cls._cleanup = [
- cls.shared_network_all,
- cls.shared_network_offering,
- cls.account
- ]
- return
+ cls._cleanup.append(cls.account)
+ cls._cleanup.append(cls.shared_network_offering)
+ cls._cleanup.append(cls.shared_network_all)
def setUp(self):
self.vmdata["displayname"] = "vm"
@@ -273,16 +270,6 @@ class TestNuageExtraDhcp(nuageTestCase):
# Cleanup resources used
self.debug("Cleaning up the resources")
self.update_NuageVspGlobalDomainTemplateName(name="")
- for obj in reversed(self.cleanup):
- try:
- if isinstance(obj, VirtualMachine):
- obj.delete(self.api_client, expunge=True)
- else:
- obj.delete(self.api_client)
- except Exception as e:
- self.error("Failed to cleanup %s, got %s" % (obj, e))
- # cleanup_resources(self.api_client, self.cleanup)
- self.cleanup = []
self.debug("Cleanup complete!")
return
@@ -435,6 +422,10 @@ class TestNuageExtraDhcp(nuageTestCase):
def verify_dhcp_on_vm(
self, dhcpleasefile, dhcp_option_map, ssh_client, cleanlease=True):
+ if self.isSimulator:
+ self.debug("Simulator Environment: Skipping VM DHCP option verification")
+ return
+
cmd = 'cat /var/lib/dhclient/'+dhcpleasefile
self.debug("get content of dhcp lease file " + cmd)
outputlist = ssh_client.execute(cmd)
@@ -1071,9 +1062,6 @@ class TestNuageExtraDhcp(nuageTestCase):
self.delete_VM(vm4)
self.delete_VM(vm3)
- self.delete_Network(network)
- if vpc:
- vpc.delete(self.api_client)
def validate_all_extra_dhcp_for_vm_actions_in_network(
self, network,
diff --git a/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py b/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py
index 0c2a6b6..09bcdc9 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py
@@ -25,6 +25,12 @@ from marvin.lib.base import Account, Network
from nose.plugins.attrib import attr
import time
+UPDATED_DOMAIN_NAME = "update.com"
+
+ISOLATED_DOMAIN_NAME = "isolated.com"
+
+VPC_DOMAIN_NAME = "vpc.com"
+
class TestNuageInternalDns(nuageTestCase):
DNS = "06"
@@ -98,6 +104,33 @@ class TestNuageInternalDns(nuageTestCase):
self.debug("Successfully verified the creation and value of DHCP "
"option type - %s in VSD" % dhcp_type)
+ def vm_verify_ping(self, src_vm, public_ip, dst_vm, domain_name):
+ if self.isSimulator:
+ self.debug("Simulator Environment: not verifying ping.")
+ return
+
+ src_vm.ssh_ip = public_ip
+ src_vm.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
+ src_vm.username = self.test_data["virtual_machine"]["username"]
+ src_vm.password = self.test_data["virtual_machine"]["password"]
+ self.debug("SSHing into VM: %s with %s" %
+ (src_vm.ssh_ip, src_vm.password))
+
+ ssh = self.ssh_into_VM(src_vm, public_ip)
+
+ cmd = 'ping -c 2 ' + dst_vm.name
+ self.debug("ping vm2 by hostname with command: " + cmd)
+ outputlist = ssh.execute(cmd)
+ self.debug("command is executed properly " + cmd)
+ completeoutput = str(outputlist).strip('[]')
+ self.debug("complete output is " + completeoutput)
+ expectedlist = ['2 received', dst_vm.name + '.' + domain_name, dst_vm.ipaddress]
+ for item in expectedlist:
+ if item in completeoutput:
+ self.debug("excepted value found in vm: " + item)
+ else:
+ self.fail("excepted value not found in vm: " + item)
+
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
def test_01_Isolated_Network_with_zone(self):
""" Verify InternalDns on Isolated Network
@@ -113,7 +146,7 @@ class TestNuageInternalDns(nuageTestCase):
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "isolated.com"
+ cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
@@ -130,11 +163,11 @@ class TestNuageInternalDns(nuageTestCase):
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -153,7 +186,7 @@ class TestNuageInternalDns(nuageTestCase):
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "isolated.com"
+ cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -171,11 +204,11 @@ class TestNuageInternalDns(nuageTestCase):
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -187,39 +220,13 @@ class TestNuageInternalDns(nuageTestCase):
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
- vm_public_ip = public_ip_1.ipaddress.ipaddress
-
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
def test_03_Isolated_Network_restarts(self):
@@ -239,7 +246,7 @@ class TestNuageInternalDns(nuageTestCase):
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "isolated.com"
+ cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -257,11 +264,11 @@ class TestNuageInternalDns(nuageTestCase):
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -273,40 +280,13 @@ class TestNuageInternalDns(nuageTestCase):
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
- vm_public_ip = public_ip_1.ipaddress.ipaddress
-
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- time.sleep(30)
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
# Restarting Isolated network (cleanup = false)
self.debug("Restarting the created Isolated network without "
@@ -324,31 +304,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
# Restarting Isolated network (cleanup = true)
self.debug("Restarting the created Isolated network with cleanup...")
@@ -365,31 +321,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
def test_04_Update_Network_with_Domain(self):
@@ -407,7 +339,7 @@ class TestNuageInternalDns(nuageTestCase):
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "isolated.com"
+ cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -429,23 +361,23 @@ class TestNuageInternalDns(nuageTestCase):
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(
network_1, self.apiclient, id=network_1.id,
- networkdomain="update.com", changecidr=False)
+ networkdomain=UPDATED_DOMAIN_NAME, changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
- self.assertEqual("update.com", update_response.networkdomain,
+ self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
"Network Domain is not updated as expected"
)
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "update.com", nic, True)
+ self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -465,7 +397,7 @@ class TestNuageInternalDns(nuageTestCase):
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "isolated.com"
+ cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -484,27 +416,27 @@ class TestNuageInternalDns(nuageTestCase):
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", network_1)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "isolated.com", nic, True)
+ self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(
network_1, self.apiclient, id=network_1.id,
- networkdomain="update.com", changecidr=False)
+ networkdomain=UPDATED_DOMAIN_NAME, changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
- self.assertEqual("update.com", update_response.networkdomain,
+ self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
"Network Domain is not updated as expected"
)
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "update.com", nic, True)
+ self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
# stop and start VM to get new DHCP option
@@ -522,7 +454,7 @@ class TestNuageInternalDns(nuageTestCase):
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
- self.DOMAINNAME, "update.com", nic, True)
+ self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
try:
@@ -533,33 +465,7 @@ class TestNuageInternalDns(nuageTestCase):
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
- vm_public_ip = public_ip_1.ipaddress.ipaddress
-
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception: %s " % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.update.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, UPDATED_DOMAIN_NAME)
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
def test_06_VPC_Network_With_InternalDns(self):
@@ -571,10 +477,9 @@ class TestNuageInternalDns(nuageTestCase):
# 2. Deploy vm1 in tier network.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
-
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "vpc.com"
+ cmd.domain = VPC_DOMAIN_NAME
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
@@ -596,10 +501,10 @@ class TestNuageInternalDns(nuageTestCase):
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -617,7 +522,7 @@ class TestNuageInternalDns(nuageTestCase):
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "vpc.com"
+ cmd.domain = VPC_DOMAIN_NAME
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
@@ -641,7 +546,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -652,7 +557,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
@@ -665,33 +570,7 @@ class TestNuageInternalDns(nuageTestCase):
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
- vm_public_ip = public_ip_1.ipaddress.ipaddress
-
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
def test_08_VPC_Network_Restarts_With_InternalDns(self):
@@ -710,7 +589,7 @@ class TestNuageInternalDns(nuageTestCase):
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
- cmd.domain = "vpc.com"
+ cmd.domain = VPC_DOMAIN_NAME
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
@@ -731,10 +610,10 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -745,7 +624,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
- self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+ self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
@@ -758,33 +637,8 @@ class TestNuageInternalDns(nuageTestCase):
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
- vm_public_ip = public_ip_1.ipaddress.ipaddress
-
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC network (cleanup = false)
self.debug("Restarting the created VPC network without cleanup...")
@@ -801,31 +655,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC network (cleanup = true)
self.debug("Restarting the created VPC network with cleanup...")
@@ -842,31 +672,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC (cleanup = false)
self.debug("Restarting the VPC without cleanup...")
@@ -882,31 +688,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC (cleanup = true)
self.debug("Restarting the VPC with cleanup...")
@@ -922,31 +704,7 @@ class TestNuageInternalDns(nuageTestCase):
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = self.test_data["virtual_machine"]["username"]
- vm_1.password = self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- cmd = 'ping -c 2 vm2'
- self.debug("ping vm2 by hostname with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
- for item in expectedlist:
- if item in completeoutput:
- self.debug("excepted value found in vm: " + item)
- else:
- self.fail("excepted value not found in vm: " + item)
+ self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
def test_09_update_network_offering_isolated_network(self):
diff --git a/test/integration/plugins/nuagevsp/test_nuage_network_migration.py b/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
index 5d64e4f..c79e758 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
@@ -31,29 +31,6 @@ import unittest
import re
-class Services:
- """Test network services
- """
- def __init__(self):
- self.services = {
- "shared_network_offering": {
- "name": "MySharedOffering-shared",
- "displaytext": "MySharedOffering",
- "guestiptype": "Shared",
- "supportedservices": "Dhcp,Dns,UserData",
- "specifyVlan": "True",
- "specifyIpRanges": "True",
- "traffictype": "GUEST",
- "tags": "native",
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "Dns": "VirtualRouter",
- "UserData": "VirtualRouter"
- }
- }
- }
-
-
class TestNuageMigration(nuageTestCase):
"""Test Native to Nuage Migration
"""
@@ -61,7 +38,6 @@ class TestNuageMigration(nuageTestCase):
@classmethod
def setUpClass(cls):
super(TestNuageMigration, cls).setUpClass()
- cls.services = Services().services
if not hasattr(cls.vsp_physical_network, "tags") \
or cls.vsp_physical_network.tags != 'nuage':
diff --git a/test/integration/plugins/nuagevsp/test_nuage_password_reset.py b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
index 7973a3e..28714a7 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
@@ -138,6 +138,10 @@ class TestNuagePasswordReset(nuageTestCase):
# cloud-set-guest-password script from people.apache.org in the given VM
# (SSH client)
def install_cloud_set_guest_password_script(self, ssh_client):
+ if self.isSimulator:
+ self.debug( "Simulator Environment: Skipping installing"
+ " cloud-set-guest-password script")
+ return
self.debug("Installing cloud-set-guest-password script")
cmd = "cd /etc/init.d;wget http://people.apache.org/~tsp/" \
"cloud-set-guest-password"
@@ -254,6 +258,10 @@ class TestNuagePasswordReset(nuageTestCase):
self.create_and_verify_fw(self.vm_1, public_ip_1, self.network)
ssh = self.ssh_into_VM(self.vm_1, public_ip_1)
user_data_cmd = self.get_userdata_url(self.vm_1)
+ if self.isSimulator:
+ self.debug("Simulator Environment: ending test early "
+ "because we don't have real vms")
+ return
self.debug("Getting user data with command: " + user_data_cmd)
actual_user_data = base64.b64decode(self.execute_cmd
(ssh, user_data_cmd))
@@ -261,7 +269,7 @@ class TestNuagePasswordReset(nuageTestCase):
", Expected user data - " + expected_user_data)
self.assertEqual(actual_user_data, expected_user_data,
"Un-expected VM (VM_1) user data"
- )
+ )
self.debug("Checking for cloud-set-guest-password script in the "
"VM for testing password reset functionality...")
@@ -269,6 +277,7 @@ class TestNuagePasswordReset(nuageTestCase):
ls_result = self.execute_cmd(ssh, ls_cmd)
ls_result = ls_result.lower()
self.debug("Response from ls_cmd: " + ls_result)
+
if "no such file" in ls_result:
self.debug("No cloud-set-guest-password script in the VM")
self.debug("Installing the cloud-set-guest-password script "
diff --git a/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py b/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py
index 554741b..afd9941 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py
@@ -409,7 +409,7 @@ class TestNuageSharedNetworkUserdata(nuageTestCase):
except Exception as e:
self.debug("Deploy vm fails as expected with exception %s" % e)
self.debug("Going to verify the exception message")
- exceptionmsg = "it is reserved for the VR in network"
+ exceptionmsg = "Unable to start a VM due to insufficient capacity"
if exceptionmsg in str(e):
self.debug("correct exception is raised")
else:
@@ -819,8 +819,7 @@ class TestNuageSharedNetworkUserdata(nuageTestCase):
"""
self.updateTemplate(True)
self.debug("Deploy VM to shared Network scope as all")
- self.test_data["virtual_machine"]["ipaddress"] = \
- self.nuagenetworkdata["network_all"]["endip"]
+ self.test_data["virtual_machine"]["ipaddress"] = None
vm_1 = self.create_VM(
self.shared_network_all, account=self.account_d11a)
@@ -847,8 +846,7 @@ class TestNuageSharedNetworkUserdata(nuageTestCase):
"""
self.updateTemplate(True)
self.debug("Deploy VM to shared Network scope as all")
- self.test_data["virtual_machine"]["ipaddress"] = \
- self.nuagenetworkdata["network_all"]["endip"]
+ self.test_data["virtual_machine"]["ipaddress"] = None
vm_1 = self.create_VM(
self.shared_network_domain_with_subdomain_d11,
account=self.account_d11a)
@@ -876,8 +874,7 @@ class TestNuageSharedNetworkUserdata(nuageTestCase):
"""
self.updateTemplate(True)
self.debug("Deploy VM to shared Network scope as all")
- self.test_data["virtual_machine"]["ipaddress"] = \
- self.nuagenetworkdata["network_all"]["endip"]
+ self.test_data["virtual_machine"]["ipaddress"] = None
vm_1 = self.create_VM(
self.shared_network_account_d111a, account=self.account_d11a)
@@ -901,8 +898,6 @@ class TestNuageSharedNetworkUserdata(nuageTestCase):
"""
try:
- self.test_data["virtual_machine"]["ipaddress"] = \
- self.nuagenetworkdata["network_all"]["endip"]
vm_1 = self.create_VM(
self.shared_network_domain_with_subdomain_d11,
account=self.account_d11a)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_source_nat.py b/test/integration/plugins/nuagevsp/test_nuage_source_nat.py
index 2d9e3b9..6b53d2d 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_source_nat.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_source_nat.py
@@ -140,12 +140,15 @@ class TestNuageSourceNat(nuageTestCase):
self.verify_vsd_firewall_rule(public_ssh_rule)
# Checking for wget file
- ssh_client = self.ssh_into_VM(vm, public_ip)
- cmd = "ls /"
- file_list = self.execute_cmd(ssh_client, cmd)
- if "index.html" in str(file_list):
- cmd = "rm -rf /index.html*"
- self.execute_cmd(ssh_client, cmd)
+ is_in_file_list = None
+ if not self.isSimulator:
+ ssh_client = self.ssh_into_VM(vm, public_ip)
+ cmd = "ls /"
+ file_list = self.execute_cmd(ssh_client, cmd)
+ is_in_file_list = "index.html" in str(file_list)
+ if is_in_file_list:
+ cmd = "rm -rf /index.html*"
+ self.execute_cmd(ssh_client, cmd)
# Removing Ingress Firewall/Network ACL rule
self.debug("Removing the created Ingress Firewall/Network ACL "
@@ -194,11 +197,11 @@ class TestNuageSourceNat(nuageTestCase):
"VSD")
# Final test result
- if "index.html" in str(file_list):
+ if is_in_file_list:
self.debug("Successfully verified Source NAT traffic "
"(wget www.google.com) to the Internet from VM - %s"
% vm.name)
- else:
+ elif not self.isSimulator:
self.fail("Failed to verify Source NAT traffic "
"(wget www.google.com) to the Internet from VM - %s"
% vm.name)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_static_nat.py b/test/integration/plugins/nuagevsp/test_nuage_static_nat.py
index 3aa36d1..e611b97 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_static_nat.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_static_nat.py
@@ -112,6 +112,10 @@ class TestNuageStaticNat(nuageTestCase):
# server running on the corresponding VM in the given network
def verify_StaticNAT_traffic(self, network, public_ip, vpc=None,
non_default_nic=False):
+ if self.isSimulator:
+ self.debug("Simulator Environment: skipping static nat"
+ "traffic tests.")
+ return
# Adding Ingress Firewall/Network ACL rule
self.debug("Adding Ingress Firewall/Network ACL rule to make the "
"created Static NAT rule (wget) accessible...")
@@ -186,6 +190,11 @@ class TestNuageStaticNat(nuageTestCase):
def verify_StaticNAT_Internet_traffic(self, vm, network, public_ip,
vpc=None, non_default_nic=False,
negative_test=False):
+ if self.isSimulator and not negative_test:
+ self.debug("Simulator Environment: not verifying internet traffic")
+ return
+ elif self.isSimulator:
+ raise Exception("Simulator simulating exception")
# Adding Ingress Firewall/Network ACL rule
self.debug("Adding Ingress Firewall/Network ACL rule to make the "
"created Static NAT rule (SSH) accessible...")
@@ -1677,15 +1686,17 @@ class TestNuageStaticNat(nuageTestCase):
self.verify_vsd_floating_ip(network_2, vm, public_ip_2.ipaddress)
# Verifying Static NAT traffic
- with self.assertRaises(AssertionError):
- self.verify_StaticNAT_traffic(network_1, public_ip_1)
+ if not self.isSimulator:
+ with self.assertRaises(AssertionError):
+ self.verify_StaticNAT_traffic(network_1, public_ip_1)
self.debug("Static NAT rule not enabled in this VM NIC")
self.verify_StaticNAT_traffic(network_2, public_ip_2)
# Verifying Static NAT traffic (wget www.google.com) to the Internet
# from the deployed VM
- with self.assertRaises(Exception):
- self.verify_StaticNAT_Internet_traffic(vm, network_1, public_ip_1)
+ if not self.isSimulator:
+ with self.assertRaises(Exception):
+ self.verify_StaticNAT_Internet_traffic(vm, network_1, public_ip_1)
self.debug("Static NAT rule not enabled in this VM NIC")
self.verify_StaticNAT_Internet_traffic(vm, network_2, public_ip_2)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py b/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
index 3e7080b..f80dcb5 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
@@ -171,6 +171,10 @@ class TestNuageInternalLb(nuageTestCase):
# verify_vpc_vm_ingress_traffic - Verifies ingress traffic to the given VM
# (SSH into VM) via a created Static NAT rule in the given VPC network
def verify_vpc_vm_ingress_traffic(self, vm, network, vpc):
+ if self.isSimulator:
+ self.debug("Simulator Environment: "
+ "skipping vpc vm ingress traffic tests.")
+ return
self.debug("Verifying ingress traffic to the VM (SSH into VM) - %s "
"via a created Static NAT rule in the VPC network - %s" %
(vm, network))
@@ -236,6 +240,9 @@ class TestNuageInternalLb(nuageTestCase):
# wget_from_vm_cmd - From within the given VM (ssh client),
# fetches index.html file of web server running with the given public IP
def wget_from_vm_cmd(self, ssh_client, ip_address, port):
+ if self.isSimulator:
+ self.debug("Simulator Environment: not wgeting from vm cmd.")
+ return
wget_file = ""
cmd = "rm -rf index.html*"
self.execute_cmd(ssh_client, cmd)
@@ -260,6 +267,9 @@ class TestNuageInternalLb(nuageTestCase):
# belongs to the given Internal LB rule
# assigned VMs (vm array)
def verify_lb_wget_file(self, wget_file, vm_array):
+ if self.isSimulator:
+ self.debug("Simulator Environment: not verifying file on vm.")
+ return
wget_server_ip = None
for vm in vm_array:
for nic in vm.nic:
@@ -1406,6 +1416,10 @@ class TestNuageInternalLb(nuageTestCase):
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
+ if self.isSimulator:
+ self.debug("Simulator Environment: skipping traffic tests.")
+ return
+
# Internal LB (wget) traffic tests
ssh_client = self.ssh_into_VM(public_vm, public_ip)
wget_file_1 = self.wget_from_vm_cmd(
@@ -1663,6 +1677,10 @@ class TestNuageInternalLb(nuageTestCase):
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
+ if self.isSimulator:
+ self.debug("Simulator Environment: skipping traffic tests.")
+ return
+
# Internal LB (wget) traffic tests with Round Robin Algorithm
ssh_client = self.ssh_into_VM(public_vm, public_ip)
self.validate_internallb_algorithm_traffic(
@@ -1863,14 +1881,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vsd_firewall_rule(public_ssh_rule)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Restart Internal tier (cleanup = false)
# InternalLbVm gets destroyed and deployed again in the Internal tier
@@ -1909,23 +1921,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- tries = 0
- while tries < 120:
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
- if wget_file != "":
- break
- self.debug("Waiting for the InternalLbVm in the Internal tier to "
- "be fully resolved for (wget) traffic test...")
- time.sleep(5)
- tries += 1
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
-
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Restart Internal tier (cleanup = true)
# InternalLbVm gets destroyed and deployed again in the Internal tier
self.debug("Restarting the Internal tier with cleanup...")
@@ -1963,22 +1960,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- tries = 0
- while tries < 120:
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
- if wget_file != "":
- break
- self.debug("Waiting for the InternalLbVm in the Internal tier to "
- "be fully resolved for (wget) traffic test...")
- time.sleep(5)
- tries += 1
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Restart Public tier (cleanup = false)
# This restart has no effect on the InternalLbVm functionality
@@ -2057,14 +2040,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Stopping VMs in the Internal tier
# wget traffic test fails as all the VMs in the Internal tier are in
@@ -2095,17 +2072,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vsd_lb_device(int_lb_vm)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- with self.assertRaises(Exception):
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
- self.debug("Failed to wget file as all the VMs in the Internal tier "
- "are in stopped state")
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm, should_fail=True)
# Starting VMs in the Internal tier
# wget traffic test succeeds as all the VMs in the Internal tier are
@@ -2144,22 +2112,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- tries = 0
- while tries < 120:
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
- if wget_file != "":
- break
- self.debug("Waiting for the InternalLbVm in the Internal tier to "
- "be fully resolved for (wget) traffic test...")
- time.sleep(5)
- tries += 1
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Restarting VPC (cleanup = false)
# VPC VR gets destroyed and deployed again in the VPC
@@ -2206,14 +2160,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Restarting VPC (cleanup = true)
# VPC VR gets destroyed and deployed again in the VPC
@@ -2269,6 +2217,35 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_lb_wget_file(
wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ def verify_internal_lb_wget_traffic(self, int_lb_rule_1, internal_vm, internal_vm_1, internal_vm_2, public_ip, public_vm, should_fail=False):
+ if self.isSimulator:
+ self.debug("Simulator Environment: not running wget traffic tests.")
+ return
+ ssh_client = self.ssh_into_VM(public_vm, public_ip)
+ tries = 0
+ wget_file = None
+ while tries < 120:
+ wget_file = self.wget_from_vm_cmd(
+ ssh_client, int_lb_rule_1.sourceipaddress,
+ self.test_data["http_rule"]["publicport"])
+ if wget_file != "":
+ break
+ self.debug("Waiting for the InternalLbVm in the Internal tier to "
+ "be fully resolved for (wget) traffic test...")
+ time.sleep(5)
+ tries += 1
+
+ # Verifying Internal LB (wget) traffic test
+ if should_fail:
+ with self.assertRaises(Exception):
+ self.verify_lb_wget_file(
+ wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.debug("Failed to wget file as all the VMs in the Internal tier "
+ "are in stopped state")
+ else:
+ self.verify_lb_wget_file(
+ wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+
@skip
# Skip until CLOUDSTACK-9837 is fixed
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -2452,14 +2429,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vsd_firewall_rule(public_ssh_rule)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# # Stopping the InternalLbVm when the VPC VR is in Stopped state
self.stop_InternalLbVm(int_lb_vm)
@@ -2478,17 +2449,9 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- with self.assertRaises(Exception):
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
- self.debug("Failed to wget file as the InternalLbVm is in stopped"
- " state")
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm,
+ should_fail=True)
# # Starting the InternalLbVm when the VPC VR is in Stopped state
self.start_InternalLbVm(int_lb_vm)
@@ -2507,23 +2470,9 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- tries = 0
- while tries < 120:
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
- if wget_file != "":
- break
- self.debug("Waiting for the InternalLbVm in the Internal tier to "
- "be fully resolved for (wget) traffic test...")
- time.sleep(5)
- tries += 1
-
- # Verifying Internal LB (wget) traffic test
# Bug CLOUDSTACK-9837
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# Starting the VPC VR
# VPC VR has no effect on the InternalLbVm functionality
@@ -2554,17 +2503,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- with self.assertRaises(Exception):
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
- self.debug("Failed to wget file as the InternalLbVm is in stopped"
- " state")
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm, should_fail=True)
# # Starting the InternalLbVm when the VPC VR is in Running state
self.start_InternalLbVm(int_lb_vm)
@@ -2583,22 +2523,8 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- tries = 0
- while tries < 120:
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
- if wget_file != "":
- break
- self.debug("Waiting for the InternalLbVm in the Internal tier to "
- "be fully resolved for (wget) traffic test...")
- time.sleep(5)
- tries += 1
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
# # Force Stopping the InternalLbVm when the VPC VR is in Running state
self.stop_InternalLbVm(int_lb_vm, force=True)
@@ -2617,17 +2543,9 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
-
- # Verifying Internal LB (wget) traffic test
- with self.assertRaises(Exception):
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
- self.debug("Failed to wget file as the InternalLbVm is in stopped"
- " state")
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm,
+ should_fail=True)
# # Starting the InternalLbVm when the VPC VR is in Running state
self.start_InternalLbVm(int_lb_vm)
@@ -2646,19 +2564,5 @@ class TestNuageInternalLb(nuageTestCase):
self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
# Internal LB (wget) traffic test
- ssh_client = self.ssh_into_VM(public_vm, public_ip)
- tries = 0
- while tries < 120:
- wget_file = self.wget_from_vm_cmd(
- ssh_client, int_lb_rule_1.sourceipaddress,
- self.test_data["http_rule"]["publicport"])
- if wget_file != "":
- break
- self.debug("Waiting for the InternalLbVm in the Internal tier to "
- "be fully resolved for (wget) traffic test...")
- time.sleep(5)
- tries += 1
-
- # Verifying Internal LB (wget) traffic test
- self.verify_lb_wget_file(
- wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+ self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+ internal_vm_2, public_ip, public_vm)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py b/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py
index 040f379..165632d 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py
@@ -453,6 +453,8 @@ class TestNuageDomainTemplate(nuageTestCase):
"(tier) network gets created on CloudStack as the "
"associated pre-configured Nuage VSP domain template is no "
"longer existing in VSD")
+ for vpc_2_tier in Network.list(self.api_client, vpcid=vpc_2.id):
+ Network(vpc_2_tier.__dict__).delete(self.api_client)
# Re-creating the associated pre-configured Nuage VSP domain template
new_domain_template = self.vsdk.NUDomainTemplate(
@@ -504,6 +506,8 @@ class TestNuageDomainTemplate(nuageTestCase):
"Network ACLs from CloudStack is not supported when the "
"VPC is associated with a Nuage VSP pre-configured domain "
"template")
+ for vpc_3_tier in Network.list(self.api_client, vpcid=vpc_3.id):
+ Network(vpc_3_tier.__dict__).delete(self.api_client)
vpc_3_tier_1 = self.create_Network(
self.network_offering, gateway='10.1.2.1', vpc=vpc_3)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py b/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py
index de4a9f5..c60f930 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py
@@ -98,43 +98,36 @@ class TestNuageManagedSubnets(nuageTestCase):
self.cleanup = [self.account]
return
- def verify_pingtovmipaddress(self, ssh, pingtovmipaddress):
- """verify ping to ipaddress of the vm and retry 3 times"""
-
+ def verify_ping_to_vm(self, src_vm, dst_vm, public_ip, dst_hostname=None):
if self.isSimulator:
+ self.debug("Simulator Environment: not verifying pinging")
return
+ try:
+ src_vm.ssh_ip = public_ip.ipaddress.ipaddress
+ src_vm.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
+ src_vm.username = self.test_data["virtual_machine"]["username"]
+ src_vm.password = self.test_data["virtual_machine"]["password"]
+ self.debug("SSHing into VM: %s with %s" %
+ (src_vm.ssh_ip, src_vm.password))
- successfull_ping = False
- nbr_retries = 0
- max_retries = 5
- cmd = 'ping -c 2 ' + pingtovmipaddress
+ ssh = self.ssh_into_VM(src_vm, public_ip)
- while not successfull_ping and nbr_retries < max_retries:
- self.debug("ping vm by ipaddress with command: " + cmd)
- outputlist = ssh.execute(cmd)
- self.debug("command is executed properly " + cmd)
- completeoutput = str(outputlist).strip('[]')
- self.debug("complete output is " + completeoutput)
- if '2 received' in completeoutput:
- self.debug("PASS as vm is pingeable: " + completeoutput)
- successfull_ping = True
- else:
- self.debug("FAIL as vm is not pingeable: " + completeoutput)
- time.sleep(3)
- nbr_retries = nbr_retries + 1
+ except Exception as e:
+ self.fail("SSH into VM failed with exception %s" % e)
- if not successfull_ping:
- self.fail("FAILED TEST as excepted value not found in vm")
+ self.verify_pingtovmipaddress(ssh, dst_vm.ipaddress)
+ if dst_hostname:
+ self.verify_pingtovmipaddress(ssh, dst_hostname)
- def verify_pingtovmhostname(self, ssh, pingtovmhostname):
- """verify ping to hostname of the vm and retry 3 times"""
+ def verify_pingtovmipaddress(self, ssh, pingtovmipaddress):
+ """verify ping to ipaddress of the vm and retry 3 times"""
successfull_ping = False
nbr_retries = 0
max_retries = 5
- cmd = 'ping -c 2 ' + pingtovmhostname
+ cmd = 'ping -c 2 ' + pingtovmipaddress
while not successfull_ping and nbr_retries < max_retries:
- self.debug("ping vm by hostname with command: " + cmd)
+ self.debug("ping vm by ipaddress with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
@@ -207,7 +200,6 @@ class TestNuageManagedSubnets(nuageTestCase):
zone1 = self.create_vsd_zone(domain1, "ZoneToBeConsumedByACS")
subnet1 = self.create_vsd_subnet(zone1, "SubnetToBeConsumedByACS",
"10.0.0.1/24")
- self.create_vsd_dhcp_option(subnet1, 15, ["nuagenetworks1.net"])
domain2 = self.create_vsd_domain(domain_template, enterprise,
"2ndL3DomainToBeConsumedByACS")
@@ -227,13 +219,13 @@ class TestNuageManagedSubnets(nuageTestCase):
isolated_network = self.create_Network(
self.nuage_isolated_network_offering,
gateway="10.0.0.1", netmask="255.255.255.0",
- externalid=subnet1.id)
+ externalid=subnet1.id, cleanup=False)
# On ACS create network using persistent nw offering allow
isolated_network2 = self.create_Network(
self.nuage_isolated_network_offering_persistent,
gateway="10.5.0.1", netmask="255.255.255.0",
- externalid=subnet2.id)
+ externalid=subnet2.id, cleanup=False)
with self.assertRaises(Exception):
self.create_Network(
@@ -255,11 +247,11 @@ class TestNuageManagedSubnets(nuageTestCase):
externalid=subnet2.id+1)
# verify floating ip and intra subnet connectivity
- vm_1 = self.create_VM(isolated_network)
+ vm_1 = self.create_VM(isolated_network, cleanup=False)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
- vm_2 = self.create_VM(isolated_network)
+ vm_2 = self.create_VM(isolated_network, cleanup=False)
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
@@ -276,31 +268,12 @@ class TestNuageManagedSubnets(nuageTestCase):
public_ip, isolated_network, static_nat=True, vm=vm_1)
self.create_FirewallRule(public_ip,
self.test_data["ingress_rule"])
- if not self.isSimulator:
- vm_public_ip = public_ip.ipaddress.ipaddress
- try:
- vm_1.ssh_ip = vm_public_ip
- vm_1.ssh_port = \
- self.test_data["virtual_machine"]["ssh_port"]
- vm_1.username = \
- self.test_data["virtual_machine"]["username"]
- vm_1.password = \
- self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_1.ssh_ip, vm_1.password))
-
- ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- self.verify_pingtovmipaddress(ssh, vm_2.ipaddress)
- self.verify_pingtovmhostname(ssh, "vm2")
-
- vm_3 = self.create_VM(isolated_network2)
+ self.verify_ping_to_vm(vm_1, vm_2, public_ip, "vm2")
+
+ vm_3 = self.create_VM(isolated_network2, cleanup=False)
self.test_data["virtual_machine"]["displayname"] = "vm4"
self.test_data["virtual_machine"]["name"] = "vm4"
- vm_4 = self.create_VM(isolated_network2)
+ vm_4 = self.create_VM(isolated_network2, cleanup=False)
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
self.verify_vsd_network_not_present(isolated_network2)
@@ -313,37 +286,17 @@ class TestNuageManagedSubnets(nuageTestCase):
self.create_StaticNatRule_For_VM(vm_3, public_ip2,
isolated_network2)
self.validate_PublicIPAddress(
- public_ip2, isolated_network2, static_nat=True, vm=vm_3)
+ public_ip2, isolated_network2, static_nat=True, vm=vm_3)
self.create_FirewallRule(public_ip2,
self.test_data["ingress_rule"])
- if not self.isSimulator:
- vm_public_ip2 = public_ip2.ipaddress.ipaddress
- try:
- vm_3.ssh_ip = vm_public_ip2
- vm_3.ssh_port = \
- self.test_data["virtual_machine"]["ssh_port"]
- vm_3.username = \
- self.test_data["virtual_machine"]["username"]
- vm_3.password = \
- self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vm_3.ssh_ip, vm_3.password))
-
- ssh2 = vm_3.get_ssh_client(ipaddress=vm_public_ip2)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- self.verify_pingtovmipaddress(ssh2, vm_4.ipaddress)
- self.verify_pingtovmhostname(ssh2, "vm4")
-
- vm_1.delete(self.api_client, expunge=True)
- vm_2.delete(self.api_client, expunge=True)
- isolated_network.delete(self.api_client)
- vm_3.delete(self.api_client, expunge=True)
+ self.verify_ping_to_vm(vm_3, vm_4, public_ip2)
vm_4.delete(self.api_client, expunge=True)
+ vm_3.delete(self.api_client, expunge=True)
+ vm_2.delete(self.api_client, expunge=True)
+ vm_1.delete(self.api_client, expunge=True)
isolated_network2.delete(self.api_client)
+ isolated_network.delete(self.api_client)
self.debug("Number of loops %s" % i)
@attr(tags=["advanced", "nuagevsp", "vpc"], required_hardware="false")
@@ -393,11 +346,11 @@ class TestNuageManagedSubnets(nuageTestCase):
vpc = self.create_Vpc(self.nuage_vpc_offering, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
acl_list = self.create_NetworkAclList(
- name="acl", description="acl", vpc=vpc)
+ name="acl", description="acl", vpc=vpc)
self.create_NetworkAclRule(
- self.test_data["ingress_rule"], acl_list=acl_list)
+ self.test_data["ingress_rule"], acl_list=acl_list)
self.create_NetworkAclRule(
- self.test_data["icmprule"], acl_list=acl_list)
+ self.test_data["icmprule"], acl_list=acl_list)
self.debug("Creating another VPC with Static NAT service provider "
"as VpcVirtualRouter")
@@ -442,7 +395,8 @@ class TestNuageManagedSubnets(nuageTestCase):
gateway='10.1.0.1',
vpc=vpc,
acl_list=acl_list,
- externalid=subnet1.id)
+ externalid=subnet1.id,
+ cleanup=False)
self.validate_Network(vpc_tier, state="Implemented")
self.debug("Creating 2nd VPC tier network with Static NAT service")
@@ -458,7 +412,8 @@ class TestNuageManagedSubnets(nuageTestCase):
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list,
- externalid=subnet2.id)
+ externalid=subnet2.id,
+ cleanup=False)
self.validate_Network(vpc_2ndtier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
@@ -514,17 +469,17 @@ class TestNuageManagedSubnets(nuageTestCase):
self.debug("Deploying a VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
- vpc_vm_1 = self.create_VM(vpc_tier)
+ vpc_vm_1 = self.create_VM(vpc_tier, cleanup=False)
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
- vpc_vm_2 = self.create_VM(vpc_tier)
+ vpc_vm_2 = self.create_VM(vpc_tier, cleanup=False)
self.check_VM_state(vpc_vm_2, state="Running")
self.debug("Deploying a VM in the 2nd VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm12"
self.test_data["virtual_machine"]["name"] = "vpcvm12"
- vpc_vm_12 = self.create_VM(vpc_2ndtier)
+ vpc_vm_12 = self.create_VM(vpc_2ndtier, cleanup=False)
self.check_VM_state(vpc_vm_2, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
@@ -542,26 +497,8 @@ class TestNuageManagedSubnets(nuageTestCase):
self.validate_PublicIPAddress(
public_ip_1, vpc_tier, static_nat=True, vm=vpc_vm_1)
- if not self.isSimulator:
- vm_public_ip_1 = public_ip_1.ipaddress.ipaddress
- try:
- vpc_vm_1.ssh_ip = vm_public_ip_1
- vpc_vm_1.ssh_port = \
- self.test_data["virtual_machine"]["ssh_port"]
- vpc_vm_1.username = \
- self.test_data["virtual_machine"]["username"]
- vpc_vm_1.password = \
- self.test_data["virtual_machine"]["password"]
- self.debug("SSHing into VM: %s with %s" %
- (vpc_vm_1.ssh_ip, vpc_vm_1.password))
-
- ssh = vpc_vm_1.get_ssh_client(ipaddress=vm_public_ip_1)
-
- except Exception as e:
- self.fail("SSH into VM failed with exception %s" % e)
-
- self.verify_pingtovmipaddress(ssh, vpc_vm_2.ipaddress)
- self.verify_pingtovmipaddress(ssh, vpc_vm_12.ipaddress)
+ self.verify_ping_to_vm(vpc_vm_1, vpc_vm_2, public_ip_1)
+ self.verify_ping_to_vm(vpc_vm_1, vpc_vm_12, public_ip_1)
vpc_vm_1.delete(self.api_client, expunge=True)
vpc_vm_2.delete(self.api_client, expunge=True)
@@ -704,8 +641,6 @@ class TestNuageManagedSubnets(nuageTestCase):
enterprise = self.vsdk.NUEnterprise()
enterprise.name = "EnterpriseToBeConsumedByACS"
enterprise.description = "EnterpriseToBeConsumedByACS"
- # enterprise.external_id = "ToBeConsumedByACS@" \
- # + str(self.cms_id)
(enterprise, connection) = self._session.user.create_child(enterprise)
return enterprise
@@ -738,8 +673,6 @@ class TestNuageManagedSubnets(nuageTestCase):
domain_template = self.vsdk.NUDomainTemplate()
domain_template.name = "L3DomainTemplateToBeConsumedByACS"
domain_template.description = "L3DomainTemplateToBeConsumedByACS"
- # domain_template.external_id = "L3DomainTemplateToBeConsumedByACS@" \
- # + str(self.cms_id)
(domain_template, connection) = \
enterprise.create_child(domain_template)
return domain_template
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index 097b890..11595e4 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -49,27 +49,6 @@ test_data = {
"forvirtualnetwork": "true",
"vlan": "300"
},
- "publiciprange1": {
- "gateway": "10.200.100.1",
- "netmask": "255.255.255.0",
- "startip": "10.200.100.101",
- "endip": "10.200.100.105",
- "forvirtualnetwork": "false"
- },
- "publiciprange2": {
- "gateway": "10.219.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.219.1.2",
- "endip": "10.219.1.5",
- "forvirtualnetwork": "false"
- },
- "publiciprange3": {
- "gateway": "10.200.100.1",
- "netmask": "255.255.255.0",
- "startip": "10.200.100.2",
- "endip": "10.200.100.20",
- "forvirtualnetwork": "false"
- },
"private_gateway": {
"ipaddress": "172.16.1.2",
"gateway": "172.16.1.1",
@@ -92,14 +71,14 @@ test_data = {
"password": "password"
},
"user": {
- "email": "user@test.com",
- "firstname": "User",
- "lastname": "User",
- "username": "User",
- # Random characters are appended for unique
- # username
- "password": "fr3sca",
- },
+ "email": "user@test.com",
+ "firstname": "User",
+ "lastname": "User",
+ "username": "User",
+ # Random characters are appended for unique
+ # username
+ "password": "fr3sca",
+ },
"small": {
"displayname": "testserver",
"username": "root",
@@ -153,7 +132,7 @@ test_data = {
"cpuspeed": 100,
"memory": 512,
},
- "large": {
+ "large": {
"name": "LargeInstance",
"displaytext": "LargeInstance",
"cpunumber": 1,
@@ -179,20 +158,20 @@ test_data = {
},
},
"service_offering_h1": {
- "name": "Tagged h1 Small Instance",
- "displaytext": "Tagged h1 Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- "hosttags": "h1"
+ "name": "Tagged h1 Small Instance",
+ "displaytext": "Tagged h1 Small Instance",
+ "cpunumber": 1,
+ "cpuspeed": 100,
+ "memory": 256,
+ "hosttags": "h1"
},
"service_offering_h2": {
- "name": "Tagged h2 Small Instance",
- "displaytext": "Tagged h2 Small Instance",
- "cpunumber": 1,
- "cpuspeed": 100,
- "memory": 256,
- "hosttags": "h2"
+ "name": "Tagged h2 Small Instance",
+ "displaytext": "Tagged h2 Small Instance",
+ "cpunumber": 1,
+ "cpuspeed": 100,
+ "memory": 256,
+ "hosttags": "h2"
},
"disk_offering": {
"name": "Disk offering",
@@ -256,23 +235,23 @@ test_data = {
},
},
"nw_off_isolated_netscaler": {
- "name": 'Netscaler',
- "displaytext": 'Netscaler',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- "Vpn": 'VirtualRouter',
- "Firewall": 'VirtualRouter',
- "Lb": 'Netscaler',
- "UserData": 'VirtualRouter',
- "StaticNat": 'VirtualRouter',
- },
+ "name": 'Netscaler',
+ "displaytext": 'Netscaler',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
+ "traffictype": 'GUEST',
+ "availability": 'Optional',
+ "serviceProviderList": {
+ "Dhcp": 'VirtualRouter',
+ "Dns": 'VirtualRouter',
+ "SourceNat": 'VirtualRouter',
+ "PortForwarding": 'VirtualRouter',
+ "Vpn": 'VirtualRouter',
+ "Firewall": 'VirtualRouter',
+ "Lb": 'Netscaler',
+ "UserData": 'VirtualRouter',
+ "StaticNat": 'VirtualRouter',
+ },
},
"nw_off_isolated_persistent": {
"name": 'Test Nw off isolated persistent',
@@ -328,50 +307,32 @@ test_data = {
}
},
"network_offering_vlan": {
- "name": 'Test Network offering',
- "displaytext": 'Test Network offering',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
- "traffictype": 'GUEST',
- "specifyvlan": 'False',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "PortForwarding": 'VirtualRouter',
- },
+ "name": 'Test Network offering',
+ "displaytext": 'Test Network offering',
+ "guestiptype": 'Isolated',
+ "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
+ "traffictype": 'GUEST',
+ "specifyvlan": 'False',
+ "availability": 'Optional',
+ "serviceProviderList": {
+ "Dhcp": 'VirtualRouter',
+ "Dns": 'VirtualRouter',
+ "SourceNat": 'VirtualRouter',
+ "PortForwarding": 'VirtualRouter',
+ },
},
"network_offering_without_sourcenat": {
- "name": 'Test Network offering',
- "displaytext": 'Test Network offering',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Dns,UserData',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": 'VirtualRouter',
- "Dns": 'VirtualRouter',
- "UserData": 'VirtualRouter',
- },
- },
- "isolated_staticnat_network_offering": {
- "name": 'isolated_staticnat_net_off_marvin',
- "displaytext": 'isolated_staticnat_net_off_marvin',
+ "name": 'Test Network offering',
+ "displaytext": 'Test Network offering',
"guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,StaticNat,UserData,Firewall,Dns',
+ "supportedservices": 'Dhcp,Dns,UserData',
"traffictype": 'GUEST',
- "ispersistent": 'True',
"availability": 'Optional',
- "tags": 'native',
"serviceProviderList": {
"Dhcp": 'VirtualRouter',
- "StaticNat": 'VirtualRouter',
- "SourceNat": 'VirtualRouter',
- "Firewall": 'VirtualRouter',
+ "Dns": 'VirtualRouter',
"UserData": 'VirtualRouter',
- "Dns": 'VirtualRouter'
- }
+ },
},
"isolated_network": {
"name": "Isolated Network",
@@ -494,20 +455,6 @@ test_data = {
"SecurityGroup": "SecurityGroupProvider"
}
},
- "shared_network_config_drive_offering": {
- "name": 'shared_network_config_drive_offering',
- "displaytext": 'shared_network_config_drive_offering',
- "guestiptype": 'shared',
- "supportedservices": 'Dhcp,UserData',
- "traffictype": 'GUEST',
- "specifyVlan": "True",
- "specifyIpRanges": "True",
- "availability": 'Optional',
- "serviceProviderList": {
- "Dhcp": "VirtualRouter",
- "UserData": 'ConfigDrive'
- }
- },
"shared_network_sg": {
"name": "Shared-Network-SG-Test",
"displaytext": "Shared-Network_SG-Test",
@@ -526,12 +473,6 @@ test_data = {
"supportedservices":
"Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL"
},
- "vpc_offering_reduced": {
- "name": "VPC reduced off",
- "displaytext": "VPC reduced off",
- "supportedservices":
- "Dhcp,Dns,SourceNat,UserData,StaticNat,NetworkACL"
- },
"vpc_offering_multi_lb": {
"name": "VPC offering with multiple Lb service providers",
"displaytext": "VPC offering with multiple Lb service providers",
@@ -554,10 +495,10 @@ test_data = {
"cidr": "10.0.0.1/24"
},
"vpc_network_domain": {
- "name": "TestVPC",
- "displaytext": "TestVPC",
- "cidr": '10.0.0.1/24',
- "network_domain": "TestVPC"
+ "name": "TestVPC",
+ "displaytext": "TestVPC",
+ "cidr": '10.0.0.1/24',
+ "network_domain": "TestVPC"
},
"clusters": {
0: {
@@ -697,26 +638,6 @@ test_data = {
"Lb": "VpcVirtualRouter"
}
},
- "nw_offering_reduced_vpc": {
- "name": 'Reduced Network for VPC',
- "displaytext": 'Reduced Network for VPC',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,UserData,'
- 'Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "tags": "native",
- "useVpc": 'on',
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": "VpcVirtualRouter",
- "StaticNat": "VpcVirtualRouter",
- "SourceNat": "VpcVirtualRouter",
- "NetworkACL": "VpcVirtualRouter",
- "UserData": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter"
- }
- },
"nw_off_persistent_VPCVR_LB": {
"name": "Persistent Network VPC with LB",
"displaytext": "Persistent Network VPC No LB",
@@ -855,11 +776,11 @@ test_data = {
},
"network_acl_rule": {
- "protocol": "TCP",
- "traffictype": "ingress",
- "cidrlist": "0.0.0.0/0",
- "startport": "1",
- "endport": "1"
+ "protocol": "TCP",
+ "traffictype": "ingress",
+ "cidrlist": "0.0.0.0/0",
+ "startport": "1",
+ "endport": "1"
},
"network_offering_internal_lb": {
"name": "Network offering for internal lb service",
@@ -900,7 +821,7 @@ test_data = {
"privateport": 50,
"privateendport": 55,
},
- "egress_80": {
+ "egress_80": {
"startport": 80,
"endport": 80,
"protocol": "TCP",
@@ -948,14 +869,6 @@ test_data = {
"protocol": "TCP",
"cidrlist": '0.0.0.0/0',
},
- "dns_rule": {
- "privateport": 53,
- "publicport": 53,
- "startport": 53,
- "endport": 53,
- "protocol": "UDP",
- "cidrlist": '0.0.0.0/0',
- },
"icmprule": {
"icmptype": -1,
"icmpcode": -1,
@@ -1053,9 +966,9 @@ test_data = {
"urlvmware":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-vmware.ova",
"urlxen":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-xen.vhd.bz2",
"urlkvm": "http://dl.openvm.eu/cloudstack/coreos/x86_64/" \
- "coreos_production_cloudstack_image-kvm.qcow2.bz2",
+ "coreos_production_cloudstack_image-kvm.qcow2.bz2",
"urlhyperv":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-hyperv.vhd.zip"
- },
+ },
"CentOS6.3template": {
"displaytext": "Centos",
"name": "Centos",
@@ -1105,14 +1018,14 @@ test_data = {
"hypervisor": "XenServer"
},
"Windows Server 2012": {
- "displaytext": "Windows Server 2012",
- "name": "Windows Server 2012",
- "passwordenabled": False,
- "format": "OVA",
- "ostype": "Windows Server 2012 (64-bit)",
- "ispublic": "true",
- "hypervisor": "Vmware"
- },
+ "displaytext": "Windows Server 2012",
+ "name": "Windows Server 2012",
+ "passwordenabled": False,
+ "format": "OVA",
+ "ostype": "Windows Server 2012 (64-bit)",
+ "ispublic": "true",
+ "hypervisor": "Vmware"
+ },
"privatetemplate": {
"displaytext": "Public Template",
"name": "Public template",
@@ -1214,29 +1127,29 @@ test_data = {
},
"volume": {"diskname": "Test Volume",
"size": 1
- },
+ },
"volume_write_path": {
"diskname": "APP Data Volume",
"size": 1, # in GBs
"xenserver": {"rootdiskdevice":"/dev/xvda",
- "datadiskdevice_1": '/dev/xvdb',
- "datadiskdevice_2": '/dev/xvdc', # Data Disk
- },
+ "datadiskdevice_1": '/dev/xvdb',
+ "datadiskdevice_2": '/dev/xvdc', # Data Disk
+ },
"kvm": {"rootdiskdevice": "/dev/vda",
- "datadiskdevice_1": "/dev/vdb",
- "datadiskdevice_2": "/dev/vdc"
- },
+ "datadiskdevice_1": "/dev/vdb",
+ "datadiskdevice_2": "/dev/vdc"
+ },
"vmware": {"rootdiskdevice": "/dev/hda",
- "datadiskdevice_1": "/dev/hdb",
- "datadiskdevice_2": "/dev/hdc"
- }
+ "datadiskdevice_1": "/dev/hdb",
+ "datadiskdevice_2": "/dev/hdc"
+ }
},
"data_write_paths": {
- "mount_dir": "/mnt/tmp",
- "sub_dir": "test",
- "sub_lvl_dir1": "test1",
- "sub_lvl_dir2": "test2",
- "random_data": "random.data",
+ "mount_dir": "/mnt/tmp",
+ "sub_dir": "test",
+ "sub_lvl_dir1": "test1",
+ "sub_lvl_dir2": "test2",
+ "random_data": "random.data",
},
"custom_volume": {
"customdisksize": 1,
@@ -1358,15 +1271,15 @@ test_data = {
"hypervisor": "XenServer"
},
"RHEL 7 (64-bit)": {
- "displaytext": "RHEL7 (64-bit)",
- "name": "RHEL 7 Insta1",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/RHEL764bitwithtools.vhd",
- "format": "VHD" ,
- "ostype": "RHEL 7 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
- },
+ "displaytext": "RHEL7 (64-bit)",
+ "name": "RHEL 7 Insta1",
+ "passwordenabled": False,
+ "url": "http://people.apache.org/~sanjeev/RHEL764bitwithtools.vhd",
+ "format": "VHD" ,
+ "ostype": "RHEL 7 (64-bit)",
+ "ispublic": "true",
+ "hypervisor": "XenServer"
+ },
"clusters": {
"clustername": "Xen Cluster Vgpu",
"clustertype": "CloudManaged",
@@ -1732,11 +1645,11 @@ test_data = {
"name": "Primary iSCSI"
},
"host": {
- "publicport": 22,
- "username": "root",
- "password": "password",
+ "publicport": 22,
+ "username": "root",
+ "password": "password",
},
- "ldap_account": {
+ "ldap_account": {
"email": "",
"firstname": "",
"lastname": "",
@@ -1754,8 +1667,8 @@ test_data = {
"ldapPassword": ""
},
"systemVmDelay": 120,
- "setUsageConfigurationThroughTestCase": False,
- "vmware_cluster" : {
+ "setUsageConfigurationThroughTestCase": False,
+ "vmware_cluster" : {
"hypervisor": 'VMware',
"clustertype": 'ExternalManaged',
"username": '',
@@ -1808,87 +1721,87 @@ test_data = {
]
},
-"interop":
- {
- "VHD":
- {
- "displaytext": "Windows 8 (64-bit)",
- "name": "win8withpvxen",
- "passwordenabled": False,
- "url": "http://people.apache.org/~sanjeev/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
- "format": "VHD" ,
- "ostype": "Windows 8 (64-bit)",
- "ispublic": "true",
- "hypervisor": "XenServer"
-
- },
- "OVA":
- {
- "displaytext": "Windows 8 (64-bit)",
- "name": "win8withpvvmware",
- "passwordenabled": False,
- "url": "http://pleaseupdateURL/",
- "format": "OVA" ,
- "ostype": "Windows 8 (64-bit)",
- "ispublic": "true",
- "hypervisor": "VMware"
- },
- "template": {
- "displaytext": "windowsxdtemplate",
- "name": "windowsxdtemplate",
- "passwordenabled": False,
- "ostype": "Windows 8 (64-bit)"
- },
-},
+ "interop":
+ {
+ "VHD":
+ {
+ "displaytext": "Windows 8 (64-bit)",
+ "name": "win8withpvxen",
+ "passwordenabled": False,
+ "url": "http://people.apache.org/~sanjeev/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
+ "format": "VHD" ,
+ "ostype": "Windows 8 (64-bit)",
+ "ispublic": "true",
+ "hypervisor": "XenServer"
- "browser_upload_volume":{
- "VHD": {
- "diskname": "XenUploadVol",
- "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.vhd",
- "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
- },
- "OVA": {
- "diskname": "VMwareUploadVol",
- "url": "http://people.apache.org/~sanjeev/CentOS5.5(64bit)-vmware-autoscale.ova",
- "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
},
- "QCOW2": {
- "diskname": "KVMUploadVol",
- "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.qcow2",
- "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
+ "OVA":
+ {
+ "displaytext": "Windows 8 (64-bit)",
+ "name": "win8withpvvmware",
+ "passwordenabled": False,
+ "url": "http://pleaseupdateURL/",
+ "format": "OVA" ,
+ "ostype": "Windows 8 (64-bit)",
+ "ispublic": "true",
+ "hypervisor": "VMware"
},
- 'browser_resized_disk_offering': {
- "displaytext": "Resizeddisk",
- "name": "Resizeddisk",
- "disksize": 3,
- }
-},
+ "template": {
+ "displaytext": "windowsxdtemplate",
+ "name": "windowsxdtemplate",
+ "passwordenabled": False,
+ "ostype": "Windows 8 (64-bit)"
+ },
+ },
+
+ "browser_upload_volume":{
+ "VHD": {
+ "diskname": "XenUploadVol",
+ "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.vhd",
+ "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
+ },
+ "OVA": {
+ "diskname": "VMwareUploadVol",
+ "url": "http://people.apache.org/~sanjeev/CentOS5.5(64bit)-vmware-autoscale.ova",
+ "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
+ },
+ "QCOW2": {
+ "diskname": "KVMUploadVol",
+ "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.qcow2",
+ "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
+ },
+ 'browser_resized_disk_offering': {
+ "displaytext": "Resizeddisk",
+ "name": "Resizeddisk",
+ "disksize": 3,
+ }
+ },
"browser_upload_template": {
- "VHD": {
- "templatename": "XenUploadtemplate",
- "displaytext": "XenUploadtemplate",
- "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2",
- "hypervisor":"XenServer",
- "checksum": "54ebc933e6e07ae58c0dc97dfd37c824",
- "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
- },
- "OVA": {
- "templatename": "VMwareUploadtemplate",
- "displaytext": "VMwareUploadtemplate",
- "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova",
- "checksum": "d6d97389b129c7d898710195510bf4fb",
- "hypervisor":"VMware",
- "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
- },
- "QCOW2": {
- "templatename": "KVMUploadtemplate",
- "displaytext": "VMwareUploadtemplate",
- "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2",
- "checksum": "ada77653dcf1e59495a9e1ac670ad95f",
- "hypervisor":"KVM",
- "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
- },
- },
+ "VHD": {
+ "templatename": "XenUploadtemplate",
+ "displaytext": "XenUploadtemplate",
+ "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2",
+ "hypervisor":"XenServer",
+ "checksum": "54ebc933e6e07ae58c0dc97dfd37c824",
+ "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
+ },
+ "OVA": {
+ "templatename": "VMwareUploadtemplate",
+ "displaytext": "VMwareUploadtemplate",
+ "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova",
+ "checksum": "d6d97389b129c7d898710195510bf4fb",
+ "hypervisor":"VMware",
+ "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
+ },
+ "QCOW2": {
+ "templatename": "KVMUploadtemplate",
+ "displaytext": "VMwareUploadtemplate",
+ "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2",
+ "checksum": "ada77653dcf1e59495a9e1ac670ad95f",
+ "hypervisor":"KVM",
+ "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
+ },
+ },
"configurableData":
{
"portableIpRange": {
@@ -1973,401 +1886,36 @@ test_data = {
"url": "http://dl.openvm.eu/cloudstack/iso/TinyCore-8.0.iso",
"ostype": 'Other Linux (64-bit)',
"mode": 'HTTP_DOWNLOAD'
- },
- "setHostConfigurationForIngressRule": False,
- "restartManagementServerThroughTestCase": False,
- "vmxnet3template": {
- "displaytext": "VMXNET3 Template",
- "name": "VMXNET3 template",
- "ostype": "CentOS 5.6 (64-bit)",
- "isfeatured": True,
- "ispublic": False,
- "isextractable": True,
- "mode": "HTTP_DOWNLOAD",
- "templatefilter": "self",
- "url": "http://people.apache.org/~sanjeev/systemvm64template-2014-09-30-4.3-vmware.ova",
- "hypervisor": "vmware",
- "format": "OVA",
- "nicadapter": "vmxnet3",
+ },
+ "setHostConfigurationForIngressRule": False,
+ "restartManagementServerThroughTestCase": False,
+ "vmxnet3template": {
+ "displaytext": "VMXNET3 Template",
+ "name": "VMXNET3 template",
+ "ostype": "CentOS 5.6 (64-bit)",
+ "isfeatured": True,
+ "ispublic": False,
+ "isextractable": True,
+ "mode": "HTTP_DOWNLOAD",
+ "templatefilter": "self",
+ "url": "http://people.apache.org/~sanjeev/systemvm64template-2014-09-30-4.3-vmware.ova",
+ "hypervisor": "vmware",
+ "format": "OVA",
+ "nicadapter": "vmxnet3",
"kvm": {
- "url": ""
- },
- "vmware": {
- "url": ""
- },
- "xenserver": {
- "url": ""
- },
- "hyperv": {
- "url": ""
- },
- "ostype": 'CentOS 5.3 (64-bit)',
- "mode": 'HTTP_DOWNLOAD'
- }
- },
- # Nuage VSP SDN plugin specific test data
- "nuagevsp": {
- # Services supported by the Nuage VSP plugin for Isolated networks
- "isolated_network_offering": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp',
- "UserData": 'VirtualRouter',
- "Dns": 'VirtualRouter'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Persistent services supported by the Nuage VSP plugin for Isolated networks
- "isolated_network_offering_persistent": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "ispersistent": 'True',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp',
- "UserData": 'VirtualRouter',
- "Dns": 'VirtualRouter'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Persistent services supported by the Nuage VSP plugin for Isolated networks
- "isolated_network_offering_persistent": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "ispersistent": 'True',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp',
- "UserData": 'VirtualRouter',
- "Dns": 'VirtualRouter'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Purely nuage network offering
- "isolated_network_offering_without_vr": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
- "traffictype": 'GUEST',
- "availabiliy": 'Optional',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Purely persistent nuage network offering
- "isolated_network_offering_without_vr_persistent": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "tags": "nuage",
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Purely nuage network offering
- "isolated_network_offering_without_vr": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
- "traffictype": 'GUEST',
- "availabiliy": 'Optional',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Purely persistent nuage network offering
- "isolated_network_offering_without_vr_persistent": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "tags": "nuage",
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": 'NuageVsp',
- "StaticNat": 'NuageVsp',
- "SourceNat": 'NuageVsp',
- "Firewall": 'NuageVsp',
- "Connectivity": 'NuageVsp'
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Services supported by the Nuage VSP plugin for VPC networks
- "vpc_network_offering": {
- "name": 'nuage_vpc_marvin',
- "displaytext": 'nuage_vpc_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "useVpc": 'on',
- "ispersistent": 'True',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter"
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- "vpc_network_offering_internal_lb": {
- "name": "nuage_vpc_marvin_internal_lb",
- "displaytext": "nuage_vpc_marvin_internal_lb",
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "tags": "nuage",
- "useVpc": 'on',
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "Lb": "InternalLbVm",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter"
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"},
- "Lb": {"lbSchemes": "internal", "SupportedLbIsolation": "dedicated"}
- }
- },
- # Services supported by the Nuage VSP plugin for VPCs
- "vpc_offering": {
- "name": 'Nuage VSP VPC offering',
- "displaytext": 'Nuage VSP VPC offering',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter"
- }
- },
- "vpc_offering_lb": {
- "name": 'Nuage VSP VPC offering with Lb',
- "displaytext": 'Nuage VSP VPC offering with Lb',
- "supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "Lb": "InternalLbVm",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "UserData": "VpcVirtualRouter",
- "Dns": "VpcVirtualRouter"
- }
- },
- # Services supported by the Nuage VSP plugin for VPC without userdata
- "vpc_network_offering_nuage_dhcp": {
- "name": 'nuage_vpc_marvin',
- "displaytext": 'nuage_vpc_marvin',
- "guestiptype": 'Isolated',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
- "traffictype": 'GUEST',
- "availability": 'Optional',
- "useVpc": 'on',
- "ispersistent": 'True',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "Dns": "VpcVirtualRouter",
- },
- "serviceCapabilityList": {
- "SourceNat": {"SupportedSourceNatTypes": "perzone"}
- }
- },
- # Services supported by the Nuage VSP plugin for VPCs
- "vpc_offering_nuage_dhcp": {
- "name": 'Nuage VSP VPC offering',
- "displaytext": 'Nuage VSP VPC offering',
- "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "StaticNat": "NuageVsp",
- "SourceNat": "NuageVsp",
- "NetworkACL": "NuageVsp",
- "Connectivity": "NuageVsp",
- "Dns": "VpcVirtualRouter",
- }
- },
- "shared_nuage_network_offering": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'shared',
- "supportedservices": 'Dhcp,Connectivity',
- "traffictype": 'GUEST',
- "specifyVlan": "False",
- "specifyIpRanges": "True",
- "availability": 'Optional',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "Connectivity": "NuageVsp"
- }
- },
- "shared_nuage_public_network_offering": {
- "name": 'nuage_marvin',
- "displaytext": 'nuage_marvin',
- "guestiptype": 'shared',
- "supportedservices": 'Dhcp,Connectivity',
- "traffictype": 'GUEST',
- "specifyVlan": "False",
- "specifyIpRanges": "True",
- "availability": 'Optional',
- "tags": "nuage",
- "serviceProviderList": {
- "Dhcp": "NuageVsp",
- "Connectivity": "NuageVsp"
- },
- "serviceCapabilityList": {
- "Connectivity": {
- "PublicAccess": "true"
- }
+ "url": ""
+ },
+ "vmware": {
+ "url": ""
+ },
+ "xenserver": {
+ "url": ""
+ },
+ "hyperv": {
+ "url": ""
+ },
+ "ostype": 'CentOS 5.3 (64-bit)',
+ "mode": 'HTTP_DOWNLOAD'
}
-
- },
- # Test data for Shared Network creation
- "network_all": {
- "name": "SharedNetwork-All-nuage",
- "displaytext": "SharedNetwork-All-nuage",
- "gateway": "10.200.100.1",
- "netmask": "255.255.255.0",
- "startip": "10.200.100.21",
- "endip": "10.200.100.100",
- "acltype": "Domain"
- },
- "network_domain_with_no_subdomain_access": {
- "name": "SharedNetwork-Domain-nosubdomain-nuage",
- "displaytext": "SharedNetwork-Domain-nosubdomain-nuage",
- "gateway": "10.222.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.222.1.2",
- "endip": "10.222.1.100",
- "acltype": "Domain",
- "subdomainaccess": "false"
- },
- "network_domain_with_subdomain_access": {
- "name": "SharedNetwork-Domain-withsubdomain-nuage",
- "displaytext": "SharedNetwork-Domain-withsubdomain-nuage",
- "gateway": "10.221.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.221.1.2",
- "endip": "10.221.1.100",
- "acltype": "Domain",
- "subdomainaccess": "true"
- },
- "network_account": {
- "name": "SharedNetwork-Account-nuage",
- "displaytext": "SharedNetwork-Account-nuage",
- "gateway": "10.220.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.220.1.2",
- "endip": "10.220.1.100",
- "acltype": "Account"
- },
- "publiciprange1": {
- "gateway": "10.200.100.1",
- "netmask": "255.255.255.0",
- "startip": "10.200.100.101",
- "endip": "10.200.100.105",
- "forvirtualnetwork": "false"
- },
- "publiciprange2": {
- "gateway": "10.219.1.1",
- "netmask": "255.255.255.0",
- "startip": "10.219.1.2",
- "endip": "10.219.1.5",
- "forvirtualnetwork": "false"
- },
- "publiciprange3": {
- "gateway": "10.200.100.1",
- "netmask": "255.255.255.0",
- "startip": "10.200.100.2",
- "endip": "10.200.100.20",
- "forvirtualnetwork": "false"
}
- }
}
-
diff --git a/tools/marvin/setup.py b/tools/marvin/setup.py
index 20b2f2a..7ff9a37 100644
--- a/tools/marvin/setup.py
+++ b/tools/marvin/setup.py
@@ -57,7 +57,7 @@ setup(name="Marvin",
"ipmisim >= 0.7"
],
extras_require={
- "nuagevsp": ["libVSD", "PyYAML", "futures", "netaddr", "retries", "jpype1"]
+ "nuagevsp": ["vspk", "PyYAML", "futures", "netaddr", "retries", "jpype1"]
},
py_modules=['marvin.marvinPlugin'],
zip_safe=False,
--
To stop receiving notification emails like this one, please contact
rohit@apache.org.