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 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)