def test_kvp_params(self): kvps = "joe:blue,jan:green" params = Params({}) params.load_kvps(kvps) self.assertTrue(params.get("jan") == 'green') self.assertTrue(params.get("joe") == 'blue')
def test_kvp_param_comment(self): kvps = "ami:ami-324:ami for ec2 hosts,vpc-id:vpc-325552:id of nonprod vpc" params = Params({}) params.load_kvps(kvps) self.assertTrue(params.get("ami") == 'ami-324') self.assertTrue(params.get("vpc-id") == 'vpc-325552')
def conditions_met(self, params): conditions_met = True # currently the only conditional supported is based on key-value pair (aka 'kvps') # conditions are met if the state of the conditional params matches the current params if self.conditions and 'kvps' in self.conditions: # load the kvps into params condition_params = Params({}) condition_params.load_kvps(self.conditions['kvps']) for condition_param_key in list(condition_params.keys()): if params.get(condition_param_key) != condition_params.get(condition_param_key): conditions_met = False break return conditions_met
class Service(): def __init__(self, serialized_service, service_path, alias="", params_path="", kvps=""): # first validate. this should throw an exception if # required fields aren't present validate(serialized_service, "yac/schema/service.json") self.path = service_path self.kvps_str = kvps self.params_file_path = params_path self.description = Description(search('Description', serialized_service,{}), alias) self.vaults = SecretVaults(search('"Vaults"', serialized_service,[])) # a service can references other services that it includes self.includes = search("includes", serialized_service,{}) # initialize stack params (key/value pairs and maps), including static params specified # in the serialized service, params from an external file, # params specified in a key-value pair string (kvps), self.params = Params(search('"Params"', serialized_service, {})) # initialize the dictionary that will hold all params (statics+secrets+inputs) self.all_params = {} inputs_cacher = InputsCacher(search('InputsCache', serialized_service,{})) self.inputs = Inputs(search('Inputs', serialized_service,{}), inputs_cacher) self.secrets = Secrets(search('"Secrets"', serialized_service,{})) # inialize the stack associated with this service self.stack = Stack(search('Stack', serialized_service, {})) self.tasks = Tasks(search('Tasks', serialized_service,{})) # initialize the tests associated with this service self.tests = IntegrationTests(search('"IntegrationTests"', serialized_service,{})) # initialize the artifacts associate with this service self.artifacts = Artifacts(search('Artifacts', serialized_service,[])) # initialize the credentialer associated with this service self.credentialers = Credentialers(search("Credentialers",serialized_service,[])) # initialize the pipeline associated with this service self.pipeline = Pipeline(search('Pipeline', serialized_service,{})) # load the objects from each included service self.load_includes() # save a copy of the full serialized version of the # service to support the serialize() method self.serialized_service = serialized_service # add mergeable fields from another service into this service def add(self, service): if service.params: self.params.add(service.params) if service.secrets: self.secrets.add(service.secrets) if service.vaults: self.vaults.add(service.vaults) if service.stack.impl: # there can be only one stack if self.stack.impl: self.stack.add(service.stack) else: self.stack = service.stack if service.tasks: self.tasks.add(service.tasks) if service.inputs: self.inputs.add(service.inputs) if service.tests: self.tests.add(service.tests) if service.artifacts: self.artifacts.add(service.artifacts) if service.credentialers: self.credentialers.add(service.credentialers) if service.pipeline and service.pipeline.get_stages(): # there can be only one pipeline per service self.pipeline = service.pipeline def add_params_via_kvps(self,kvp_str): # load key-value pairs via a kvp string formatted as: # <key1>:<value1>,<key2>:<val2>,etc self.params.load_kvps(kvp_str) def load_includes(self): # load objects from each included service # for each included service specified for service_key in self.includes: sub_service_path = self.includes[service_key]["value"] # load the included service ... this_sub, err = get_service(sub_service_path, servicefile_path=self.path) # add to this service if not err: print("including '%s' service ..."%(service_key)) self.add(this_sub) else: print("included service '%s' could not be loaded from %s"%(service_key, sub_service_path)) print("error: %s"%err) print("exiting ...") exit(0) exit(0) def get_meta_params(self): # get meta data about this service service_metadata = Params({}) service_metadata.set("service-default-alias",self.description.default_alias, "service default alias") service_metadata.set("service-alias",self.description.alias, "service alias") service_metadata.set("service-name",self.description.name, "service name") service_metadata.set("servicefile-path",self.path, "path to the servicefile") # add service summary and repo service_metadata.set('service-summary',self.description.summary, "service summary") service_metadata.set('service-repo',self.description.repo, "repo containing this service") # add the command that was run against this service service_metadata.set("yac-command",sys.argv[0], 'the yac command being run') return service_metadata def get_params(self): # add params describing the service itself self.params.add(self.get_meta_params()) # load any params from yac-supported env variables self.params.load_from_env_variables() # load kvps (typically used for injecting inputs in pipelines or overriding # an invidual param setpoint) self.params.load_kvps(self.kvps_str) # load params from file self.params.load_from_file(self.params_file_path) return self.params def get_all_params(self, context="", dry_run_bool=False, credentialer_names=[]): # Take a copy of params self.all_params = self.get_params() # process inputs and load results into params self.inputs.load(self.all_params) # load secrets into params self.secrets.load(self.all_params, self.vaults) return self.all_params def get_description(self): return self.description def get_artifacts(self): return self.artifacts def get_stack(self): return self.stack def get_tests(self): return self.tests def get_tasks(self): return self.tasks def get_vaults(self): return self.vaults def get_deployer(self): return self.deployer() def get_inputs(self): return self.inputs def get_secrets(self): return self.secrets def get_pipeline(self): return self.pipeline def get_credentialers(self): return self.credentialers def get_serialized_pipeline(self): return self.serialized_pipeline def deploy_boot_files(self, dry_run_bool=False): self.boot_files.deploy(self.params, dry_run_bool) def serialize(self): return self.serialized_service def __str__(self): ret = ("description:\n %s\n"%self.description + "params:\n %s\n"%self.params + "secrets:\n %s\n"%self.secrets + "stack:\n %s\n"%self.stack + "vaults: \n %s\n")%self.vaults return ret