def test_accumulate_with_first_value_on_step_boundary(self): """ step: 0 5 --|--+--+--+--+--|-- value: 14 """ persist = Persist() accumulate = Accumulator(persist, 5) self.assertEqual(persist.get("key"), None) step_data = accumulate(0, 14, "key") self.assertEqual(step_data, None) self.assertEqual(persist.get("key"), (0, 0))
def test_accumulate(self): """ step: 0 5 --|--+--+--+--+--|-- value: 0 4 """ persist = Persist() accumulate = Accumulator(persist, 5) self.assertEqual(persist.get("key"), None) step_data = accumulate(5, 4, "key") self.assertEqual(step_data, (5, 4)) self.assertEqual(persist.get("key"), (5, 0))
def test_accumulate_skipped_step(self): """ step: 0 5 10 15 --|--+--+--+--+--|--+--+--+--+--|--+--+--+--+--|-- value: 0 4 """ persist = Persist() accumulate = Accumulator(persist, 5) self.assertEqual(persist.get("key"), None) step_data = accumulate(12, 4, "key") self.assertEqual(step_data, None) self.assertEqual(persist.get("key"), (12, 8))
def run_script(self, shell, code, user=None, time_limit=None, attachments=None, server_supplied_env=None): """ Run a script based on a shell and the code. A file will be written with #!<shell> as the first line, as executable, and run as the given user. XXX: Handle the 'reboot' and 'killall landscape-client' commands gracefully. @param shell: The interpreter to use. @param code: The code to run. @param user: The username to run the process as. @param time_limit: The number of seconds to allow the process to run before killing it and failing the returned Deferred with a L{ProcessTimeLimitReachedError}. @param attachments: C{dict} of filename/data attached to the script. @return: A deferred that will fire with the data printed by the process or fail with a L{ProcessTimeLimitReachedError}. """ if not os.path.exists(shell.split()[0]): return fail(UnknownInterpreterError(shell)) uid, gid, path = get_user_info(user) fd, filename = tempfile.mkstemp() script_file = os.fdopen(fd, "w") self.write_script_file(script_file, filename, shell, code, uid, gid) env = {"PATH": UBUNTU_PATH, "USER": user or "", "HOME": path or ""} if server_supplied_env: env.update(server_supplied_env) old_umask = os.umask(0022) if attachments: persist = Persist(filename=os.path.join( self.registry.config.data_path, "broker.bpickle")) persist = persist.root_at("registration") computer_id = persist.get("secure-id") d = self._save_attachments(attachments, uid, gid, computer_id) else: d = succeed(None) def prepare_script(attachment_dir): if attachment_dir is not None: env["LANDSCAPE_ATTACHMENTS"] = attachment_dir return self._run_script(filename, uid, gid, path, env, time_limit) d.addCallback(prepare_script) return d.addBoth(self._cleanup, filename, env, old_umask)
def test_that_resynchronize_clears_message_blackhole(self): """ When a resynchronisation event occurs the block on new messages being stored is lifted. """ self.reactor.fire("resynchronize-clients", []) persist = Persist(filename=self.persist_filename) self.assertFalse(persist.get("blackhole-messages"))
class IdentityTest(LandscapeTest): helpers = [BrokerConfigurationHelper] def setUp(self): super(IdentityTest, self).setUp() self.persist = Persist(filename=self.makePersistFile()) self.identity = Identity(self.config, self.persist) def check_persist_property(self, attr, persist_name): value = "VALUE" self.assertEqual(getattr(self.identity, attr), None, "%r attribute should default to None, not %r" % (attr, getattr(self.identity, attr))) setattr(self.identity, attr, value) self.assertEqual(getattr(self.identity, attr), value, "%r attribute should be %r, not %r" % (attr, value, getattr(self.identity, attr))) self.assertEqual( self.persist.get(persist_name), value, "%r not set to %r in persist" % (persist_name, value)) def check_config_property(self, attr): value = "VALUE" setattr(self.config, attr, value) self.assertEqual(getattr(self.identity, attr), value, "%r attribute should be %r, not %r" % (attr, value, getattr(self.identity, attr))) def test_secure_id(self): self.check_persist_property("secure_id", "registration.secure-id") def test_secure_id_as_unicode(self): """secure-id is expected to be retrieved as unicode.""" self.identity.secure_id = b"spam" self.assertEqual(self.identity.secure_id, "spam") def test_insecure_id(self): self.check_persist_property("insecure_id", "registration.insecure-id") def test_computer_title(self): self.check_config_property("computer_title") def test_account_name(self): self.check_config_property("account_name") def test_registration_key(self): self.check_config_property("registration_key") def test_client_tags(self): self.check_config_property("tags") def test_access_group(self): self.check_config_property("access_group")
def test_flush_saves_persist(self): """ The L{Monitor.flush} method saves any changes made to the persist database. """ self.monitor.persist.set("a", 1) self.monitor.flush() persist = Persist() persist.load(self.monitor.persist_filename) self.assertEqual(persist.get("a"), 1)
def test_flush_after_exchange(self): """ The L{Monitor.exchange} method flushes the monitor after C{exchange} on all plugins has been called. """ plugin = BrokerClientPlugin() plugin.exchange = lambda: self.monitor.persist.set("a", 1) self.monitor.add(plugin) self.monitor.exchange() persist = Persist() persist.load(self.monitor.persist_filename) self.assertEqual(persist.get("a"), 1)
def test_accumulate_non_zero_accumulated_value(self): """ step: 5 10 15 --|--+--+--+--+--|--+--+--+--+--|-- value: 4 3 """ persist = Persist() accumulate = Accumulator(persist, 5) # Persist data that would have been stored when # accumulate(7, 4, "key") was called. persist.set("key", (7, 8)) step_data = accumulate(13, 3, "key") self.assertEqual(step_data, (10, float((2 * 4) + (3 * 3)) / 5)) self.assertEqual(persist.get("key"), (13, 9))
def test_accumulate_within_step_with_nonzero_start_accumulated_value(self): """ step: 0 5 --|--+--+--+--+--|-- value: 0 3 4 """ persist = Persist() accumulate = Accumulator(persist, 5) # Persist data that would have been stored when # accumulate(2, 3, "key") was called. persist.set("key", (2, 6)) step_data = accumulate(4, 4, "key") self.assertEqual(step_data, None) self.assertEqual(persist.get("key"), (4, 14))
class PatchTest(LandscapeTest): def setUp(self): LandscapeTest.setUp(self) self.persist = Persist() self.manager = UpgradeManager() def test_wb_nopatches(self): """ Applying no patches should make no change to the database, apart from maybe specifying a default version. """ self.assertEqual(self.persist._hardmap, {}) self.manager.apply(self.persist) self.assertEqual(self.persist._hardmap, {"system-version": 0}) def test_one_patch(self): """Test that patches are called and passed a L{Persist} object.""" calls = [] self.manager.register_upgrader(1, calls.append) self.manager.apply(self.persist) self.assertEqual(calls, [self.persist]) def test_two_patches(self): """Test that patches are run in order.""" calls = [] self.manager.register_upgrader(2, lambda x: calls.append(2)) self.manager.register_upgrader(1, lambda x: calls.append(1)) self.manager.apply(self.persist) self.assertEqual(calls, [1, 2]) def test_record_version(self): """When a patch is run it should update the C{system-version}.""" self.assertEqual(self.persist.get("system-version"), None) self.manager.register_upgrader(1, lambda x: None) self.manager.apply(self.persist) self.assertEqual(self.persist.get("system-version"), 1) def test_only_apply_unapplied_versions(self): """Upgraders should only be run if they haven't been run before.""" calls = [] self.manager.register_upgrader(1, lambda x: calls.append(1)) self.manager.apply(self.persist) self.manager.apply(self.persist) self.assertEqual(calls, [1]) def test_initialize(self): """Marking no upgraders as applied should leave the version at 0.""" self.manager.initialize(self.persist) self.assertEqual(self.persist.get("system-version"), 0) def test_initialize_with_upgraders(self): """ After registering some upgraders, initialize should set the version for the new persist to the highest version number available, without running any of the upgraders. """ self.manager.register_upgrader(1, lambda x: 1 / 0) self.manager.register_upgrader(5, lambda x: 1 / 0) self.manager.register_upgrader(3, lambda x: 1 / 0) self.manager.initialize(self.persist) self.assertEqual(self.persist.get("system-version"), 5) def test_decorated_upgraders_run(self): """ Upgraders that use the L{upgrader} decorator should automatically register themselves with a given L{UpgradeManager} and be run when the manager applies patches. """ upgrade_manager = UpgradeManager() @upgrade_manager.upgrader(1) def upgrade(persist): self.persist.set("upgrade-called", True) upgrade_manager.apply(self.persist) self.assertTrue(self.persist.get("upgrade-called"))