def get_parameters_by_tmpl(dbpersonality):
ret = defaultdict(dict)
session = object_session(dbpersonality)
paramdef_holder = dbpersonality.archetype.paramdef_holder
if not paramdef_holder:
return ret
param_definitions = paramdef_holder.param_definitions
parameters = get_parameters(session, personality=dbpersonality)
for param_def in param_definitions:
value = None
for param in parameters:
value = param.get_path(param_def.path, compel=False)
if (value is None) and param_def.default:
value = validate_value("default for path=%s" % param_def.path,
param_def.value_type, param_def.default)
if value is not None:
## coerce string list to list
if param_def.value_type == 'list':
value = string_to_list(value)
get_path_under_top(param_def.path, value,
ret[param_def.template])
## if all parameters are not defined still generate empty template
if param_def.template not in ret:
ret[param_def.template] = defaultdict()
return ret
def get_parameters_by_tmpl(dbpersonality):
ret = defaultdict(dict)
session = object_session(dbpersonality)
paramdef_holder = dbpersonality.archetype.paramdef_holder
if not paramdef_holder:
return ret
param_definitions = paramdef_holder.param_definitions
parameters = get_parameters(session, personality=dbpersonality)
for param_def in param_definitions:
value = None
for param in parameters:
value = param.get_path(param_def.path, compel=False)
if (value is None) and param_def.default:
value = validate_value("default for path=%s" % param_def.path,
param_def.value_type, param_def.default)
if value is not None:
## coerce string list to list
if param_def.value_type == 'list':
value = string_to_list(value)
get_path_under_top(param_def.path, value,
ret[param_def.template])
## if all parameters are not defined still generate empty template
if param_def.template not in ret:
ret[param_def.template] = defaultdict()
return ret
def render(self, session, personality, archetype, **arguments):
parameters = get_parameters(session,
archetype=archetype,
personality=personality)
if parameters:
return parameters
raise NotFoundException("No parameters found for personality %s." %
personality)
def render(self, session, personality, archetype, **arguments):
parameters = get_parameters(session,
archetype=archetype,
personality=personality)
if parameters:
return parameters
raise NotFoundException("No parameters found for personality %s." %
personality)
def render(self, session, feature, type, archetype, personality,
**arguments):
if not (personality or archetype):
raise ArgumentError("Archetype or Personality must be specified")
dbfeature = Feature.get_unique(session, name=feature, feature_type=type,
compel=True)
parameters = get_parameters(session,
archetype=archetype,
personality=personality,
feature=dbfeature)
if parameters:
return parameters
raise NotFoundException("No parameters found for feature %s." % feature)
def render(self, session, feature, type, archetype, personality,
**arguments):
if not (personality or archetype):
raise ArgumentError("Archetype or Personality must be specified")
dbfeature = Feature.get_unique(session,
name=feature,
feature_type=type,
compel=True)
parameters = get_parameters(session,
archetype=archetype,
personality=personality,
feature=dbfeature)
if parameters:
return parameters
raise NotFoundException("No parameters found for feature %s." %
feature)
def populate_data(self, session, dbpersona, dtype, ret):
""" pouplate data we are interesetd in seeing as part of diff """
## parameters
params = {}
dbpersona_parameters = get_parameters(session, personality=dbpersona)
for param in dbpersona_parameters:
params.update(Parameter.flatten(param.value))
ret["Parameters"][dtype] = params
## process features
features = dict((fl.feature.name, True) for fl in dbpersona.features)
ret["Features"][dtype] = features
## process required_services
services = dict((srv.name, True) for srv in dbpersona.services)
ret["Required Services"][dtype] = services
## service maps
q = session.query(PersonalityServiceMap).filter_by(personality=dbpersona)
smaps = dict(("{0} {1}".format(sm.service_instance, sm.location), True) for sm in q.all())
ret["ServiceMap"][dtype] = smaps
## grns
grns = dict((grn, True) for grn in dbpersona.grns)
ret["Grns"][dtype] = grns
## options
enabled = defaultdict()
if dbpersona.config_override:
enabled["ConfigOverride"] = True
if dbpersona.cluster_required:
enabled["Cluster Required"] = True
enabled["Environment"] = dbpersona.host_environment.name
ret["Options"][dtype] = enabled
def get_parameters_by_feature(dbfeaturelink):
ret = {}
paramdef_holder = dbfeaturelink.feature.paramdef_holder
if not paramdef_holder:
return ret
param_definitions = paramdef_holder.param_definitions
parameters = get_parameters(object_session(dbfeaturelink),
personality=dbfeaturelink.personality)
for param_def in param_definitions:
value = None
for param in parameters:
value = param.get_feature_path(dbfeaturelink,
param_def.path, compel=False)
if not value and param_def.default:
value = validate_value("default for path=%s" % param_def.path,
param_def.value_type, param_def.default)
if value is not None:
if param_def.value_type == 'list':
value = string_to_list(value)
ret[param_def.path] = value
return ret
def get_parameters_by_feature(dbfeaturelink):
ret = {}
paramdef_holder = dbfeaturelink.feature.paramdef_holder
if not paramdef_holder:
return ret
param_definitions = paramdef_holder.param_definitions
parameters = get_parameters(object_session(dbfeaturelink),
personality=dbfeaturelink.personality)
for param_def in param_definitions:
value = None
for param in parameters:
value = param.get_feature_path(dbfeaturelink,
param_def.path,
compel=False)
if not value and param_def.default:
value = validate_value("default for path=%s" % param_def.path,
param_def.value_type, param_def.default)
if value is not None:
if param_def.value_type == 'list':
value = string_to_list(value)
ret[param_def.path] = value
return ret
def render(self, session, logger, personality, archetype,
grn, eon_id, host_environment, comments,
cluster_required, copy_from, config_override, **arguments):
if not VALID_PERSONALITY_RE.match(personality):
raise ArgumentError("Personality name '%s' is not valid." %
personality)
if not (grn or eon_id):
raise ArgumentError("GRN or EON ID is required for adding a "
"personality.")
dbarchetype = Archetype.get_unique(session, archetype, compel=True)
if not host_environment:
try:
host_environment = self.config.get("archetype_" + archetype,
"default_environment")
except (NoSectionError, NoOptionError):
raise ArgumentError("Default environment is not configured "
"for {0:l}, please specify "
"--host_environment.".format(dbarchetype))
HostEnvironment.polymorphic_subclass(host_environment,
"Unknown environment name")
Personality.validate_env_in_name(personality, host_environment)
host_env = HostEnvironment.get_unique(session, host_environment, compel=True)
Personality.get_unique(session, archetype=dbarchetype, name=personality,
preclude=True)
dbgrn = lookup_grn(session, grn, eon_id, logger=logger,
config=self.config)
dbpersona = Personality(name=personality, archetype=dbarchetype,
cluster_required=bool(cluster_required),
host_environment=host_env, owner_grn=dbgrn,
comments=comments,
config_override=config_override)
session.add(dbpersona)
if self.config.has_option("archetype_" + archetype, "default_grn_target"):
dbpersona.grns.append((dbpersona, dbgrn,
self.config.get("archetype_" + archetype,
"default_grn_target")))
if copy_from:
## copy config data
dbfrom_persona = Personality.get_unique(session,
archetype=dbarchetype,
name=copy_from,
compel=True)
src_parameters = get_parameters(session,
personality=dbfrom_persona)
db_param_holder = PersonalityParameter(personality=dbpersona)
for param in src_parameters:
dbparameter = Parameter(value=param.value,
comments=param.comments,
holder=db_param_holder)
session.add(dbparameter)
for link in dbfrom_persona.features:
params = {}
params["personality"] = dbpersona
if link.model:
params["model"] = link.model
if link.interface_name:
params["interface_name"] = link.interface_name
add_link(session, logger, link.feature, params)
## service maps
q = session.query(PersonalityServiceMap).filter_by(personality=dbfrom_persona)
for sm in q.all() :
dbmap = PersonalityServiceMap(service_instance=sm.service_instance,
location=sm.location,
network=sm.network,
personality=dbpersona)
session.add(dbmap)
## required services
dbpersona.services.extend(dbfrom_persona.services)
session.flush()
plenary = PlenaryPersonality(dbpersona, logger=logger)
plenary.write()
return
