def _load_host(p, c, m, run_name, instanceid, hostname, servicename):
"""Load a VM instance from cloudinit information
"""
# Account for
piggybacked = ""
if not instanceid:
known_id = m.persistence.find_instanceid_byservice(run_name, servicename)
if known_id:
instanceid = known_id
else:
instanceid = "P-%d" % (int(random() * 100000000))
if m.persistence.check_new_instanceid(instanceid):
raise Exception("instance ID collision")
piggybacked = "piggybacked on "
vm = RunVM()
vm.instanceid = instanceid
vm.hostname = hostname
vm.service_type = servicename
m.runlogs.new_vm(vm)
if m.persistence.new_vm(run_name, vm):
c.log.info("New EPU related service detected: '%s'. %shost '%s', ID is '%s'" % (servicename, piggybacked, vm.hostname, vm.instanceid))
return vm
def test_latest_iaas_status(self):
self.svc_adapter.initialize(self.m, self.run_name, self.cloudinitd)
vm = RunVM()
vm.instanceid = "i-dfs3f32"
try:
status = self.svc_adapter.latest_iaas_status(None)
raised_programming_error = False
except ProgrammingError:
raised_programming_error = True
assert raised_programming_error
# Test response when there's no status in VM object
status = self.svc_adapter.latest_iaas_status(vm)
assert not status
vm.events = []
vm_iaas_state_0 = "RUNNING"
vm_timestamp_0 = datetime.datetime(2000, 10, 3)
vm_iaas_state_1 = "SOMETHINGELSE"
vm_timestamp_1 = datetime.datetime(2000, 10, 5)
vm.events.append(Event(name="iaas_state", state=vm_iaas_state_0, timestamp=vm_timestamp_0))
vm.events.append(Event(name="iaas_state", state=vm_iaas_state_1, timestamp=vm_timestamp_1))
status = self.svc_adapter.latest_iaas_status(vm)
assert status == vm_iaas_state_1
def get_run_vms_or_none(self, run_name):
"""Get list of VMs for a run name or return None"""
if not self.cdb:
raise ProgrammingError("cannot persist anything without setup/validation")
cyvm_a = self.cdb.get_iaas_by_runname(run_name)
vm_a = []
for cyvm in cyvm_a:
rvm = RunVM()
rvm.instanceid = cyvm.iaasid
rvm.nodeid = cyvm.nodeid
rvm.hostname = cyvm.hostname
rvm.service_type = cyvm.service_type
rvm.parent = cyvm.parent
rvm.runlogdir = cyvm.runlogdir
rvm.vmlogdir = cyvm.vmlogdir
for e in cyvm.events:
xtras = {}
for x in e.extra:
xtras[x.key] = x.value
c = CYvent(e.source, e.name, e.unique_event_key, e.timestamp, xtras)
rvm.events.append(c)
vm_a.append(rvm)
return vm_a
def test_intake_query_result(self):
provisioner = RunVM()
provisioner.runlogdir = tempfile.mkdtemp()
local_filename = "log.json"
remote_filename = "something"
local_abs_filepath = os.path.join(provisioner.runlogdir, local_filename)
controller_name = "test-controller"
de_state = "STABLE_DE"
de_conf_report = "balala"
instance_0 = "fashfjsahfjksa"
instance_0_state = "600-RUNNING"
iaas_state_time = 12312142
heartbeat_state = "SOMETHING"
heartbeat_time = 5
test_json = """
{"%s": {"de_state":"%s", "de_conf_report":"%s",
"instances": {
"%s": {"iaas_state":"%s", "iaas_state_time": %s,
"heartbeat_state":"%s", "heartbeat_time": %s}}}}
""" % (controller_name, de_state, de_conf_report,
instance_0, instance_0_state, iaas_state_time,
heartbeat_state, heartbeat_time)
with open(local_abs_filepath, "w") as j_file:
j_file.write(test_json)
self.svc_adapter.initialize(self.m, self.run_name, self.cloudinitd)
# Test detection of non-existant files
try:
fake_file = "not_a_file"
self.svc_adapter._intake_query_result(provisioner, fake_file, remote_filename)
raised_unexpected_error = False
except UnexpectedError:
raised_unexpected_error = True
assert raised_unexpected_error
# Test reading a file actually works
# all of the other values should be tested by test_intake_query_result_from_file
map = self.svc_adapter._intake_query_result(provisioner, local_filename, remote_filename)
assert map.has_key(controller_name)
def vms_launched(m, run_name, eventname):
provisioner = _get_provisioner(m, run_name)
vms = []
for event in provisioner.events:
if event.name == eventname:
vm = RunVM()
if eventname == "new_node":
vm.instanceid = event.extra['iaas_id']
vm.nodeid = event.extra['node_id']
elif eventname == "node_started":
vm.instanceid = event.extra['iaas_id']
vm.nodeid = event.extra['node_id']
else:
raise IncompatibleEnvironment("eventname is illegal")
vm.hostname = event.extra['public_ip']
# todo: 'unknown' is hardcoded in fetchkill, too
vm.service_type = "unknown" + vm.WORKER_SUFFIX
m.runlogs.new_vm(vm)
vms.append(vm)
return vms
def test_worker_state(self):
# Check when nothing's passed to worker_state
try:
self.svc_adapter.worker_state(None, None)
raised_incompatible_env = False
except IncompatibleEnvironment:
raised_incompatible_env = True
assert raised_incompatible_env
provisioner = RunVM()
# Check when not initialized yet
try:
self.svc_adapter.worker_state(None, provisioner)
raised_programming_error = False
except ProgrammingError:
raised_programming_error = True
assert raised_programming_error
self.svc_adapter.initialize(self.m, self.run_name, self.cloudinitd)
# Check when no controllers provided
try:
self.svc_adapter.worker_state(None, provisioner)
raised_invalid_input = False
except InvalidInput:
raised_invalid_input = True
assert raised_invalid_input
controllers = ["one", "two"]
try:
self.svc_adapter.worker_state(controllers, provisioner)
raised_incompatible_env = False
except IncompatibleEnvironment:
raised_incompatible_env = True
assert raised_incompatible_env
provisioner.hostname = "some.fake.hostname"
provisioner.service_type = "provisioner"
provisioner.runlogdir = self.runlogdir
self.svc_adapter.provisioner._svc._s.hostname = provisioner.hostname
try:
self.svc_adapter.worker_state(controllers, provisioner)
except UnexpectedError as e:
print e.msg
assert "Expecting to find the state query result here" in e.msg
ssh_commands = [message for (level, message)
in self.c.log.transcript
if level == "DEBUG"
and "command = 'echo ssh" in message]
ssh_command = ssh_commands[0]
# Make sure epu-state called for provisioner
assert re.match(".*ssh.*%s.*epu-state" % provisioner.hostname, ssh_command)
# Make sure we query both controllers
assert re.match(".*epu-state.*%s" % controllers[0], ssh_command)
assert re.match(".*epu-state.*%s" % controllers[1], ssh_command)
