class TestSharedTarget(JobTestCaseWithHost):
mock_servers = {
"pair1": {
"fqdn": "pair1.mycompany.com",
"nodename": "test01.pair1.mycompany.com",
"nids": [Nid.Nid("192.168.0.1", "tcp", 0)],
},
"pair2": {
"fqdn": "pair2.mycompany.com",
"nodename": "test02.pair2.mycompany.com",
"nids": [Nid.Nid("192.168.0.2", "tcp", 0)],
},
}
def setUp(self):
super(TestSharedTarget, self).setUp()
(mgt, fs, mdt, ost) = create_simple_fs()
self.mgt = mgt
self.assertEqual(
ManagedMgs.objects.get(pk=self.mgt.pk).state, "unmounted")
def test_clean_setup(self):
# Start it normally the way the API would on creation
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, "mounted")
self.assertEqual(
ManagedTarget.objects.get(pk=self.mgt.pk).state, "mounted")
def setUp(self):
super(TestHostResource, self).setUp()
MockAgentRpc.mock_servers = {
"foo": {
"fqdn": "foo.mycompany.com",
"nodename": "test01.foo.mycompany.com",
"nids": [Nid.Nid("192.168.0.19", "tcp", 0)],
},
"bar": {
"fqdn": "bar.mycompany.com",
"nodename": "test01.bar.mycompany.com",
"nids": [Nid.Nid("192.168.0.91", "tcp", 0)],
},
}
def setUp(self):
super(TestHostResource, self).setUp()
MockAgentRpc.mock_servers = {
'foo': {
'fqdn': 'foo.mycompany.com',
'nodename': 'test01.foo.mycompany.com',
'nids': [Nid.Nid("192.168.0.19", "tcp", 0)]
},
'bar': {
'fqdn': 'bar.mycompany.com',
'nodename': 'test01.bar.mycompany.com',
'nids': [Nid.Nid("192.168.0.91", "tcp", 0)]
}
}
def setUp(self):
super(TestHostResource, self).setUp()
self.host = {
'fqdn': 'foo.mycompany.com',
'nodename': 'foo.mycompany.com',
'nids': [Nid.Nid("192.168.0.19", "tcp", 0)]
}
MockAgentRpc.mock_servers = {'foo': self.host}
self.api_post('/api/host/',
data={
'address': 'foo',
'server_profile': '/api/server_profile/test_profile/'
})
self._lnetinfo = self._get_lnet_info(self.host)
# Sanity check.
self.assertEqual(self._lnetinfo.nids,
self._lnetinfo.lnet_configuration['nids'])
mock.patch(
'chroma_core.services.job_scheduler.job_scheduler_client.JobSchedulerClient.update_nids',
new=mock.Mock(side_effect=mock_update_nids)).start()
self.addCleanup(mock.patch.stopall)
class JobTestCaseWithHost(JobTestCase):
mock_servers = {
"myaddress": {
"fqdn": "myaddress.mycompany.com",
"nodename": "test01.myaddress.mycompany.com",
"nids": [Nid.Nid("192.168.0.1", "tcp", 0)],
}
}
@classmethod
def setUpTestData(cls):
super(JobTestCaseWithHost, cls).setUpTestData()
cls.hosts = []
for address, info in cls.mock_servers.items():
host = synthetic_host(address=address,
fqdn=info["fqdn"],
nids=info["nids"],
nodename=info["nodename"])
cls.hosts.append(host)
def setUp(self):
super(JobTestCaseWithHost, self).setUp()
for host in self.hosts:
host.refresh_from_db()
# Handy if you're only using one
self.host = self.hosts[0]
class TestOneHost(JobTestCase):
mock_servers = {
"myaddress": {
"fqdn": "myaddress.mycompany.com",
"nodename": "test01.myaddress.mycompany.com",
"nids": [Nid.Nid("192.168.0.1", "tcp", 0)],
}
}
def setUp(self):
super(TestOneHost, self).setUp()
connection.use_debug_cursor = True
def tearDown(self):
super(TestOneHost, self).tearDown()
connection.use_debug_cursor = False
def test_one_host(self):
try:
dbperf.enabled = True
with dbperf("create_from_string"):
host = synthetic_host("myaddress")
with dbperf("set_state"):
self.set_state_delayed([(host, "managed")])
with dbperf("run_next"):
self.set_state_complete()
self.assertState(host, "managed")
finally:
dbperf.enabled = False
def _host_with_nids(self, address):
host_nids = {
"primary-mgs": [Nid.Nid("1.2.3.4", "tcp", 0)],
"failover-mgs": [Nid.Nid("1.2.3.5", "tcp", 5)],
"primary-mgs-twonid": [Nid.Nid("1.2.3.4", "tcp", 0), Nid.Nid("4.3.2.1", "tcp", 1)],
"failover-mgs-twonid": [Nid.Nid("1.2.3.5", "tcp", 5), Nid.Nid("4.3.2.2", "tcp", 1)],
"othernode": [Nid.Nid("1.2.3.6", "tcp", 0), Nid.Nid("4.3.2.3", "tcp", 1)],
}
return synthetic_host(address, host_nids[address])
def _host_with_nids(self, address):
host_nids = {
'primary-mgs': [Nid.Nid('1.2.3.4', 'tcp', 0)],
'failover-mgs': [Nid.Nid('1.2.3.5', 'tcp', 5)],
'primary-mgs-twonid': [Nid.Nid('1.2.3.4', 'tcp', 0), Nid.Nid('4.3.2.1', 'tcp', 1)],
'failover-mgs-twonid': [Nid.Nid('1.2.3.5', 'tcp', 5), Nid.Nid('4.3.2.2', 'tcp', 1)],
'othernode': [Nid.Nid('1.2.3.6', 'tcp', 0), Nid.Nid('4.3.2.3', 'tcp', 1)]
}
return synthetic_host(address, host_nids[address])
def run(self, kwargs):
host_id = kwargs["host_id"]
fqdn = kwargs["fqdn"]
nid_updates = kwargs["config_changes"]["nid_updates"]
nid_deletes = kwargs["config_changes"]["nid_deletes"]
modprobe_entries = []
nid_tuples = []
network_interfaces = NetworkInterface.objects.filter(host__id=host_id)
lnet_configuration = LNetConfiguration.objects.get(host__id=host_id)
for network_interface in network_interfaces:
# See if we have deleted the nid for this network interface or
# see if we have a new configuration for this if we do then it
# will replace the current configuration.
#
# The int will have become a string - we should use a PickledObjectField really.
if str(network_interface.id) in nid_deletes:
nid = None
elif str(network_interface.id) in nid_updates:
nid = Nid(
network_interface=network_interface,
lnet_configuration=lnet_configuration,
lnd_network=nid_updates[str(
network_interface.id)]["lnd_network"],
lnd_type=nid_updates[str(
network_interface.id)]["lnd_type"],
)
else:
try:
nid = Nid.objects.get(network_interface=network_interface)
except ObjectDoesNotExist:
nid = None
pass
if nid is not None:
modprobe_entries.append(nid.modprobe_entry)
nid_tuples.append(nid.to_tuple)
self.invoke_agent_expect_result(
fqdn,
"configure_lnet",
{
"lnet_configuration": {
"state": lnet_configuration.state,
"modprobe_entries": modprobe_entries,
"network_interfaces": nid_tuples,
}
},
)
def test_log_links(self):
"""Test that log viewer only displays valid links."""
self.host = synthetic_host("myserver-with-nids",
[Nid.Nid("192.168.0.1", "tcp", 0)])
self.create_simple_filesystem(self.host)
fake_log_message("192.168.0.1@tcp testfs-MDT0000")
response = self.api_client.get("/api/log/")
event, = self.deserialize(response)["objects"]
self.assertEqual(len(event["substitutions"]), 2)
self.host.state = "removed"
self.host.save()
self.mdt.not_deleted = False
self.mdt.save()
response = self.api_client.get("/api/log/")
event, = self.deserialize(response)["objects"]
self.assertEqual(len(event["substitutions"]), 0)
def parse_synthentic_device_info(host_id, data):
""" Parses the data returned from plugins for integration test purposes. On does lnet data because
at present that is all we need. """
# This creates nid tuples so it can use synthetic_host_create_lnet_configuration to do the
# actual writes to the database
for plugin, device_data in data.items():
if plugin == "linux_network":
if len(device_data["lnet"]["nids"]) > 0:
nid_tuples = []
for name, nid in device_data["lnet"]["nids"].items():
nid_tuples.append(Nid.Nid(nid["nid_address"], nid["lnd_type"], nid["lnd_network"]))
else:
nid_tuples = None
synthetic_lnet_configuration(ManagedHost.objects.get(id=host_id), nid_tuples)
def run(self, kwargs):
host = kwargs['host']
nid_updates = kwargs['config_changes']['nid_updates']
nid_deletes = kwargs['config_changes']['nid_deletes']
modprobe_entries = []
nid_tuples = []
network_interfaces = NetworkInterface.objects.filter(host=host)
lnet_configuration = LNetConfiguration.objects.get(host=host)
for network_interface in network_interfaces:
# See if we have deleted the nid for this network interface or
# see if we have a new configuration for this if we do then it
# will replace the current configuration.
#
# The int will have become a string - we should use a PickledObjectField really.
if str(network_interface.id) in nid_deletes:
nid = None
elif str(network_interface.id) in nid_updates:
nid = Nid(network_interface=network_interface,
lnet_configuration=lnet_configuration,
lnd_network=nid_updates[str(
network_interface.id)]['lnd_network'],
lnd_type=nid_updates[str(
network_interface.id)]['lnd_type'])
else:
try:
nid = Nid.objects.get(network_interface=network_interface)
except ObjectDoesNotExist:
nid = None
pass
if nid is not None:
modprobe_entries.append(nid.modprobe_entry)
nid_tuples.append(nid.to_tuple)
self.invoke_agent_expect_result(
host, "configure_lnet", {
'lnet_configuration': {
'state': lnet_configuration.state,
'modprobe_entries': modprobe_entries,
'network_interfaces': nid_tuples
}
})
def step(context, name):
import os
import json
from chroma_core.models import Nid
from tests.unit.chroma_core.helpers import MockAgentRpc
# Skip setup if it was already done in a previous scenario.
if len(MockAgentRpc.mock_servers) > 0:
return
path = os.path.join(os.path.dirname(__file__),
"../../../../sample_data/%s.json" % name)
with open(path) as fh:
data = json.load(fh)
for host in data["hosts"]:
host["nids"] = [Nid.split_nid_string(n) for n in host["nids"]]
MockAgentRpc.mock_servers[host["address"]] = host
class JobTestCaseWithHost(JobTestCase):
mock_servers = {
"myaddress": {
"fqdn": "myaddress.mycompany.com",
"nodename": "test01.myaddress.mycompany.com",
"nids": [Nid.Nid("192.168.0.1", "tcp", 0)],
}
}
def setUp(self):
super(JobTestCaseWithHost, self).setUp()
self.hosts = []
for address, info in self.mock_servers.items():
host = synthetic_host(address=address,
fqdn=info["fqdn"],
nids=info["nids"],
nodename=info["nodename"])
self.hosts.append(host)
# Handy if you're only using one
self.host = self.hosts[0]
class JobTestCaseWithHost(JobTestCase):
mock_servers = {
'myaddress': {
'fqdn': 'myaddress.mycompany.com',
'nodename': 'test01.myaddress.mycompany.com',
'nids': [Nid.Nid("192.168.0.1", "tcp", 0)]
}
}
def setUp(self):
super(JobTestCaseWithHost, self).setUp()
self.hosts = []
for address, info in self.mock_servers.items():
host = synthetic_host(address=address,
fqdn=info['fqdn'],
nids=info['nids'],
nodename=info['nodename'])
self.hosts.append(host)
# Handy if you're only using one
self.host = self.hosts[0]
def setUp(self):
super(TestHostResource, self).setUp()
self.host = {
"fqdn": "foo.mycompany.com",
"nodename": "foo.mycompany.com",
"nids": [Nid.Nid("192.168.0.19", "tcp", 0)],
}
MockAgentRpc.mock_servers = {"foo": self.host}
self.api_post("/api/host/", data={"address": "foo", "server_profile": "/api/server_profile/test_profile/"})
self._lnetinfo = self._get_lnet_info(self.host)
# Sanity check.
self.assertEqual(self._lnetinfo.nids, self._lnetinfo.lnet_configuration["nids"])
mock.patch(
"chroma_core.services.job_scheduler.job_scheduler_client.JobSchedulerClient.update_nids",
new=mock.Mock(side_effect=mock_update_nids),
).start()
self.addCleanup(mock.patch.stopall)
def lnd_types(self):
return Nid.lnd_types_for_network_type(self.type)
class TestRegistration(IMLUnitTestCase):
"""API unit tests for functionality used only by the agent"""
mock_servers = {
"mynewhost": {
"fqdn": "mynewhost.mycompany.com",
"nodename": "test01.mynewhost.mycompany.com",
"nids": [Nid.Nid("192.168.0.1", "tcp", 0)],
}
}
def setUp(self):
super(TestRegistration, self).setUp()
load_default_profile()
self.old_create_host = JobSchedulerClient.create_host
JobSchedulerClient.create_host = mock.Mock(
side_effect=lambda *args, **kwargs: (
synthetic_host("mynewhost", **self.mock_servers["mynewhost"]),
mock.Mock(id="bar"),
))
ValidatedClientView.valid_certs = {}
def tearDown(self):
JobSchedulerClient.create_host = self.old_create_host
def test_version(self):
host_info = self.mock_servers["mynewhost"]
with timed("csr", 10):
data = {
"fqdn": host_info["fqdn"],
"nodename": host_info["nodename"],
"version": "1.0",
"capabilities": ["manage_targets"],
"address": "mynewhost",
"csr": generate_csr(host_info["fqdn"]),
}
with patch(settings, VERSION="2.0"):
# Try with a mis-matched version
token = RegistrationToken.objects.create(
profile=ServerProfile.objects.get())
with timed("register fail", 10):
response = Client().post("/agent/register/%s/" % token.secret,
data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
# Try with a matching version
token = RegistrationToken.objects.create(
profile=ServerProfile.objects.get())
settings.VERSION = "1.1"
with timed("register pass", 10):
response = Client().post("/agent/register/%s/" % token.secret,
data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
content = json.loads(response.content)
# reregistration should fail with unknown serial
data = {"address": "mynewhost", "fqdn": "mynewhost.newcompany.com"}
headers = {
"HTTP_X_SSL_CLIENT_NAME": host_info["fqdn"],
"HTTP_X_SSL_CLIENT_SERIAL": ""
}
response = Client().post("/agent/reregister/",
data=json.dumps(data),
content_type="application/json",
**headers)
self.assertEqual(response.status_code, 403)
# reregistration should update host's domain name
headers["HTTP_X_SSL_CLIENT_SERIAL"] = Crypto().get_serial(
content["certificate"])
response = Client().post("/agent/reregister/",
data=json.dumps(data),
content_type="application/json",
**headers)
self.assertEqual(response.status_code, 200)
host = ManagedHost.objects.get(id=content["host_id"])
self.assertEqual(host.fqdn, data["fqdn"])
def load_filesystem_from_json(data):
# Since this is only ever used for the behave tests, and the behave tests
# are slated to be decommissioned at some point, we're just going to
# abandon all pretense that we might be loading a non-synthetic cluster.
from chroma_core.services.job_scheduler.job_scheduler_client import JobSchedulerClient
from tests.unit.chroma_core.helpers import synthetic_volume
from chroma_core.models import ManagedMgs, VolumeNode
from chroma_core.lib.cache import ObjectCache
from chroma_core.models import ManagedHost, ManagedTarget, ManagedTargetMount
from chroma_core.models import Nid
from tests.unit.chroma_core.helpers import synthetic_host
lookup = defaultdict(dict)
for host_info in data["hosts"]:
from tests.unit.chroma_core.helpers import MockAgentRpc
mock_host_info = MockAgentRpc.mock_servers[host_info["address"]]
# host, command = JobSchedulerClient.create_host(mock_host_info['fqdn'], mock_host_info['nodename'], ['manage_targets'], address = host_info['address'])
nids = [Nid.split_nid_string(n) for n in mock_host_info["nids"]]
# update mock_servers with list of Nid objects
MockAgentRpc.mock_servers[host_info["address"]]["nids"] = nids
host = synthetic_host(mock_host_info["address"],
nids=nids,
fqdn=mock_host_info["fqdn"],
nodename=mock_host_info["nodename"])
ObjectCache.add(ManagedHost, host)
host.state = "managed"
host.save()
lookup["hosts"][host_info["address"]] = host
def _create_volume_for_mounts(mounts):
# The test data doesn't give us a serial, so mung one out of the device paths
# on the basis that they're iSCSI-style
serial = mounts[0]["device_node"].split("/")[-1]
volume = synthetic_volume(serial=serial)
for mount in mounts:
VolumeNode.objects.create(host=lookup["hosts"][mount["host"]],
path=mount["device_node"],
primary=mount["primary"],
volume=volume)
return volume
for mgs_info in data["mgss"]:
volume = _create_volume_for_mounts(mgs_info["mounts"])
target, target_mounts = ManagedMgs.create_for_volume(volume.id)
target.uuid = uuid.uuid4().__str__()
target.ha_label = "%s_%s" % (target.name, uuid.uuid4().__str__()[0:6])
ObjectCache.add(ManagedTarget, target.managedtarget_ptr)
for tm in target_mounts:
ObjectCache.add(ManagedTargetMount, tm)
lookup["mgt"][mgs_info["mounts"][0]["host"]] = target
for fs_info in data["filesystems"]:
fs_bundle = {
"name": fs_info["name"],
"mgt": {
"id": lookup["mgt"][fs_info["mgs"]].id
},
"mdts": [],
"osts": [],
"conf_params": {},
}
for mdt_info in fs_info["mdts"]:
volume = _create_volume_for_mounts(mdt_info["mounts"])
# Although we create multiple volumes for the mdt, initially only add a single volume, once delete of MDT
# is possible we can add them all and then delete before adding. This code is structured for that fixed case.
if not fs_bundle["mdts"]:
fs_bundle["mdts"].append({
"volume_id": volume.id,
"conf_params": {}
})
for ost_info in fs_info["osts"]:
volume = _create_volume_for_mounts(ost_info["mounts"])
fs_bundle["osts"].append({
"volume_id": volume.id,
"conf_params": {}
})
fs, command = JobSchedulerClient.create_filesystem(fs_bundle)
def test_combined_mgs_mdt(self, invoke):
invoke.return_value = '{"Ok": []}'
def fixture_glob(g):
return glob.glob(
os.path.join(os.path.dirname(__file__),
"fixtures/test_combined_mgs_mdt", g))
for path in fixture_glob("*_nid.txt"):
address = os.path.basename(path).split("_")[0]
nids = [
Nid.split_nid_string(l.strip())
for l in open(path).readlines()
]
synthetic_host(address, nids)
host_data = {}
for path in fixture_glob("*detect_scan_output.txt"):
address = os.path.basename(path).split("_")[0]
data = json.load(open(path))["result"]
host_data[ManagedHost.objects.get(address=address)] = data
# Simplified volume construction:
# * Assume all device paths referenced in detection exist
# * Assume all devices visible on all hosts
# * Assume device node paths are identical on all hosts
devpaths = set()
for host, data in host_data.items():
for lt in data["local_targets"]:
for d in lt["device_paths"]:
if not d in devpaths:
devpaths.add(d)
volume = Volume.objects.create()
for host in host_data.keys():
VolumeNode.objects.create(volume=volume,
path=d,
host=host)
def _detect_scan_device_plugin(host, command, args=None):
self.assertIn(command, ["detect_scan", "device_plugin"])
if command == "detect_scan":
return host_data[host]
raise AgentException(
host, command, args,
"No device plugin data available in unit tests")
job = DetectTargetsJob.objects.create()
with mock.patch("chroma_core.lib.job.Step.invoke_agent",
new=mock.Mock(side_effect=_detect_scan_device_plugin)):
with mock.patch("chroma_core.models.Volume.storage_resource"):
synchronous_run_job(job)
self.assertEqual(ManagedFilesystem.objects.count(), 1)
self.assertEqual(ManagedFilesystem.objects.get().name, "test18fs")
self.assertEqual(ManagedOst.objects.count(), 8)
for t in ManagedTarget.objects.all():
self.assertEqual(t.immutable_state, True)
def assertMount(target_name, primary_host, failover_hosts=list()):
target = ManagedTarget.objects.get(name=target_name)
self.assertEquals(
ManagedTargetMount.objects.filter(target=target).count(),
1 + len(failover_hosts))
self.assertEquals(
ManagedTargetMount.objects.filter(
target=target,
primary=True,
host=ManagedHost.objects.get(
address=primary_host)).count(),
1,
)
for h in failover_hosts:
self.assertEquals(
ManagedTargetMount.objects.filter(
target=target,
primary=False,
host=ManagedHost.objects.get(address=h)).count(),
1,
)
assertMount("MGS", "kp-lustre-1-8-mgs-1")
assertMount("test18fs-MDT0000", "kp-lustre-1-8-mgs-1")
assertMount("test18fs-OST0000", "kp-lustre-1-8-oss-1")
assertMount("test18fs-OST0001", "kp-lustre-1-8-oss-1")
assertMount("test18fs-OST0002", "kp-lustre-1-8-oss-2")
assertMount("test18fs-OST0003", "kp-lustre-1-8-oss-2")
assertMount("test18fs-OST0004", "kp-lustre-1-8-oss-3")
assertMount("test18fs-OST0005", "kp-lustre-1-8-oss-3")
assertMount("test18fs-OST0006", "kp-lustre-1-8-oss-4")
assertMount("test18fs-OST0007", "kp-lustre-1-8-oss-4")
self.assertEqual(ManagedFilesystem.objects.get().state, "available")
class TestRegistration(IMLUnitTestCase):
"""API unit tests for functionality used only by the agent"""
mock_servers = {
'mynewhost': {
'fqdn': 'mynewhost.mycompany.com',
'nodename': 'test01.mynewhost.mycompany.com',
'nids': [Nid.Nid("192.168.0.1", "tcp", 0)],
}
}
def setUp(self):
super(TestRegistration, self).setUp()
load_default_profile()
self.old_create_host = JobSchedulerClient.create_host
JobSchedulerClient.create_host = mock.Mock(
side_effect=lambda *args, **kwargs:
(synthetic_host('mynewhost', **self.mock_servers['mynewhost']),
mock.Mock(id='bar')))
ValidatedClientView.valid_certs = {}
def tearDown(self):
JobSchedulerClient.create_host = self.old_create_host
def test_version(self):
host_info = self.mock_servers['mynewhost']
with timed('csr', 10):
data = {
'fqdn': host_info['fqdn'],
'nodename': host_info['nodename'],
'version': '1.0',
'capabilities': ['manage_targets'],
'address': 'mynewhost',
'csr': generate_csr(host_info['fqdn']),
}
with patch(settings, VERSION='2.0'):
# Try with a mis-matched version
token = RegistrationToken.objects.create(
profile=ServerProfile.objects.get())
with timed('register fail', 10):
response = Client().post("/agent/register/%s/" % token.secret,
data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 400)
# Try with a matching version
token = RegistrationToken.objects.create(
profile=ServerProfile.objects.get())
settings.VERSION = '1.1'
with timed('register pass', 10):
response = Client().post("/agent/register/%s/" % token.secret,
data=json.dumps(data),
content_type="application/json")
self.assertEqual(response.status_code, 201)
content = json.loads(response.content)
# reregistration should fail with unknown serial
data = {'address': 'mynewhost', 'fqdn': 'mynewhost.newcompany.com'}
headers = {
'HTTP_X_SSL_CLIENT_NAME': host_info['fqdn'],
'HTTP_X_SSL_CLIENT_SERIAL': ''
}
response = Client().post('/agent/reregister/',
data=json.dumps(data),
content_type='application/json',
**headers)
self.assertEqual(response.status_code, 403)
# reregistration should update host's domain name
headers['HTTP_X_SSL_CLIENT_SERIAL'] = Crypto().get_serial(
content['certificate'])
response = Client().post('/agent/reregister/',
data=json.dumps(data),
content_type='application/json',
**headers)
self.assertEqual(response.status_code, 200)
host = ManagedHost.objects.get(id=content['host_id'])
self.assertEqual(host.fqdn, data['fqdn'])
class TestSharedTarget(JobTestCaseWithHost):
mock_servers = {
'pair1': {
'fqdn': 'pair1.mycompany.com',
'nodename': 'test01.pair1.mycompany.com',
'nids': [Nid.Nid("192.168.0.1", "tcp", 0)]
},
'pair2': {
'fqdn': 'pair2.mycompany.com',
'nodename': 'test02.pair2.mycompany.com',
'nids': [Nid.Nid("192.168.0.2", "tcp", 0)]
}
}
def setUp(self):
super(TestSharedTarget, self).setUp()
self.mgt, tms = ManagedMgs.create_for_volume(self._test_lun(
ManagedHost.objects.get(address='pair1'),
secondary_hosts=[ManagedHost.objects.get(address='pair2')]).id,
name="MGS")
ObjectCache.add(ManagedTarget, self.mgt.managedtarget_ptr)
for tm in tms:
ObjectCache.add(ManagedTargetMount, tm)
self.assertEqual(
ManagedMgs.objects.get(pk=self.mgt.pk).state, 'unformatted')
def test_clean_setup(self):
# Start it normally the way the API would on creation
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'mounted')
self.assertEqual(
ManagedTarget.objects.get(pk=self.mgt.pk).state, 'mounted')
self.assertEqual(
ManagedTarget.objects.get(pk=self.mgt.pk).active_mount,
ManagedTargetMount.objects.get(host=self.hosts[0],
target=self.mgt))
def test_teardown_unformatted(self):
self.assertEqual(
ManagedTarget.objects.get(pk=self.mgt.pk).state, 'unformatted')
try:
# We should need no agent ops to remove something we never formatted
MockAgentRpc.succeed = False
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'removed')
finally:
MockAgentRpc.succeed = True
with self.assertRaises(ManagedTarget.DoesNotExist):
ManagedTarget.objects.get(pk=self.mgt.pk)
def test_teardown_remove_primary_host(self):
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'mounted')
self.set_and_assert_state(self.mgt.primary_host, 'removed')
# Removing the primary server removes the target
with self.assertRaises(ManagedTarget.DoesNotExist):
ManagedTarget.objects.get(pk=self.mgt.pk)
def test_teardown_remove_secondary_host(self):
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'mounted')
self.set_and_assert_state(self.mgt.failover_hosts[0], 'removed')
# Removing the secondary server removes the target
with self.assertRaises(ManagedTarget.DoesNotExist):
ManagedTarget.objects.get(pk=self.mgt.pk)
def test_teardown_friendly_user(self):
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'mounted')
# Friendly user stops the target
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'unmounted')
# Friendly user removes the target
self.mgt.managedtarget_ptr = self.set_and_assert_state(
self.mgt.managedtarget_ptr, 'removed')
with self.assertRaises(ManagedTarget.DoesNotExist):
ManagedTarget.objects.get(pk=self.mgt.pk)
# Friendly user removes the secondary host
self.hosts[1] = self.set_and_assert_state(self.hosts[1], 'removed')
# Friendly user removes the primary host
self.hosts[0] = self.set_and_assert_state(self.hosts[0], 'removed')