def convert_passwords(path, val): log.info("Converting %s", path) password = str(path)[len("passwords."):] configuration.converters.started(path) environment = configuration['bespin'].environment val_as_dict = configuration["passwords"][password].as_dict() if not environment: raise BespinError("No environment was provided", available=list( configuration["environments"].keys())) password_environment_as_dict = {} if ["passwords", password, environment] in configuration: password_environment_as_dict = configuration[[ "passwords", password, environment ]].as_dict() base = MergedOptions(dont_prefix=path.configuration.dont_prefix, converters=path.configuration.converters) everything = path.configuration.root().wrapped() base.update(val_as_dict) everything[path] = val_as_dict base.update(password_environment_as_dict) everything[path].update(password_environment_as_dict) for thing in (base, everything): thing["__password__"] = val thing["__environment__"] = configuration["environments"][ environment] meta = Meta(everything, [("passwords", ""), (password, "")]) return bespin_spec.password_spec.normalise(meta, base)
def extra_prepare(self, configuration, args_dict): """Called before the configuration.converters are activated""" harpoon = MergedOptions.using( configuration.get('harpoon', MergedOptions()).as_dict(), dict(args_dict.get("harpoon", MergedOptions()).items())).as_dict() # Args_dict may itself be a MergedOptions while "harpoon" in args_dict: del args_dict["harpoon"] # Create the addon getter and register the crosshair namespace self.addon_getter = AddonGetter() self.addon_getter.add_namespace("harpoon.crosshairs", Result.FieldSpec(), Addon.FieldSpec()) # Initiate the addons from our configuration self.register = Register(self.addon_getter, self) if ("addons" in harpoon) and ( type(harpoon["addons"]) in (MergedOptions, dict) or getattr(harpoon["addons"], "is_dict", False)): for namespace, adns in sb.dictof( sb.string_spec(), sb.listof(sb.string_spec())).normalise( Meta(harpoon, []).at("addons"), harpoon["addons"]).items(): self.register.add_pairs(*[(namespace, adn) for adn in adns]) # Import our addons self.register.recursive_import_known() # Resolve our addons self.register.recursive_resolve_imported() # Make sure images is started if "images" not in self.configuration: self.configuration["images"] = {} # Add our special stuff to the configuration self.configuration.update( { "$@": harpoon.get("extra", ""), "bash": args_dict["bash"] or NotSpecified, "harpoon": harpoon, "command": args_dict['command'] or NotSpecified, "assume_role": args_dict["assume_role"] or NotSpecified }, source="<args_dict>")
def extra_prepare(self, configuration, args_dict): """Called before the configuration.converters are activated""" bespin = dict(args_dict.get("bespin", MergedOptions()).items()) while "bespin" in args_dict: del args_dict["bespin"] environment = bespin.get("environment") bespin["configuration"] = configuration self.configuration.update( { "$@": bespin["extra"], "bespin": bespin, "command": args_dict['command'], "environment": environment }, source="<args_dict>")
def start_configuration(self): """Create the base of the configuration""" return MergedOptions(dont_prefix=[dictobj])
def collect_configuration(self, configuration_file): """Return us a MergedOptions with this configuration and any collected configurations""" errors = [] result = self.read_yaml(configuration_file) configuration_dir = os.path.dirname( os.path.abspath(configuration_file)) images_from = [] images_from_path = None if "images" in result and "__images_from__" in result["images"]: images_from_path = result["images"]["__images_from__"] if not images_from_path.startswith("/"): images_from_path = os.path.join(configuration_dir, images_from_path) if not os.path.exists(images_from_path) or not os.path.isdir( images_from_path): raise BadConfiguration( "Specified folder for other configuration files points to a folder that doesn't exist", path="images.__images_from__", value=images_from_path) images_from = sorted( chain.from_iterable([[ os.path.join(root, fle) for fle in files if fle.endswith(".yml") or fle.endswith(".yaml") ] for root, dirs, files in os.walk(images_from_path)])) harpoon_spec = HarpoonSpec() configuration = MergedOptions(dont_prefix=[dictobj]) home_dir_configuration = self.home_dir_configuration_location() sources = [home_dir_configuration, configuration_file] + images_from def make_mtime_func(source): """Lazily calculate the mtime to avoid wasted computation""" return lambda: self.get_committime_or_mtime(source) for source in sources: if source is None or not os.path.exists(source): continue try: result = self.read_yaml(source) except BadYaml as error: errors.append(error) continue if "images" in result and "__images_from__" in result["images"]: del result["images"]["__images_from__"] if source in images_from: result = { "images": { os.path.splitext(os.path.basename(source))[0]: result } } result["mtime"] = make_mtime_func(source) if "images" in result: images = result.pop("images") images = dict( (image, MergedOptions.using(configuration.root(), val, converters=configuration.converters, source=source)) for image, val in images.items()) result["images"] = images configuration.update(result, dont_prefix=[dictobj], source=source) for image in result.get('images', {}).keys(): self.make_image_converters(image, configuration, harpoon_spec) def convert_harpoon(path, val): log.info("Converting %s", path) meta = Meta(path.configuration, [("harpoon", "")]) configuration.converters.started(path) return harpoon_spec.harpoon_spec.normalise(meta, val) harpoon_converter = Converter(convert=convert_harpoon, convert_path=["harpoon"]) configuration.add_converter(harpoon_converter) if errors: raise BadConfiguration("Some of the configuration was broken", _errors=errors) return configuration
with mock.patch.multiple(collector , find_photons_app_options = find_photons_app_options , determine_mainline_module = determine_mainline_module , setup_addon_register = setup_addon_register ): yield __main__ find_photons_app_options.assert_called_once_with(configuration, args_dict) determine_mainline_module.assert_called_once_with() setup_addon_register.assert_called_once_with(photons_app, __main__) it "puts things into the configuration and sets up the addon register": extra = str(uuid.uuid1()) photons_app = {"extra": extra} configuration = MergedOptions() collector = Collector() register = mock.Mock(name="register") args_dict = mock.Mock(name="args_dict") with self.mocks(collector, configuration, args_dict, photons_app, register): collector.extra_prepare(configuration, args_dict) class AFuture: def __eq__(self, other): return isinstance(other, asyncio.Future) self.assertIs(collector.register, register) self.assertEqual(configuration.as_dict() , { "$@": extra , "collector": collector