appdirs==1.4.0
Babel==2.3.4
backport-ipaddress==0.1
+chainmap==1.0.2
cliff==2.3.0
cmd2==0.6.8
coverage==4.1b2
memory-mb: '4096'
mgmt-interface:
vdu-id: pinggen-baremetal
+ {% if user is defined %}
user: '{{user}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if password is defined %}
password: '{{password}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if ip is defined %}
ip: '{{ip}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if key_filename is defined %}
+ key_filename: '{{key_filename}}' # Value filled by vnfdgen
+ {% endif %}
connection-point:
- name: xe0
type: VPORT
description: TRex stateless traffic verifier
mgmt-interface:
vdu-id: trexgen-baremetal
+ {% if user is defined %}
user: '{{user}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if password is defined %}
password: '{{password}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if ip is defined %}
ip: '{{ip}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if key_filename is defined %}
+ key_filename: '{{key_filename}}' # Value filled by vnfdgen
+ {% endif %}
connection-point:
- name: xe0
type: VPORT
--- /dev/null
+# Copyright (c) 2016-2017 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+vnfd:vnfd-catalog:
+ vnfd:
+ - id: TrexTrafficGenRFC # nsb class mapping
+ name: trexverifier
+ short-name: trexverifier
+ description: TRex stateless traffic verifier
+ mgmt-interface:
+ vdu-id: trexgen-baremetal
+ {% if user is defined %}
+ user: '{{user}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if password is defined %}
+ password: '{{password}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if ip is defined %}
+ ip: '{{ip}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if key_filename is defined %}
+ key_filename: '{{key_filename}}' # Value filled by vnfdgen
+ {% endif %}
+ connection-point:
+ - name: xe0
+ type: VPORT
+ - name: xe1
+ type: VPORT
+ vdu:
+ - id: trexgen-baremetal
+ name: trexgen-baremetal
+ description: TRex stateless traffic verifier
+ external-interface:
+ - name: xe0
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ # Substitution variables MUST be quoted. Otherwise Python can misinterpet them.
+ vpci: '{{ interfaces.xe0.vpci }}' # Value filled by vnfdgen
+ local_iface_name: '{{ interfaces.xe0.local_iface_name }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe0.local_ip }}' # Value filled by vnfdgen
+ driver: '{{ interfaces.xe0.driver}}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe0.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe0.local_mac }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe0.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe0
+ - name: xe1
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ vpci: '{{ interfaces.xe1.vpci }}' # Value filled by vnfdgen
+ local_iface_name: '{{ interfaces.xe1.local_iface_name }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe1.local_ip }}' # Value filled by vnfdgen
+ driver: '{{ interfaces.xe1.driver}}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe1.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe1.local_mac }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe1.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe1
+ - name: xe2
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ # Substitution variables MUST be quoted. Otherwise Python can misinterpet them.
+ vpci: '{{ interfaces.xe2.vpci }}' # Value filled by vnfdgen
+ local_iface_name: '{{ interfaces.xe2.local_iface_name }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe2.local_ip }}' # Value filled by vnfdgen
+ driver: '{{ interfaces.xe2.driver}}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe2.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe2.local_mac }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe2.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe2
+ - name: xe3
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ vpci: '{{ interfaces.xe3.vpci }}' # Value filled by vnfdgen
+ local_iface_name: '{{ interfaces.xe3.local_iface_name }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe3.local_ip }}' # Value filled by vnfdgen
+ driver: '{{ interfaces.xe3.driver}}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe3.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe3.local_mac }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe3.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe3
+
+ benchmark:
+ kpi:
+ - rx_throughput_fps
+ - tx_throughput_fps
+ - tx_throughput_mbps
+ - rx_throughput_mbps
+ - in_packets
+ - out_packets
memory-mb: '4096'
mgmt-interface:
vdu-id: trexgen-baremetal
+ {% if user is defined %}
user: '{{user}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if password is defined %}
password: '{{password}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if ip is defined %}
ip: '{{ip}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if key_filename is defined %}
+ key_filename: '{{key_filename}}' # Value filled by vnfdgen
+ {% endif %}
connection-point:
- name: xe0
type: VPORT
description: vPe approximation using DPDK
mgmt-interface:
vdu-id: vpevnf-baremetal
+ {% if user is defined %}
user: '{{user}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if password is defined %}
password: '{{password}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if ip is defined %}
ip: '{{ip}}' # Value filled by vnfdgen
- host: '{{host}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if key_filename is defined %}
+ key_filename: '{{key_filename}}' # Value filled by vnfdgen
+ {% endif %}
connection-point:
- name: xe0
type: VPORT
--- /dev/null
+# Copyright (c) 2016-2017 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+vnfd:vnfd-catalog:
+ vnfd:
+ - id: VpeApproxVnf
+ name: VpeVnfSshIntel
+ short-name: VpeVnf
+ description: vPe approximation using DPDK
+ mgmt-interface:
+ vdu-id: vpevnf-baremetal
+ {% if user is defined %}
+ user: '{{user}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if password is defined %}
+ password: '{{password}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if ip is defined %}
+ ip: '{{ip}}' # Value filled by vnfdgen
+ {% endif %}
+ {% if key_filename is defined %}
+ key_filename: '{{key_filename}}' # Value filled by vnfdgen
+ {% endif %}
+ connection-point:
+ - name: xe0
+ type: VPORT
+ - name: xe1
+ type: VPORT
+ vdu:
+ - id: vpevnf-baremetal
+ name: vpevnf-baremetal
+ description: vpe approximation using DPDK
+ external-interface:
+ - name: xe0
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ # Substitution variables MUST be quoted. Otherwise Python can misinterpet them.
+ vpci: '{{ interfaces.xe0.vpci }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe0.local_ip }}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe0.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe0.local_mac }}' # Value filled by vnfdgen
+ netmask: '{{ interfaces.xe0.netmask }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe0.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe0
+ - name: xe1
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ # Substitution variables MUST be quoted. Otherwise Python can misinterpet them.
+ vpci: '{{ interfaces.xe1.vpci }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe1.local_ip }}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe1.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe1.local_mac }}' # Value filled by vnfdgen
+ netmask: '{{ interfaces.xe1.netmask }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe1.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe1
+ - name: xe2
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ # Substitution variables MUST be quoted. Otherwise Python can misinterpet them.
+ vpci: '{{ interfaces.xe2.vpci }}' # Value filled by vnfdgen
+ local_iface_name: '{{ interfaces.xe2.local_iface_name }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe2.local_ip }}' # Value filled by vnfdgen
+ driver: '{{ interfaces.xe2.driver}}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe2.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe2.local_mac }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe2.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe2
+ - name: xe3
+ virtual-interface:
+ type: PCI-PASSTHROUGH
+ vpci: '{{ interfaces.xe3.vpci }}' # Value filled by vnfdgen
+ local_iface_name: '{{ interfaces.xe3.local_iface_name }}' # Value filled by vnfdgen
+ local_ip: '{{ interfaces.xe3.local_ip }}' # Value filled by vnfdgen
+ driver: '{{ interfaces.xe3.driver}}' # Value filled by vnfdgen
+ dst_ip: '{{ interfaces.xe3.dst_ip }}' # Value filled by vnfdgen
+ local_mac: '{{ interfaces.xe3.local_mac }}' # Value filled by vnfdgen
+ dst_mac: '{{ interfaces.xe3.dst_mac }}' # Value filled by vnfdgen
+ bandwidth: 10 Gbps
+ vnfd-connection-point-ref: xe3
+ routing_table: {{ routing_table }}
+ benchmark:
+ kpi:
+ - packets_in
+ - packets_fwd
+ - packets_dropped
def test_install(self, mock_ssh):
p = plugin.Plugin()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
input_file = Arg()
p.install(input_file)
expected_result = {}
def test_remove(self, mock_ssh):
p = plugin.Plugin()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
input_file = Arg()
p.remove(input_file)
expected_result = {}
def test_install_setup_run(self, mock_ssh):
p = plugin.Plugin()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
plugins = {
"name": "sample"
}
def test_remove_setup_run(self, mock_ssh):
p = plugin.Plugin()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
plugins = {
"name": "sample"
}
ins = attacker_baremetal.BaremetalAttacker(self.attacker_cfg,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "running", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
ins.setup()
ins.inject_fault()
ins.recover()
def test__attacker_baremetal_check_failuer(self, mock_ssh):
ins = attacker_baremetal.BaremetalAttacker(self.attacker_cfg,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "error check", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "error check", '')
ins.setup()
def test__attacker_baremetal_recover_successful(self, mock_ssh):
ins = attacker_baremetal.BaremetalAttacker(self.attacker_cfg,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "running", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
ins.setup()
ins.recover()
cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
ins = cls(self.attacker_cfg, self.context)
- mock_ssh.SSH().execute.return_value = (0, "running", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
ins.setup()
ins.inject_fault()
ins.recover()
cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
ins = cls(self.attacker_cfg, self.context)
- mock_ssh.SSH().execute.return_value = (0, "error check", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "error check", '')
ins.setup()
cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
ins = cls(self.attacker_cfg, self.context)
- mock_ssh.SSH().execute.return_value = (0, "running", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
ins.setup()
ins.inject_fault()
ins.recover()
cls = baseattacker.BaseAttacker.get_attacker_cls(self.attacker_cfg)
ins = cls(self.attacker_cfg, self.context)
- mock_ssh.SSH().execute.return_value = (0, "error check", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "error check", '')
ins.setup()
instance = monitor_command.MonitorOpenstackCmd(
self.config, self.context)
instance.setup()
- mock_ssh.SSH().execute.return_value = (0, "0", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "0", '')
ret = instance.monitor_func()
ins = monitor_general.GeneralMonitor(self.monitor_cfg, self.context)
ins.setup()
- mock_ssh.SSH().execute.return_value = (0, "running", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
ins.monitor_func()
ins._result = {'outage_time': 0}
ins.verify_SLA()
self.monitor_cfg_noparam, self.context)
ins.setup()
- mock_ssh.SSH().execute.return_value = (0, "running", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "running", '')
ins.monitor_func()
ins._result = {'outage_time': 0}
ins.verify_SLA()
self.monitor_cfg_noparam, self.context)
ins.setup()
- mock_ssh.SSH().execute.return_value = (1, "error", 'error')
+ mock_ssh.SSH.from_node().execute.return_value = (1, "error", 'error')
ins.monitor_func()
ins._result = {'outage_time': 2}
ins.verify_SLA()
ins = monitor_process.MonitorProcess(self.monitor_cfg, self.context)
- mock_ssh.SSH().execute.return_value = (0, "1", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
ins.setup()
ins.monitor_func()
ins._result = {"outage_time": 0}
ins = monitor_process.MonitorProcess(self.monitor_cfg, self.context)
- mock_ssh.SSH().execute.return_value = (0, "0", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "0", '')
ins.setup()
ins.monitor_func()
ins._result = {"outage_time": 10}
def test__operation_successful(self, mock_open, mock_ssh):
ins = operation_general.GeneralOperaion(self.operation_cfg,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "success", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "success", '')
ins.setup()
ins.run()
ins.rollback()
def test__operation_successful_noparam(self, mock_open, mock_ssh):
ins = operation_general.GeneralOperaion(self.operation_cfg_noparam,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "success", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "success", '')
ins.setup()
ins.run()
ins.rollback()
def test__operation_fail(self, mock_open, mock_ssh):
ins = operation_general.GeneralOperaion(self.operation_cfg,
self.context)
- mock_ssh.SSH().execute.return_value = (1, "failed", '')
+ mock_ssh.SSH.from_node().execute.return_value = (1, "failed", '')
ins.setup()
ins.run()
ins.rollback()
def test__result_checker_eq(self, mock_open, mock_ssh):
ins = result_checker_general.GeneralResultChecker(self.checker_cfg,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "1", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
ins.setup()
self.assertTrue(ins.verify())
config['condition'] = 'gt'
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "2", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "2", '')
ins.setup()
self.assertTrue(ins.verify())
config['condition'] = 'gt_eq'
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "1", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
ins.setup()
self.assertTrue(ins.verify())
config['condition'] = 'lt'
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "0", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "0", '')
ins.setup()
self.assertTrue(ins.verify())
config['condition'] = 'lt_eq'
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "1", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
ins.setup()
self.assertTrue(ins.verify())
config['expectedValue'] = "value"
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "value return", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "value return", '')
ins.setup()
self.assertTrue(ins.verify())
config['condition'] = 'wrong'
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (0, "1", '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, "1", '')
ins.setup()
self.assertFalse(ins.verify())
config.pop('parameter')
ins = result_checker_general.GeneralResultChecker(config,
self.context)
- mock_ssh.SSH().execute.return_value = (1, "fail", '')
+ mock_ssh.SSH.from_node().execute.return_value = (1, "fail", '')
ins.setup()
ins.verify()
def test_cachestat_successful_setup(self, mock_ssh):
c = cachestat.CACHEstat({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
self.assertIsNotNone(c.client)
def test_execute_command_success(self, mock_ssh):
c = cachestat.CACHEstat({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
expected_result = 'abcdefg'
- mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
result = c._execute_command("foo")
self.assertEqual(result, expected_result)
def test_execute_command_failed(self, mock_ssh):
c = cachestat.CACHEstat({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- mock_ssh.SSH().execute.return_value = (127, '', 'Failed executing \
+ mock_ssh.SSH.from_node().execute.return_value = (127, '', 'Failed executing \
command')
self.assertRaises(RuntimeError, c._execute_command,
"cat /proc/meminfo")
}
args = {"options": options}
c = cachestat.CACHEstat(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
output = self._read_file("cachestat_sample_output.txt")
- mock_ssh.SSH().execute.return_value = (0, output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, output, '')
result = c._get_cache_usage()
expected_result = {"cachestat": {"cache0": {"HITS": "6462",
"DIRTIES": "29",
def test_capacity_successful_setup(self, mock_ssh):
c = computecapacity.ComputeCapacity({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
self.assertIsNotNone(c.client)
def test_capacity_successful(self, mock_ssh):
c = computecapacity.ComputeCapacity({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, SAMPLE_OUTPUT, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, SAMPLE_OUTPUT, '')
c.run(self.result)
expected_result = jsonutils.loads(SAMPLE_OUTPUT)
self.assertEqual(self.result, expected_result)
def test_capacity_unsuccessful_script_error(self, mock_ssh):
c = computecapacity.ComputeCapacity({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, c.run, self.result)
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
self.assertIsNotNone(l.client)
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (127, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (127, '', '')
l.setup()
self.assertIsNotNone(l.client)
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
expected_result = 'abcdefg'
- mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
result = l._execute_command("foo")
self.assertEqual(result, expected_result)
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
- mock_ssh.SSH().execute.return_value = (127, '', 'abcdefg')
+ mock_ssh.SSH.from_node().execute.return_value = (127, '', 'abcdefg')
self.assertRaises(RuntimeError, l._execute_command,
"cat /proc/loadavg")
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
- mock_ssh.SSH().execute.return_value = \
+ mock_ssh.SSH.from_node().execute.return_value = \
(0, '1.50 1.45 1.51 3/813 14322', '')
result = l._get_loadavg()
expected_result = \
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
l.interval = 1
l.count = 1
mpstat_output = self._read_file("cpuload_sample_output1.txt")
- mock_ssh.SSH().execute.return_value = (0, mpstat_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, mpstat_output, '')
result = l._get_cpu_usage_mpstat()
expected_result = \
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
l.interval = 0
output = self._read_file("cpuload_sample_output2.txt")
- mock_ssh.SSH().execute.return_value = (0, output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, output, '')
result = l._get_cpu_usage()
expected_result = \
args = {'options': options}
l = cpuload.CPULoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
l.setup()
l.interval = 0
stat_output = self._read_file("cpuload_sample_output2.txt")
- mock_ssh.SSH().execute.side_effect = \
+ mock_ssh.SSH.from_node().execute.side_effect = \
[(0, '1.50 1.45 1.51 3/813 14322', ''), (0, stat_output, '')]
l.run(self.result)
def test_cyclictest_successful_setup(self, mock_ssh):
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
self.assertIsNotNone(c.guest)
result = {}
self.scenario_cfg.pop("sla", None)
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- c.guest = mock_ssh.SSH()
+ c.guest = mock_ssh.SSH.from_node()
sample_output = '{"min": 100, "avg": 500, "max": 1000}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
c.run(result)
expected_result = jsonutils.loads(sample_output)
}
})
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- c.guest = mock_ssh.SSH()
+ c.guest = mock_ssh.SSH.from_node()
sample_output = '{"min": 100, "avg": 500, "max": 1000}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
c.run(result)
expected_result = jsonutils.loads(sample_output)
result = {}
self.scenario_cfg.update({"sla": {"max_min_latency": 10}})
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- c.guest = mock_ssh.SSH()
+ c.guest = mock_ssh.SSH.from_node()
sample_output = '{"min": 100, "avg": 500, "max": 1000}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, c.run, result)
def test_cyclictest_unsuccessful_sla_avg_latency(self, mock_ssh):
result = {}
self.scenario_cfg.update({"sla": {"max_avg_latency": 10}})
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- c.guest = mock_ssh.SSH()
+ c.guest = mock_ssh.SSH.from_node()
sample_output = '{"min": 100, "avg": 500, "max": 1000}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, c.run, result)
def test_cyclictest_unsuccessful_sla_max_latency(self, mock_ssh):
result = {}
self.scenario_cfg.update({"sla": {"max_max_latency": 10}})
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- c.guest = mock_ssh.SSH()
+ c.guest = mock_ssh.SSH.from_node()
sample_output = '{"min": 100, "avg": 500, "max": 1000}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, c.run, result)
def test_cyclictest_unsuccessful_script_error(self, mock_ssh):
result = {}
self.scenario_cfg.update({"sla": {"max_max_latency": 10}})
c = cyclictest.Cyclictest(self.scenario_cfg, self.context_cfg)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
- c.guest = mock_ssh.SSH()
+ c.guest = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, c.run, result)
def test_successful_setup(self, mock_ssh):
l = lmbench.Lmbench({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
l.setup()
self.assertIsNotNone(l.client)
l = lmbench.Lmbench(args, self.ctx)
sample_output = '[{"latency": 4.944, "size": 0.00049}]'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
l.run(self.result)
expected_result = jsonutils.loads(
'{"latencies": ' + sample_output + "}")
l = lmbench.Lmbench(args, self.ctx)
sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 11025.5}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
l.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
l = lmbench.Lmbench(args, self.ctx)
sample_output = '[{"latency": 4.944, "size": 0.00049}]'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
l.run(self.result)
expected_result = jsonutils.loads(
'{"latencies": ' + sample_output + "}")
l = lmbench.Lmbench(args, self.ctx)
sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 11025.5}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
l.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
l = lmbench.Lmbench(args, self.ctx)
sample_output = '[{"latency": 37.5, "size": 0.00049}]'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, l.run, self.result)
def test_unsuccessful_bandwidth_run_sla(self, mock_ssh):
l = lmbench.Lmbench(args, self.ctx)
sample_output = '{"size(MB)": 0.262144, "bandwidth(MBps)": 9925.5}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, l.run, self.result)
def test_successful_latency_for_cache_run_sla(self, mock_ssh):
l = lmbench.Lmbench(args, self.ctx)
sample_output = "{\"L1cache\": 1.6}"
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
l.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
args = {"options": options}
l = lmbench.Lmbench(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, l.run, self.result)
def test_memload_successful_setup(self, mock_ssh):
m = memload.MEMLoad({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
m.setup()
self.assertIsNotNone(m.client)
def test_execute_command_success(self, mock_ssh):
m = memload.MEMLoad({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
m.setup()
expected_result = 'abcdefg'
- mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
result = m._execute_command("foo")
self.assertEqual(result, expected_result)
def test_execute_command_failed(self, mock_ssh):
m = memload.MEMLoad({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
m.setup()
- mock_ssh.SSH().execute.return_value = (127, '', 'Failed executing \
+ mock_ssh.SSH.from_node().execute.return_value = (127, '', 'Failed executing \
command')
self.assertRaises(RuntimeError, m._execute_command,
"cat /proc/meminfo")
}
args = {"options": options}
m = memload.MEMLoad(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
m.setup()
output = self._read_file("memload_sample_output.txt")
- mock_ssh.SSH().execute.return_value = (0, output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, output, '')
result = m._get_mem_usage()
expected_result = {
"max": {
def test_sample_successful_setup(self, mock_ssh):
s = plugintest.PluginTest({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
s.setup()
self.assertIsNotNone(s.client)
s = plugintest.PluginTest({}, self.ctx)
sample_output = '{"Test Output": "Hello world!"}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
s.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
def test_sample_unsuccessful_script_error(self, mock_ssh):
s = plugintest.PluginTest({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, s.run, self.result)
def test_ramspeed_successful_setup(self, mock_ssh):
r = ramspeed.Ramspeed({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
r.setup()
self.assertIsNotNone(r.client)
{"Test_type": "INTEGER & WRITING", "Block_size(kb)": 16384,\
"Bandwidth(MBps)": 14128.94}, {"Test_type": "INTEGER & WRITING",\
"Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
r.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
{"Test_type": "INTEGER & WRITING", "Block_size(kb)": 16384,\
"Bandwidth(MBps)": 14128.94}, {"Test_type": "INTEGER & WRITING",\
"Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
r.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
"Bandwidth(MBps)": 14159.86}, {"Test_type": "INTEGER & WRITING",\
"Block_size(kb)": 16384, "Bandwidth(MBps)": 14128.94}, {"Test_type":\
"INTEGER & WRITING", "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, r.run, self.result)
def test_ramspeed_unsuccessful_script_error(self, mock_ssh):
args = {"options": options}
r = ramspeed.Ramspeed(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, r.run, self.result)
def test_ramspeed_mem_successful_run_no_sla(self, mock_ssh):
"Bandwidth(MBps)": 10057.48}, {"Test_type": "INTEGER Triad:",\
"Bandwidth(MBps)": 10116.27}, {"Test_type": "INTEGER AVERAGE:",\
"Bandwidth(MBps)": 9401.58}]}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
r.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
"Bandwidth(MBps)": 10057.48}, {"Test_type": "INTEGER Triad:",\
"Bandwidth(MBps)": 10116.27}, {"Test_type": "INTEGER AVERAGE:",\
"Bandwidth(MBps)": 9401.58}]}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
r.run(self.result)
expected_result = jsonutils.loads(sample_output)
self.assertEqual(self.result, expected_result)
"Bandwidth(MBps)": 4300.48}, {"Test_type": "INTEGER Triad:",\
"Bandwidth(MBps)": 1300.27}, {"Test_type": "INTEGER AVERAGE:",\
"Bandwidth(MBps)": 2401.58}]}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, r.run, self.result)
def test_ramspeed_unsuccessful_unknown_type_run(self, mock_ssh):
args = {'options': options}
r = ramspeed.Ramspeed(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'No such type_id: 30 for \
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'No such type_id: 30 for \
Ramspeed scenario')
self.assertRaises(RuntimeError, r.run, self.result)
u = unixbench.Unixbench({}, self.ctx)
u.setup()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
self.assertIsNotNone(u.client)
self.assertEqual(u.setup_done, True)
u = unixbench.Unixbench(args, self.ctx)
result = {}
- u.server = mock_ssh.SSH()
+ u.server = mock_ssh.SSH.from_node()
sample_output = '{"Score":"4425.4"}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
u.run(result)
expected_result = jsonutils.loads(sample_output)
u = unixbench.Unixbench(args, self.ctx)
result = {}
- u.server = mock_ssh.SSH()
+ u.server = mock_ssh.SSH.from_node()
sample_output = '{"Score":"4425.4"}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
u.run(result)
expected_result = jsonutils.loads(sample_output)
u = unixbench.Unixbench(args, self.ctx)
result = {}
- u.server = mock_ssh.SSH()
+ u.server = mock_ssh.SSH.from_node()
sample_output = '{"signle_score":"2251.7","parallel_score":"4395.9"}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
u.run(result)
expected_result = jsonutils.loads(sample_output)
u = unixbench.Unixbench(args, self.ctx)
result = {}
- u.server = mock_ssh.SSH()
+ u.server = mock_ssh.SSH.from_node()
sample_output = '{"single_score":"200.7","parallel_score":"4395.9"}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, u.run, result)
def test_unixbench_unsuccessful_sla_parallel_score(self, mock_ssh):
u = unixbench.Unixbench(args, self.ctx)
result = {}
- u.server = mock_ssh.SSH()
+ u.server = mock_ssh.SSH.from_node()
sample_output = '{"signle_score":"2251.7","parallel_score":"3395.9"}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, u.run, result)
def test_unixbench_unsuccessful_script_error(self, mock_ssh):
u = unixbench.Unixbench(args, self.ctx)
result = {}
- u.server = mock_ssh.SSH()
+ u.server = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, u.run, result)
def test_iperf_successful_setup(self, mock_ssh):
p = iperf3.Iperf({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
p.setup()
self.assertIsNotNone(p.target)
self.assertIsNotNone(p.host)
- mock_ssh.SSH().execute.assert_called_with("iperf3 -s -D")
+ mock_ssh.SSH.from_node().execute.assert_called_with("iperf3 -s -D")
def test_iperf_unsuccessful_setup(self, mock_ssh):
p = iperf3.Iperf({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.setup)
def test_iperf_successful_teardown(self, mock_ssh):
p = iperf3.Iperf({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
- p.target = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
+ p.target = mock_ssh.SSH.from_node()
p.teardown()
- self.assertTrue(mock_ssh.SSH().close.called)
- mock_ssh.SSH().execute.assert_called_with("pkill iperf3")
+ self.assertTrue(mock_ssh.SSH.from_node().close.called)
+ mock_ssh.SSH.from_node().execute.assert_called_with("pkill iperf3")
def test_iperf_successful_no_sla(self, mock_ssh):
result = {}
p = iperf3.Iperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.output_name_tcp)
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = iperf3.Iperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.output_name_tcp)
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = iperf3.Iperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.output_name_tcp)
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_iperf_successful_sla_jitter(self, mock_ssh):
result = {}
p = iperf3.Iperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.output_name_udp)
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = iperf3.Iperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.output_name_udp)
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_iperf_unsuccessful_script_error(self, mock_ssh):
result = {}
p = iperf3.Iperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
def _read_sample_output(self, filename):
def test_netperf_successful_setup(self, mock_ssh):
p = netperf.Netperf({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
p.setup()
self.assertIsNotNone(p.server)
result = {}
p = netperf.Netperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output()
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = netperf.Netperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output()
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = netperf.Netperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output()
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_netperf_unsuccessful_script_error(self, mock_ssh):
result = {}
p = netperf.Netperf(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
def _read_sample_output(self):
def test_netperf_node_successful_setup(self, mock_ssh):
p = netperf_node.NetperfNode({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
p.setup()
self.assertIsNotNone(p.server)
result = {}
p = netperf_node.NetperfNode(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output()
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = netperf_node.NetperfNode(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output()
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
expected_result = jsonutils.loads(sample_output)
p.run(result)
self.assertEqual(result, expected_result)
result = {}
p = netperf_node.NetperfNode(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output()
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_netperf_node_unsuccessful_script_error(self, mock_ssh):
result = {}
p = netperf_node.NetperfNode(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
- p.host = mock_ssh.SSH()
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ p.host = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
def _read_sample_output(self):
args = {'options': options}
n = netutilization.NetUtilization(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
n.setup()
self.assertIsNotNone(n.client)
args = {'options': options}
n = netutilization.NetUtilization(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
n.setup()
expected_result = 'abcdefg'
- mock_ssh.SSH().execute.return_value = (0, expected_result, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, expected_result, '')
result = n._execute_command("foo")
self.assertEqual(result, expected_result)
args = {'options': options}
n = netutilization.NetUtilization(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
n.setup()
- mock_ssh.SSH().execute.return_value = (127, '', 'abcdefg')
+ mock_ssh.SSH.from_node().execute.return_value = (127, '', 'abcdefg')
self.assertRaises(RuntimeError, n._execute_command,
"failed")
args = {'options': options}
n = netutilization.NetUtilization(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
n.setup()
mpstat_output = self._read_file("netutilization_sample_output1.txt")
- mock_ssh.SSH().execute.return_value = (0, mpstat_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, mpstat_output, '')
result = n._get_network_utilization()
expected_result = \
args = {'options': options}
n = netutilization.NetUtilization(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
n.setup()
mpstat_output = self._read_file("netutilization_sample_output2.txt")
- mock_ssh.SSH().execute.return_value = (0, mpstat_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, mpstat_output, '')
result = n._get_network_utilization()
expected_result = \
def test_capacity_successful_setup(self, mock_ssh):
c = networkcapacity.NetworkCapacity({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
self.assertIsNotNone(c.client)
self.assertTrue(c.setup_done)
def test_capacity_successful(self, mock_ssh):
c = networkcapacity.NetworkCapacity({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, SAMPLE_OUTPUT, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, SAMPLE_OUTPUT, '')
c.run(self.result)
expected_result = jsonutils.loads(SAMPLE_OUTPUT)
self.assertEqual(self.result, expected_result)
def test_capacity_unsuccessful_script_error(self, mock_ssh):
c = networkcapacity.NetworkCapacity({}, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, c.run, self.result)
n = nstat.Nstat({}, self.ctx)
n.setup()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
self.assertIsNotNone(n.client)
self.assertEqual(n.setup_done, True)
sample_output = '#kernel\nIpInReceives 1837 0.0\nIpInHdrErrors 0 0.0\nIpInAddrErrors 2 0.0\nIcmpInMsgs 319 0.0\nIcmpInErrors 0 0.0\nTcpInSegs 36 0.0\nTcpInErrs 0 0.0\nUdpInDatagrams 1318 0.0\nUdpInErrors 0 0.0\n'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
n.run(result)
expected_result = {"TcpInErrs": 0, "UdpInDatagrams": 1318,
sample_output = '#kernel\nIpInReceives 1837 0.0\nIpInHdrErrors 0 0.0\nIpInAddrErrors 2 0.0\nIcmpInMsgs 319 0.0\nIcmpInErrors 0 0.0\nTcpInSegs 36 0.0\nTcpInErrs 0 0.0\nUdpInDatagrams 1318 0.0\nUdpInErrors 0 0.0\n'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
n.run(result)
expected_result = {"TcpInErrs": 0, "UdpInDatagrams": 1318,
n = nstat.Nstat(args, self.ctx)
result = {}
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, n.run, result)
p = ping.Ping(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '100', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
p.run(result)
self.assertEqual(result, {'rtt': {'ares': 100.0}})
p = ping.Ping(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '100', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
p.run(result)
self.assertEqual(result, {'rtt': {'ares': 100.0}})
p = ping.Ping(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '100', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
self.assertRaises(AssertionError, p.run, result)
@mock.patch('yardstick.benchmark.scenarios.networking.ping.ssh')
p = ping.Ping(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
'sla': {'max_rtt': 50}
}
p = ping6.Ping6(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '0', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '0', '')
p.setup()
self.assertEqual(p.setup_done, True)
result = {}
p = ping6.Ping6(args, self.ctx)
- p.client = mock_ssh.SSH()
- mock_ssh.SSH().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
+ p.client = mock_ssh.SSH.from_node()
+ mock_ssh.SSH.from_node().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
p.run(result)
self.assertEqual(result, {'rtt': 100.0})
result = {}
p = ping6.Ping6(args, self.ctx)
- p.client = mock_ssh.SSH()
- mock_ssh.SSH().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
+ p.client = mock_ssh.SSH.from_node()
+ mock_ssh.SSH.from_node().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
p.run(result)
self.assertEqual(result, {'rtt': 100.0})
result = {}
p = ping6.Ping6(args, self.ctx)
- p.client = mock_ssh.SSH()
- mock_ssh.SSH().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
+ p.client = mock_ssh.SSH.from_node()
+ mock_ssh.SSH.from_node().execute.side_effect = [(0, 'host1', ''), (0, 100, '')]
self.assertRaises(AssertionError, p.run, result)
@mock.patch('yardstick.benchmark.scenarios.networking.ping6.ssh')
result = {}
p = ping6.Ping6(args, self.ctx)
- p.client = mock_ssh.SSH()
- mock_ssh.SSH().execute.side_effect = [
+ p.client = mock_ssh.SSH.from_node()
+ mock_ssh.SSH.from_node().execute.side_effect = [
(0, 'host1', ''), (1, '', 'FOOBAR')]
self.assertRaises(RuntimeError, p.run, result)
p = pktgen.Pktgen(args, self.ctx)
p.setup()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
self.assertIsNotNone(p.server)
self.assertIsNotNone(p.client)
self.assertEqual(p.setup_done, True)
'options': {'packetsize': 60, 'number_of_ports': 10},
}
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
p.number_of_ports = args['options']['number_of_ports']
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
p._iptables_setup()
- mock_ssh.SSH().execute.assert_called_with(
+ mock_ssh.SSH.from_node().execute.assert_called_with(
"sudo iptables -F; "
"sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
% 1010)
}
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
p.number_of_ports = args['options']['number_of_ports']
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p._iptables_setup)
def test_pktgen_successful_iptables_get_result(self, mock_ssh):
}
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
p.number_of_ports = args['options']['number_of_ports']
- mock_ssh.SSH().execute.return_value = (0, '150000', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
p._iptables_get_result()
- mock_ssh.SSH().execute.assert_called_with(
+ mock_ssh.SSH.from_node().execute.assert_called_with(
"sudo iptables -L INPUT -vnx |"
"awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
% 1010)
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
p.number_of_ports = args['options']['number_of_ports']
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p._iptables_get_result)
def test_pktgen_successful_no_sla(self, mock_ssh):
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
- p.client = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
+ p.client = mock_ssh.SSH.from_node()
mock_iptables_result = mock.Mock()
mock_iptables_result.return_value = 149300
sample_output = '{"packets_per_second": 9753, "errors": 0, \
"packets_sent": 149776, "packetsize": 60, "flows": 110}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
expected_result = jsonutils.loads(sample_output)
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
- p.client = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
+ p.client = mock_ssh.SSH.from_node()
mock_iptables_result = mock.Mock()
mock_iptables_result.return_value = 149300
sample_output = '{"packets_per_second": 9753, "errors": 0, \
"packets_sent": 149776, "packetsize": 60, "flows": 110}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
expected_result = jsonutils.loads(sample_output)
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
- p.client = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
+ p.client = mock_ssh.SSH.from_node()
mock_iptables_result = mock.Mock()
mock_iptables_result.return_value = 149300
sample_output = '{"packets_per_second": 9753, "errors": 0, \
"packets_sent": 149776, "packetsize": 60, "flows": 110}'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_pktgen_unsuccessful_script_error(self, mock_ssh):
p = pktgen.Pktgen(args, self.ctx)
- p.server = mock_ssh.SSH()
- p.client = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
+ p.client = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
p.setup()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
self.assertIsNotNone(p.server)
self.assertIsNotNone(p.client)
self.assertEqual(p.setup_done, True)
'options': {'packetsize': 60},
}
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
p.get_port_ip(p.server, "eth1")
- mock_ssh.SSH().execute.assert_called_with(
+ mock_ssh.SSH.from_node().execute.assert_called_with(
"ifconfig eth1 |grep 'inet addr' |awk '{print $2}' \
|cut -d ':' -f2 ")
}
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.get_port_ip, p.server, "eth1")
def test_pktgen_dpdk_successful_get_port_mac(self, mock_ssh):
'options': {'packetsize': 60},
}
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
p.get_port_mac(p.server, "eth1")
- mock_ssh.SSH().execute.assert_called_with(
+ mock_ssh.SSH.from_node().execute.assert_called_with(
"ifconfig |grep HWaddr |grep eth1 |awk '{print $5}' ")
def test_pktgen_dpdk_unsuccessful_get_port_mac(self, mock_ssh):
}
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
- p.server = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.get_port_mac, p.server, "eth1")
def test_pktgen_dpdk_successful_no_sla(self, mock_ssh):
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
sample_output = '100\n110\n112\n130\n149\n150\n90\n150\n200\n162\n'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
# with python 3 we get float, might be due python division changes
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
sample_output = '100\n100\n100\n100\n100\n100\n100\n100\n100\n100\n'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
- p.server = mock_ssh.SSH()
- p.client = mock_ssh.SSH()
+ p.server = mock_ssh.SSH.from_node()
+ p.client = mock_ssh.SSH.from_node()
sample_output = '100\n110\n112\n130\n149\n150\n90\n150\n200\n162\n'
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_pktgen_dpdk_unsuccessful_script_error(self, mock_ssh):
p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
class SfcTestCase(unittest.TestCase):
def setUp(self):
- scenario_cfg = dict()
- context_cfg = dict()
-
- # Used in Sfc.setup()
- context_cfg['target'] = dict()
- context_cfg['target']['user'] = 'root'
- context_cfg['target']['password'] = 'opnfv'
- context_cfg['target']['ip'] = '127.0.0.1'
-
- # Used in Sfc.run()
- context_cfg['host'] = dict()
- context_cfg['host']['user'] = 'root'
- context_cfg['host']['password'] = 'opnfv'
- context_cfg['host']['ip'] = None
- context_cfg['target'] = dict()
- context_cfg['target']['ip'] = '127.0.0.1'
+ scenario_cfg = {}
+ context_cfg = {
+ # Used in Sfc.setup()
+ 'target': {
+ 'user': 'root',
+ 'password': 'opnfv',
+ 'ip': '127.0.0.1',
+ },
+
+ # Used in Sfc.run()
+ 'host': {
+ 'user': 'root',
+ 'password': 'opnfv',
+ 'ip': None,
+ }
+ }
self.sfc = sfc.Sfc(scenario_cfg=scenario_cfg, context_cfg=context_cfg)
@mock.patch('yardstick.benchmark.scenarios.networking.sfc.subprocess')
def test_run_for_success(self, mock_subprocess, mock_openstack, mock_ssh):
# Mock a successfull SSH in Sfc.setup() and Sfc.run()
- mock_ssh.SSH().execute.return_value = (0, '100', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '100', '')
mock_openstack.get_an_IP.return_value = "127.0.0.1"
mock_subprocess.call.return_value = 'mocked!'
@mock.patch('yardstick.benchmark.scenarios.networking.sfc.subprocess')
def test2_run_for_success(self, mock_subprocess, mock_openstack, mock_ssh):
# Mock a successfull SSH in Sfc.setup() and Sfc.run()
- mock_ssh.SSH().execute.return_value = (
+ mock_ssh.SSH.from_node().execute.return_value = (
0, 'vxlan_tool.py', 'succeeded timed out')
mock_openstack.get_an_IP.return_value = "127.0.0.1"
mock_subprocess.call.return_value = 'mocked!'
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
for node, node_dict in self.context_cfg["nodes"].items():
with SshManager(node_dict) as conn:
self.assertIsNotNone(conn)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
self.s.map_topology_to_infrastructure(self.context_cfg,
self.topology)
self.assertEqual("tg_trex_tpl.yaml",
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(1, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
self.assertRaises(IncorrectSetup,
self.s.map_topology_to_infrastructure,
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
self.assertRaises(IncorrectConfig,
self.s.map_topology_to_infrastructure,
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
del self.context_cfg['nodes']
self.assertRaises(IncorrectConfig, self.s._resolve_topology,
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, SYS_CLASS_NET + IP_ADDR_SHOW, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
tgen = mock.Mock(autospec=GenericTrafficGen)
tgen.traffic_finished = True
def test_vsperf_setup(self, mock_ssh, mock_subprocess):
p = vsperf.Vsperf(self.args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
mock_subprocess.call().execute.return_value = None
p.setup()
p = vsperf.Vsperf(self.args, self.ctx)
# setup() specific mocks
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
mock_subprocess.call().execute.return_value = None
p.setup()
p = vsperf.Vsperf(self.args, self.ctx)
# setup() specific mocks
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
mock_subprocess.call().execute.return_value = None
# run() specific mocks
- mock_ssh.SSH().execute.return_value = (0, '', '')
- mock_ssh.SSH().execute.return_value = (
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (
0, 'throughput_rx_fps\r\n14797660.000\r\n', '')
result = {}
p = vsperf.Vsperf(self.args, self.ctx)
# setup() specific mocks
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
mock_subprocess.call().execute.return_value = None
# run() specific mocks
- mock_ssh.SSH().execute.return_value = (1, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
result = {}
self.assertRaises(RuntimeError, p.run, result)
p = vsperf.Vsperf(self.args, self.ctx)
# setup() specific mocks
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
mock_subprocess.call().execute.return_value = None
# run() specific mocks
- mock_ssh.SSH().execute.return_value = (0, '', '')
- mock_ssh.SSH().execute.return_value = (1, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
result = {}
self.assertRaises(RuntimeError, p.run, result)
p = fio.Fio(args, self.ctx)
p.setup()
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
self.assertIsNotNone(p.client)
self.assertEqual(p.setup_done, True)
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['rw'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['read'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['write'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['rw'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['rw'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_fio_successful_bw_iops_sla(self, mock_ssh):
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['rw'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
p.run(result)
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
sample_output = self._read_sample_output(self.sample_output['rw'])
- mock_ssh.SSH().execute.return_value = (0, sample_output, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
self.assertRaises(AssertionError, p.run, result)
def test_fio_unsuccessful_script_error(self, mock_ssh):
p = fio.Fio(args, self.ctx)
result = {}
- p.client = mock_ssh.SSH()
+ p.client = mock_ssh.SSH.from_node()
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, p.run, result)
def _read_sample_output(self, file_name):
def test_capacity_successful_setup(self, mock_ssh):
c = storagecapacity.StorageCapacity(self.scn, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, '', '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
c.setup()
self.assertIsNotNone(c.client)
self.assertTrue(c.setup_done)
def test_capacity_disk_size_successful(self, mock_ssh):
c = storagecapacity.StorageCapacity(self.scn, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, DISK_SIZE_SAMPLE_OUTPUT, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, DISK_SIZE_SAMPLE_OUTPUT, '')
c.run(self.result)
expected_result = jsonutils.loads(
DISK_SIZE_SAMPLE_OUTPUT)
}
c = storagecapacity.StorageCapacity(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, BLOCK_SIZE_SAMPLE_OUTPUT, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, BLOCK_SIZE_SAMPLE_OUTPUT, '')
c.run(self.result)
expected_result = jsonutils.loads(
BLOCK_SIZE_SAMPLE_OUTPUT)
}
c = storagecapacity.StorageCapacity(args, self.ctx)
- mock_ssh.SSH().execute.return_value = (0, DISK_UTIL_RAW_OUTPUT, '')
+ mock_ssh.SSH.from_node().execute.return_value = (0, DISK_UTIL_RAW_OUTPUT, '')
c.run(self.result)
expected_result = jsonutils.loads(
DISK_UTIL_SAMPLE_OUTPUT)
def test_capacity_unsuccessful_script_error(self, mock_ssh):
c = storagecapacity.StorageCapacity(self.scn, self.ctx)
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
self.assertRaises(RuntimeError, c.run, self.result)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, {}, ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
self.resource_profile = \
ResourceProfile(self.VNFD['vnfd:vnfd-catalog']['vnfd'][0],
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
resource_profile = \
ResourceProfile(self.VNFD['vnfd:vnfd-catalog']['vnfd'][0],
[1, 2, 3])
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
resource_profile = \
ResourceProfile(self.VNFD['vnfd:vnfd-catalog']['vnfd'][0],
[1, 2, 3])
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
ping_traffic_gen = PingTrafficGen(vnfd)
self.assertEqual(ping_traffic_gen._queue, None)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
ping_traffic_gen = PingTrafficGen(vnfd)
ping_traffic_gen._queue = Queue()
ping_traffic_gen._queue.put({})
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
ping_traffic_gen = PingTrafficGen(vnfd)
self.assertEqual(None, ping_traffic_gen.instantiate({}, {}))
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
ping_traffic_gen = PingTrafficGen(vnfd)
self.assertEqual(None, ping_traffic_gen.listen_traffic({}))
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
self.sut = PingTrafficGen(vnfd)
self.sut.connection = mock.Mock()
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
self.sut = PingTrafficGen(vnfd)
self.sut.connection = mock.Mock()
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
flavor = ""
ping_traffic_gen = PingTrafficGen(vnfd)
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
ping_traffic_gen = PingTrafficGen(vnfd)
self.assertEqual(None, ping_traffic_gen.terminate())
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
self.assertIsNotNone(trex_traffic_gen._terminated)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
restult = trex_traffic_gen.collect_kpi()
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
self.assertEqual(None, trex_traffic_gen.listen_traffic({}))
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
trex_traffic_gen._start_server = mock.Mock(return_value=0)
mock.Mock(return_value=(1, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
scenario_cfg = {"tc": "tc_baremetal_rfc2544_ipv4_1flow_64B"}
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
self.assertEqual([0.8, 1.0],
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
self.assertEqual(None, trex_traffic_gen._start_server())
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
self.sut = TrexTrafficGenRFC(vnfd)
self.sut.connection = mock.Mock()
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
result = ['0x00', '0x00', '0x00', '0x00', '0x00', '0x01']
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
tg_rfc2544_trex.WAIT_TIME = 1
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
self.sut = TrexTrafficGenRFC(vnfd)
self.sut.connection = mock.Mock()
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
flavor = ""
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
self.assertEqual(None, trex_traffic_gen.terminate())
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
trex_traffic_gen = TrexTrafficGenRFC(vnfd)
client = mock.Mock(autospec=STLClient)
client.connect = mock.Mock(return_value=0)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertIsNotNone(trex_traffic_gen._terminated)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
trex_traffic_gen._queue.put({})
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertEqual(None, trex_traffic_gen.listen_traffic({}))
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertEqual(0, trex_traffic_gen.instantiate({}, {}))
mock.Mock(return_value=(1, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertRaises(RuntimeError,
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertEqual(None, trex_traffic_gen._start_server())
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
self.sut = TrexTrafficGen(vnfd)
self.sut.connection = mock.Mock()
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertEqual(None, trex_traffic_gen._generate_trex_cfg(vnfd))
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
result = ['0x00', '0x00', '0x00', '0x00', '0x00', '0x01']
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
self.sut = TrexTrafficGen(vnfd)
self.sut.connection = mock.Mock()
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(1, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
flavor = ""
trex_traffic_gen = TrexTrafficGen(vnfd)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(1, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertEqual(
None, trex_traffic_gen.setup_vnf_environment(ssh_mock))
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
trex_traffic_gen = TrexTrafficGen(vnfd)
self.assertEqual(None, trex_traffic_gen.terminate())
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
trex_traffic_gen = TrexTrafficGen(vnfd)
client = mock.Mock(autospec=STLClient)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
vpe_approx_vnf.resource = mock.Mock(autospec=ResourceProfile)
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
cmd = "quit"
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
vpe_approx_vnf.execute_command = \
mock.Mock(return_value=(0, "", ""))
ssh_mock.run = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
curr_path = os.path.dirname(os.path.abspath(__file__))
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
self.scenario_cfg['vnf_options'] = {'vpe': {'cfg': ""}}
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(1, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
self.scenario_cfg['vnf_options'] = {'vpe': {'cfg': ""}}
ssh_mock = mock.Mock(autospec=ssh.SSH)
ssh_mock.execute = \
mock.Mock(return_value=(0, "", ""))
- ssh.return_value = ssh_mock
+ ssh.from_node.return_value = ssh_mock
vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
vpe_approx_vnf = VpeApproxVnf(vnfd)
self.assertEqual(None,
self.assertEqual("kf", test_ssh.key_filename)
self.assertEqual("secret", test_ssh.password)
+ @mock.patch("yardstick.ssh.SSH._get_pkey")
+ def test_ssh_from_node(self, mock_ssh__get_pkey):
+ mock_ssh__get_pkey.return_value = "pkey"
+ node = {
+ "user": "root", "ip": "example.net", "ssh_port": 33,
+ "key_filename": "kf", "password": "secret"
+ }
+ test_ssh = ssh.SSH.from_node(node)
+ self.assertEqual("root", test_ssh.user)
+ self.assertEqual("example.net", test_ssh.host)
+ self.assertEqual(33, test_ssh.port)
+ self.assertEqual("kf", test_ssh.key_filename)
+ self.assertEqual("secret", test_ssh.password)
+
+ @mock.patch("yardstick.ssh.SSH._get_pkey")
+ def test_ssh_from_node_password_default(self, mock_ssh__get_pkey):
+ mock_ssh__get_pkey.return_value = "pkey"
+ node = {
+ "user": "root", "ip": "example.net", "ssh_port": 33,
+ "key_filename": "kf"
+ }
+ test_ssh = ssh.SSH.from_node(node)
+ self.assertEqual("root", test_ssh.user)
+ self.assertEqual("example.net", test_ssh.host)
+ self.assertEqual(33, test_ssh.port)
+ self.assertEqual("kf", test_ssh.key_filename)
+ self.assertIsNone(test_ssh.password)
+
+ @mock.patch("yardstick.ssh.SSH._get_pkey")
+ def test_ssh_from_node_ssh_port_default(self, mock_ssh__get_pkey):
+ mock_ssh__get_pkey.return_value = "pkey"
+ node = {
+ "user": "root", "ip": "example.net",
+ "key_filename": "kf", "password": "secret"
+ }
+ test_ssh = ssh.SSH.from_node(node)
+ self.assertEqual("root", test_ssh.user)
+ self.assertEqual("example.net", test_ssh.host)
+ self.assertEqual(ssh.SSH_PORT, test_ssh.port)
+ self.assertEqual("kf", test_ssh.key_filename)
+ self.assertEqual("secret", test_ssh.password)
+
+ @mock.patch("yardstick.ssh.SSH._get_pkey")
+ def test_ssh_from_node_key_filename_default(self, mock_ssh__get_pkey):
+ mock_ssh__get_pkey.return_value = "pkey"
+ node = {
+ "user": "root", "ip": "example.net", "ssh_port": 33,
+ "password": "secret"
+ }
+ test_ssh = ssh.SSH.from_node(node)
+ self.assertEqual("root", test_ssh.user)
+ self.assertEqual("example.net", test_ssh.host)
+ self.assertEqual(33, test_ssh.port)
+ self.assertIsNone(test_ssh.key_filename)
+ self.assertEqual("secret", test_ssh.password)
+
def test_construct_default(self):
self.assertEqual("root", self.test_client.user)
self.assertEqual("example.net", self.test_client.host)
if node is None:
raise SystemExit('No such node')
- user = node.get('user', 'ubuntu')
- ssh_port = node.get("ssh_port", ssh.DEFAULT_PORT)
- ip = node.get('ip')
- pwd = node.get('password')
- key_fname = node.get('key_filename', '/root/.ssh/id_rsa')
-
- if pwd is not None:
- LOG.debug("Log in via pw, user:%s, host:%s, password:%s",
- user, ip, pwd)
- self.client = ssh.SSH(user, ip, password=pwd, port=ssh_port)
- else:
- LOG.debug("Log in via key, user:%s, host:%s, key_filename:%s",
- user, ip, key_fname)
- self.client = ssh.SSH(user, ip, key_filename=key_fname,
- port=ssh_port)
+ self.client = ssh.SSH.from_node(node, defaults={'user': 'ubuntu'})
self.client.wait(timeout=600)
self.script = pkg_resources.resource_filename(
'yardstick.resources', 'scripts/install/' + target_script)
- deployment_user = deployment.get("user")
- deployment_ssh_port = deployment.get("ssh_port", ssh.DEFAULT_PORT)
deployment_ip = deployment.get("ip", None)
- deployment_password = deployment.get("password", None)
- deployment_key_filename = deployment.get("key_filename",
- "/root/.ssh/id_rsa")
if deployment_ip == "local":
- installer_ip = os.environ.get("INSTALLER_IP", None)
-
- if deployment_password is not None:
- self._login_via_password(deployment_user, installer_ip,
- deployment_password,
- deployment_ssh_port)
- else:
- self._login_via_key(self, deployment_user, installer_ip,
- deployment_key_filename,
- deployment_ssh_port)
+ self.client = ssh.SSH.from_node(deployment, overrides={
+ # host can't be None, fail if no INSTALLER_IP
+ 'ip': os.environ["INSTALLER_IP"],
+ })
else:
- if deployment_password is not None:
- self._login_via_password(deployment_user, deployment_ip,
- deployment_password,
- deployment_ssh_port)
- else:
- self._login_via_key(self, deployment_user, deployment_ip,
- deployment_key_filename,
- deployment_ssh_port)
+ self.client = ssh.SSH.from_node(deployment)
+ self.client.wait(timeout=600)
+
# copy script to host
remotepath = '~/%s.sh' % plugin_name
self.script = pkg_resources.resource_filename(
'yardstick.resources', 'scripts/remove/' + target_script)
- deployment_user = deployment.get("user")
- deployment_ssh_port = deployment.get("ssh_port", ssh.DEFAULT_PORT)
deployment_ip = deployment.get("ip", None)
- deployment_password = deployment.get("password", None)
- deployment_key_filename = deployment.get("key_filename",
- "/root/.ssh/id_rsa")
if deployment_ip == "local":
- installer_ip = os.environ.get("INSTALLER_IP", None)
-
- if deployment_password is not None:
- self._login_via_password(deployment_user, installer_ip,
- deployment_password,
- deployment_ssh_port)
- else:
- self._login_via_key(self, deployment_user, installer_ip,
- deployment_key_filename,
- deployment_ssh_port)
+ self.client = ssh.SSH.from_node(deployment, overrides={
+ # host can't be None, fail if no INSTALLER_IP
+ 'ip': os.environ["INSTALLER_IP"],
+ })
else:
- if deployment_password is not None:
- self._login_via_password(deployment_user, deployment_ip,
- deployment_password,
- deployment_ssh_port)
- else:
- self._login_via_key(self, deployment_user, deployment_ip,
- deployment_key_filename,
- deployment_ssh_port)
+ self.client = ssh.SSH.from_node(deployment)
+ self.client.wait(timeout=600)
# copy script to host
remotepath = '~/%s.sh' % plugin_name
LOG.info("copying script to host: %s", remotepath)
self.client._put_file_shell(self.script, remotepath)
- def _login_via_password(self, user, ip, password, ssh_port):
- LOG.info("Log in via pw, user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, password=password, port=ssh_port)
- self.client.wait(timeout=600)
-
- def _login_via_key(self, user, ip, key_filename, ssh_port):
- LOG.info("Log in via key, user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
- self.client.wait(timeout=600)
-
def _run(self, plugin_name):
"""Run installation script """
cmd = "sudo bash %s" % plugin_name + ".sh"
LOG.info("Executing command: %s", cmd)
- status, stdout, stderr = self.client.execute(cmd)
+ self.client.execute(cmd)
class PluginParser(object):
def setup(self):
LOG.debug("config:%s context:%s", self._config, self._context)
host = self._context.get(self._config['host'], None)
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
- self.host_ip = ip
+ self.host_ip = host['ip']
self.ipmi_ip = host.get("ipmi_ip", None)
self.ipmi_user = host.get("ipmi_user", "root")
self.jump_connection = None
if jump_host_name is not None:
host = self._context.get(jump_host_name, None)
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- pwd = host.get("pwd", None)
-
- LOG.debug("jump_host ip:%s user:%s", ip, user)
- self.jump_connection = ssh.SSH(user, ip, password=pwd,
- port=ssh_port)
+
+ LOG.debug("jump_host ip:%s user:%s", host['ip'], host['user'])
+ self.jump_connection = ssh.SSH.from_node(
+ host,
+ # why do we allow pwd for password?
+ defaults={"user": "root", "password": host.get("pwd")}
+ )
self.jump_connection.wait(timeout=600)
LOG.debug("ssh jump host success!")
if self.jump_connection is not None:
with open(self.recovery_script, "r") as stdin_file:
- exit_status, stdout, stderr = self.jump_connection.execute(
+ self.jump_connection.execute(
"/bin/bash -s {0} {1} {2} {3}".format(
self.ipmi_ip, self.ipmi_user, self.ipmi_pwd, "on"),
stdin=stdin_file)
else:
- exit_status, stdout = _execute_shell_command(
+ _execute_shell_command(
"/bin/bash -s {0} {1} {2} {3}".format(
self.ipmi_ip, self.ipmi_user, self.ipmi_pwd, "on"),
stdin=open(self.recovery_script, "r"))
def setup(self):
LOG.debug("config:%s context:%s", self._config, self._context)
host = self._context.get(self._config['host'], None)
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
def setup(self):
LOG.debug("config:%s context:%s", self._config, self._context)
host = self._context.get(self._config['host'], None)
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
node_name = self._config.get("host", None)
if node_name:
host = self._context[node_name]
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host,
+ defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
def setup(self):
host = self._context[self._config["host"]]
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
self.key = self._config["key"]
self.monitor_key = self._config["monitor_key"]
self.monitor_type = self._config["monitor_type"]
self.monitor_key)
self.monitor_script = self.get_script_fullpath(
self.monitor_cfg['monitor_script'])
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
def setup(self):
host = self._context[self._config["host"]]
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
self.check_script = self.get_script_fullpath(
def setup(self):
LOG.debug("config:%s context:%s", self._config, self._context)
host = self._context.get(self._config['host'], None)
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
def setup(self):
LOG.debug("config:%s context:%s", self._config, self._context)
host = self._context.get(self._config['host'], None)
- ip = host.get("ip", None)
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "root"})
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
CACHEstat.TARGET_SCRIPT)
host = self.context_cfg['host']
- user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get('ip', None)
- key_filename = host.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy scripts to host
nodes = self.context_cfg['nodes']
node = nodes.get('host', None)
- host_user = node.get('user', 'ubuntu')
- ssh_port = node.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = node.get('ip', None)
- host_pwd = node.get('password', 'root')
- LOG.debug("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
- port=ssh_port)
+ self.client = ssh.SSH.from_node(node, defaults={
+ "user": "ubuntu", "password": "root"
+ })
self.client.wait(timeout=600)
# copy script to host
def setup(self):
"""Scenario setup."""
host = self.context_cfg['host']
- user = host.get('user', 'ubuntu')
- ip = host.get('ip', None)
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- key_filename = host.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# Check if mpstat prog is installed
def _connect_host(self):
host = self.context_cfg["host"]
- user = host.get("user", "root")
- ip = host.get("ip", None)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- LOG.debug("user:%s, host:%s", user, ip)
- self.host = ssh.SSH(user, ip, key_filename=key_filename)
+ self.host = ssh.SSH.from_node(host, defaults={"user": "root"})
self.host.wait(timeout=600)
def _connect_guest(self):
host = self.context_cfg["host"]
- user = host.get("user", "root")
- ip = host.get("ip", None)
- ssh_port = host.get("ssh_port", 5555)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
-
- LOG.debug("user:%s, host:%s", user, ip)
- self.guest = ssh.SSH(user, ip, port=ssh_port,
- key_filename=key_filename)
+ # why port 5555?
+ self.guest = ssh.SSH.from_node(host,
+ defaults={
+ "user": "root", "ssh_port": 5555
+ })
self.guest.wait(timeout=600)
def _run_setup_cmd(self, client, cmd):
"yardstick.benchmark.scenarios.compute",
Lmbench.LATENCY_CACHE_SCRIPT)
host = self.context_cfg["host"]
- user = host.get("user", "ubuntu")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get("ip", None)
- key_filename = host.get('key_filename', "~/.ssh/id_rsa")
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy scripts to host
def setup(self):
"""Scenario setup."""
host = self.context_cfg['host']
- user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get('ip', None)
- key_filename = host.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
self.setup_done = True
self.target_script = pkg_resources.resource_filename(
'yardstick.benchmark.scenarios.compute', Perf.TARGET_SCRIPT)
host = self.context_cfg['host']
- user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get('ip', None)
- key_filename = host.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy script to host
nodes = self.context_cfg['nodes']
node = nodes.get('host1', None)
- host_user = node.get('user', 'ubuntu')
- host_ssh_port = node.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = node.get('ip', None)
- host_pwd = node.get('password', 'root')
- LOG.debug("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
- port=host_ssh_port)
+
+ self.client = ssh.SSH.from_node(node, defaults={
+ "user": "ubuntu", "password": "root"
+ })
self.client.wait(timeout=600)
self.setup_done = True
Ramspeed.RAMSPEED_MEM_SCRIPT)
host = self.context_cfg["host"]
- user = host.get("user", "ubuntu")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get("ip", None)
- key_filename = host.get('key_filename', "~/.ssh/id_rsa")
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy scripts to host
Unixbench.TARGET_SCRIPT)
host = self.context_cfg["host"]
- user = host.get("user", "ubuntu")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get("ip", None)
- key_filename = host.get('key_filename', "~/.ssh/id_rsa")
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy scripts to host
def setup(self):
host = self.context_cfg['host']
- host_user = host.get('user', 'ubuntu')
- host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
- host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
- target_user = target.get('user', 'ubuntu')
- target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- target_ip = target.get('ip', None)
- target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, target:%s", target_user, target_ip)
- self.target = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename,
- port=target_ssh_port)
+
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.target = ssh.SSH.from_node(target, defaults={"user": "ubuntu"})
self.target.wait(timeout=600)
- LOG.info("user:%s, host:%s", host_user, host_ip)
- self.host = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename, port=host_ssh_port)
+ LOG.info("user:%s, host:%s", host['user'], host['ip'])
+ self.host = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.host.wait(timeout=600)
cmd = "iperf3 -s -D"
'yardstick.benchmark.scenarios.networking',
Netperf.TARGET_SCRIPT)
host = self.context_cfg['host']
- host_user = host.get('user', 'ubuntu')
- host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
- host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
- target_user = target.get('user', 'ubuntu')
- target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- target_ip = target.get('ip', None)
- target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
# netserver start automatically during the vm boot
- LOG.info("user:%s, target:%s", target_user, target_ip)
- self.server = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename,
- port=target_ssh_port)
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(target, defaults={"user": "ubuntu"})
self.server.wait(timeout=600)
- LOG.info("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename,
- port=host_ssh_port)
+ LOG.info("user:%s, host:%s", host['user'], host['ip'])
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy script to host
'yardstick.benchmark.scenarios.networking',
NetperfNode.TARGET_SCRIPT)
host = self.context_cfg['host']
- host_user = host.get('user', 'ubuntu')
- host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
target = self.context_cfg['target']
- target_user = target.get('user', 'ubuntu')
- target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- target_ip = target.get('ip', None)
- self.target_ip = target.get('ip', None)
- host_password = host.get('password', None)
- target_password = target.get('password', None)
-
- LOG.info("host_pw:%s, target_pw:%s", host_password, target_password)
+ self.target_ip = target['ip']
+
# netserver start automatically during the vm boot
- LOG.info("user:%s, target:%s", target_user, target_ip)
- self.server = ssh.SSH(target_user, target_ip,
- password=target_password, port=target_ssh_port)
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(target, defaults={"user": "ubuntu"})
self.server.wait(timeout=600)
- LOG.info("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip,
- password=host_password, port=host_ssh_port)
+ LOG.info("user:%s, host:%s", host['user'], host['ip'])
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy script to host
def setup(self):
"""Scenario setup."""
host = self.context_cfg['host']
- user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get('ip', None)
- key_filename = host.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
self.setup_done = True
host = self.context_cfg['host']
if host is None:
raise RuntimeError('No right node.please check the configuration')
- host_user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
- host_pwd = host.get('password', None)
-
- LOG.debug("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy script to host
def setup(self):
"""scenario setup"""
host = self.context_cfg["host"]
- user = host.get("user", "ubuntu")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get("ip", None)
- key_filename = host.get('key_filename', "~/.ssh/id_rsa")
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
self.setup_done = True
self.target_script = pkg_resources.resource_filename(
'yardstick.benchmark.scenarios.networking', Ping.TARGET_SCRIPT)
host = self.context_cfg['host']
- user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get('ip', None)
- key_filename = host.get('key_filename', '/root/.ssh/id_rsa')
- password = host.get('password', None)
-
- if password is not None:
- LOG.info("Log in via pw, user:%s, host:%s, pw:%s",
- user, ip, password)
- self.connection = ssh.SSH(user, ip, password=password,
- port=ssh_port)
- else:
- LOG.info("Log in via key, user:%s, host:%s, key_filename:%s",
- user, ip, key_filename)
- self.connection = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.connection = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.connection.wait(timeout=600)
def _ssh_host(self, node_name):
# ssh host
node = self.nodes.get(node_name, None)
- user = node.get('user', 'ubuntu')
- ssh_port = node.get("ssh_port", ssh.DEFAULT_PORT)
- ip = node.get('ip', None)
- pwd = node.get('password', None)
- key_fname = node.get('key_filename', '/root/.ssh/id_rsa')
- if pwd is not None:
- LOG.debug("Log in via pw, user:%s, host:%s, password:%s",
- user, ip, pwd)
- self.client = ssh.SSH(user, ip, password=pwd, port=ssh_port)
- else:
- LOG.debug("Log in via key, user:%s, host:%s, key_filename:%s",
- user, ip, key_fname)
- self.client = ssh.SSH(user, ip, key_filename=key_fname,
- port=ssh_port)
+ self.client = ssh.SSH.from_node(node, defaults={"user": "ubuntu"})
self.client.wait(timeout=60)
def _pre_setup(self):
'yardstick.benchmark.scenarios.networking',
Pktgen.TARGET_SCRIPT)
host = self.context_cfg['host']
- host_user = host.get('user', 'ubuntu')
- host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
- host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
- target_user = target.get('user', 'ubuntu')
- target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- target_ip = target.get('ip', None)
- target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
-
- LOG.info("user:%s, target:%s", target_user, target_ip)
- self.server = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename,
- port=target_ssh_port)
+
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(target, defaults={"user": "ubuntu"})
self.server.wait(timeout=600)
- LOG.info("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename,
- port=host_ssh_port)
+ LOG.info("user:%s, host:%s", host['user'], host['ip'])
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy script to host
'yardstick.benchmark.scenarios.networking',
PktgenDPDKLatency.TESTPMD_SCRIPT)
host = self.context_cfg['host']
- host_user = host.get('user', 'ubuntu')
- host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
- host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
- target_user = target.get('user', 'ubuntu')
- target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- target_ip = target.get('ip', None)
- target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
- LOG.info("user:%s, target:%s", target_user, target_ip)
- self.server = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename,
- port=target_ssh_port)
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(target, defaults={"user": "ubuntu"})
self.server.wait(timeout=600)
# copy script to host
self.server._put_file_shell(self.testpmd_script, '~/testpmd_fwd.sh')
- LOG.info("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename,
- port=host_ssh_port)
+ LOG.info("user:%s, host:%s", host['user'], host['ip'])
+ self.client = ssh.SSH.from_node(host, defaults={"user": "ubuntu"})
self.client.wait(timeout=600)
# copy script to host
subprocess.call(cmd_tacker, shell=True)
target = self.context_cfg['target']
- target_user = target.get('user', 'root')
- target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- target_pwd = target.get('password', 'opnfv')
- target_ip = target.get('ip', None)
""" webserver start automatically during the vm boot """
- LOG.info("user:%s, target:%s", target_user, target_ip)
- self.server = ssh.SSH(target_user, target_ip, password=target_pwd,
- port=target_ssh_port)
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(target, defaults={
+ "user": "root", "password": "opnfv"
+ })
self.server.wait(timeout=600)
self.server._put_file_shell(self.server_script, '~/server.sh')
cmd_server = "sudo bash server.sh"
ips = sfc_openstack.get_an_IP()
target = self.context_cfg['target']
- SF1_user = target.get('user', 'root')
- SF1_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- SF1_pwd = target.get('password', 'opnfv')
- SF1_ip = ips[0]
-
- LOG.info("user:%s, host:%s", SF1_user, SF1_ip)
- self.server = ssh.SSH(SF1_user, SF1_ip, password=SF1_pwd,
- port=SF1_ssh_port)
+
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(
+ target,
+ defaults={"user": "root", "password": "opnfv"},
+ # we must override ip
+ overrides={"ip": ips[0]}
+ )
self.server.wait(timeout=600)
cmd_SF1 = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -b 80 &")
LOG.debug("Starting HTTP firewall in SF1")
- status, stdout, stderr = self.server.execute(cmd_SF1)
+ self.server.execute(cmd_SF1)
result = self.server.execute("ps lax | grep python")
if "vxlan_tool.py" in result[1]: # pragma: no cover
LOG.debug("HTTP firewall started")
- SF2_user = target.get('user', 'root')
- SF2_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
- SF2_pwd = target.get('password', 'opnfv')
- SF2_ip = ips[1]
-
- LOG.info("user:%s, host:%s", SF2_user, SF2_ip)
- self.server = ssh.SSH(SF2_user, SF2_ip, password=SF2_pwd,
- port=SF2_ssh_port)
+ LOG.info("user:%s, target:%s", target['user'], target['ip'])
+ self.server = ssh.SSH.from_node(
+ target,
+ defaults={"user": "root", "password": "opnfv"},
+ # we must override ip
+ overrides={"ip": ips[1]}
+ )
self.server.wait(timeout=600)
cmd_SF2 = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -b 22 &")
LOG.debug("Starting SSH firewall in SF2")
- status, stdout, stderr = self.server.execute(cmd_SF2)
+ self.server.execute(cmd_SF2)
result = self.server.execute("ps lax | grep python")
if "vxlan_tool.py" in result[1]: # pragma: no cover
def run(self, result):
""" Creating client and server VMs to perform the test"""
host = self.context_cfg['host']
- host_user = host.get('user', 'root')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- host_pwd = host.get('password', 'opnfv')
- host_ip = host.get('ip', None)
-
- LOG.info("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
- port=ssh_port)
+
+ LOG.info("user:%s, host:%s", host['user'], host['ip'])
+ self.client = ssh.SSH.from_node(host, defaults={
+ "user": "root", "password": "opnfv"
+ })
self.client.wait(timeout=600)
if not self.setup_done: # pragma: no cover
returns -> ssh connection ready to be used
"""
try:
- ssh_port = self.node.get("ssh_port", ssh.DEFAULT_PORT)
- self.conn = ssh.SSH(user=self.node["user"],
- host=self.node["ip"],
- password=self.node["password"],
- port=ssh_port)
+ self.conn = ssh.SSH.from_node(self.node)
self.conn.wait()
- except (SSHError) as error:
+ except SSHError as error:
LOG.info("connect failed to %s, due to %s", self.node["ip"], error)
# self.conn defaults to None
return self.conn
def setup(self):
"""scenario setup"""
vsperf = self.context_cfg['host']
- vsperf_user = vsperf.get('user', 'ubuntu')
- vsperf_ssh_port = vsperf.get('ssh_port', ssh.DEFAULT_PORT)
- vsperf_password = vsperf.get('password', 'ubuntu')
- vsperf_ip = vsperf.get('ip', None)
# add trafficgen interfaces to the external bridge
if self.tg_port1:
(self.br_ex, self.tg_port2), shell=True)
# copy vsperf conf to VM
- LOG.info("user:%s, host:%s", vsperf_user, vsperf_ip)
- self.client = ssh.SSH(vsperf_user, vsperf_ip,
- password=vsperf_password, port=vsperf_ssh_port)
+ self.client = ssh.SSH.from_node(vsperf, defaults={
+ "user": "ubuntu", "password": "ubuntu"
+ })
# traffic generation could last long
self.client.wait(timeout=1800)
"yardstick.benchmark.scenarios.storage",
Fio.TARGET_SCRIPT)
host = self.context_cfg["host"]
- user = host.get("user", "root")
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- ip = host.get("ip", None)
- key_filename = host.get("key_filename", "~/.ssh/id_rsa")
-
- LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={"user": "root"})
self.client.wait(timeout=600)
# copy script to host
host = self.context_cfg['host']
if host is None:
raise RuntimeError('No right node.Please check the configuration')
- host_user = host.get('user', 'ubuntu')
- ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
- host_ip = host.get('ip', None)
- host_pwd = host.get('password', 'root')
- LOG.debug("user:%s, host:%s", host_user, host_ip)
-
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
- port=ssh_port)
+
+ self.client = ssh.SSH.from_node(host, defaults={
+ "user": "ubuntu", "password": "root"
+ })
self.client.wait(timeout=600)
# copy script to host
self.cores = cores
mgmt_interface = vnfd.get("mgmt-interface")
- user = mgmt_interface.get("user")
- passwd = mgmt_interface.get("password")
- ip_addr = mgmt_interface.get("ip")
- self.vnfip = mgmt_interface.get("host", ip_addr)
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- self.connection = ssh.SSH(user, self.vnfip,
- password=passwd, port=ssh_port)
+ # why the host or ip?
+ self.vnfip = mgmt_interface.get("host", mgmt_interface["ip"])
+ self.connection = ssh.SSH.from_node(mgmt_interface,
+ overrides={"ip": self.vnfip})
+
self.connection.wait()
def check_if_sa_running(self, process):
self._traffic_process = None
mgmt_interface = vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- LOG.debug("Connecting to %s", mgmt_interface["ip"])
-
- self.connection = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(mgmt_interface)
self.connection.wait()
def _bind_device_kernel(self, connection):
def _traffic_runner(self, traffic_profile, filewrapper):
mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- self.connection = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+ self.connection = ssh.SSH.from_node(mgmt_interface)
self.connection.wait()
external_interface = self.vnfd["vdu"][0]["external-interface"]
virtual_interface = external_interface[0]["virtual-interface"]
self.my_ports = None
mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- self.connection = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+
+ self.connection = ssh.SSH.from_node(mgmt_interface)
self.connection.wait()
@classmethod
def _start_server(self):
mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- _server = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+
+ _server = ssh.SSH.from_node(mgmt_interface)
_server.wait()
_server.execute("fuser -n tcp %s %s -k > /dev/null 2>&1" %
self.my_ports = None
self.client_started = multiprocessing.Value('i', 0)
- mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- self.connection = ssh.SSH(mgmt_interface["user"],
- mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+ mgmt_interface = vnfd["mgmt-interface"]
+
+ self.connection = ssh.SSH.from_node(mgmt_interface)
self.connection.wait()
@classmethod
def _start_server(self):
mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- _server = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+
+ _server = ssh.SSH.from_node(mgmt_interface)
_server.wait()
_server.execute("fuser -n tcp %s %s -k > /dev/null 2>&1" %
def instantiate(self, scenario_cfg, context_cfg):
vnf_cfg = scenario_cfg['vnf_options']['vpe']['cfg']
- mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- self.connection = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+ mgmt_interface = self.vnfd["mgmt-interface"]
+ self.connection = ssh.SSH.from_node(mgmt_interface)
- self.connection.wait()
+ self.tc_file_name = '{0}.yaml'.format(scenario_cfg['tc'])
self.setup_vnf_environment(self.connection)
def _run_vpe(self, filewrapper, vnf_cfg):
mgmt_interface = self.vnfd["mgmt-interface"]
- ssh_port = mgmt_interface.get("ssh_port", ssh.DEFAULT_PORT)
- self.connection = ssh.SSH(mgmt_interface["user"], mgmt_interface["ip"],
- password=mgmt_interface["password"],
- port=ssh_port)
+
+ self.connection = ssh.SSH.from_node(mgmt_interface)
self.connection.wait()
+
interfaces = self.vnfd["vdu"][0]['external-interface']
port0_ip = ipaddress.ip_interface(six.text_type(
"%s/%s" % (interfaces[0]["virtual-interface"]["local_ip"],
:return: Complete VNF Descriptor that will be taken
as input for GenericVNF.__init__
"""
+ # get is unused as global method inside template
node["get"] = get
+ # Set Node details to default if not defined in pod file
rendered_vnfd = TaskTemplate.render(vnf_model, **node)
# This is done to get rid of issues with serializing node
del node["get"]
import re
import logging
+
import paramiko
+from chainmap import ChainMap
from oslo_utils import encodeutils
from scp import SCPClient
import six
-DEFAULT_PORT = 22
+SSH_PORT = paramiko.config.SSH_PORT
class SSHError(Exception):
class SSH(object):
"""Represent ssh connection."""
- def __init__(self, user, host, port=DEFAULT_PORT, pkey=None,
+ def __init__(self, user, host, port=SSH_PORT, pkey=None,
key_filename=None, password=None, name=None):
"""Initialize SSH client.
self.user = user
self.host = host
+ # everybody wants to debug this in the caller, do it here instead
+ self.log.debug("user:%s host:%s", user, host)
+
# we may get text port from YAML, convert to int
self.port = int(port)
self.pkey = self._get_pkey(pkey) if pkey else None
else:
logging.getLogger("paramiko").setLevel(logging.WARN)
+ @classmethod
+ def from_node(cls, node, overrides=None, defaults=None):
+ if overrides is None:
+ overrides = {}
+ if defaults is None:
+ defaults = {}
+ params = ChainMap(overrides, node, defaults)
+ return cls(
+ user=params['user'],
+ host=params['ip'],
+ # paramiko doesn't like None default, requires SSH_PORT default
+ port=params.get('ssh_port', SSH_PORT),
+ pkey=params.get('pkey'),
+ key_filename=params.get('key_filename'),
+ password=params.get('password'),
+ name=params.get('name'))
+
def _get_pkey(self, key):
if isinstance(key, six.string_types):
key = six.moves.StringIO(key)
Code Review / yardstick.git / commitdiff