def to_resource(
self, resource: Union[InvalidObject, Any]
) -> Union[Operator, Workflow, Config, MalformedResource]:
if isinstance(resource, InvalidObject):
return MalformedResource(resource)
elif isinstance(resource, Operator) or isinstance(
resource, Workflow) or isinstance(resource, Config):
return resource
else:
return MalformedResource(
message=
f"Not a valid resource type: {resource.__class__.__name__}")
def get_operator(self, namespace: str,
command: str) -> Union[Operator, MalformedResource]:
op = self.get_resource("operator", namespace, command)
if isinstance(op, Operator) or isinstance(op, MalformedResource):
return op
else:
return MalformedResource(message="Bad type cast")
def get_resources(
self,
type: str,
namespace: Optional[str] = None,
command: Optional[str] = None
) -> List[Union[Operator, Workflow, Config, MalformedResource]]:
all: List[Union[Operator, Workflow, Config, MalformedResource]] = []
if self.type_any(type):
if self.type_operator(type):
if namespace and command:
all += [self.get_operator(namespace, command)]
else:
all += self.get_operators(namespace, command)
all += self.get_bad()
if self.type_workflow(type):
if namespace and command:
all += [self.get_workflow(namespace, command)]
else:
all += self.get_workflows(namespace, command)
all += self.get_bad()
if self.type_config(type):
if namespace:
all += [self.get_config(namespace)]
else:
all += self.get_configs(namespace)
all += self.get_bad()
else:
all += [MalformedResource(message=f"Unsupported type: {type}")]
relevant = [
a for a in all
if not (isinstance(a, MalformedResource) and a.ignorable())
]
return relevant
def get_first_config(self) -> Union[Config, MalformedResource]:
configs: List[Config] = self.get_configs()
configs.sort(key=lambda c: c.id)
if len(configs) > 0:
return configs[0]
else:
return MalformedResource()
def get_workflow(self, namespace: str,
command: str) -> Union[Workflow, MalformedResource]:
op = self.get_resource("workflow", namespace, command)
if isinstance(op, Workflow) or isinstance(op, MalformedResource):
return op
else:
return MalformedResource(message="Bad type cast")
def get_config(self, config_id: str) -> Union[Config, MalformedResource]:
conf: Union[Operator, Config, Workflow,
MalformedResource] = self.get_resource(
"config", config_id)
if isinstance(conf, Config) or isinstance(conf, MalformedResource):
return conf
else:
return MalformedResource(message="Bad type cast")
def get_parameters(
self, type: str, parameter_string: Optional[str],
parameter_path: Optional[str], parameter_dict: Optional[dict]
) -> Union[Parameters, MalformedResource]:
parameters: Union[Parameters, MalformedResource]
if self.type_workflow(type):
parameters = WorkflowParameters(parameter_path, parameter_dict)
elif self.type_operator(type):
parameters = OperatorParameters(parameter_string, parameter_path,
parameter_dict)
elif self.type_config(type):
parameters = MalformedResource(
message=f"Config type not supported: {type}")
else:
parameters = MalformedResource(
message=f"Type not supported: {type}")
return parameters
def get_resource(
self,
type: str,
namespace: Optional[str] = None,
command: Optional[str] = None
) -> Union[Operator, Workflow, Config, MalformedResource]:
resources: List[Union[Operator, Workflow, Config]] = []
bad: List[MalformedResource] = []
if self.type_operator(type):
resources, bad = self.filter_resource(Operator, namespace, command)
elif self.type_workflow(type):
resources, bad = self.filter_resource(Workflow, namespace, command)
elif self.type_config(type):
resources, bad = self.filter_resource(Config, namespace, command)
else:
bad = [
MalformedResource(message=f"Unsupported resource type: {type}")
]
if len(resources) > 1:
message = f"Multiple {type} resources matching {namespace}"
if command:
message += f":{command}"
return MalformedResource(message=message)
elif len(resources) == 0:
matching_bad = self.get_matching_bad_resource(
type, bad, namespace, command)
if isinstance(matching_bad, MalformedResource):
return matching_bad
else:
not_found = f"{type}"
if namespace:
not_found += f":{namespace}"
if command:
not_found += f":{command}"
return MalformedResource(not_found=not_found)
else:
return resources[0]
def filter_resource(
self,
cls: Type[T],
namespace: Optional[str] = None,
command: Optional[str] = None
) -> Tuple[List[T], List[MalformedResource]]:
all = self.get_all()
operators, workflows, configs, malformed = sequence_4(
all, Operator, Workflow, Config, MalformedResource)
if cls == Operator:
ops = [o for o in operators if self.matches(o, namespace, command)]
return ops, malformed # type: ignore
elif cls == Workflow:
wfs = [w for w in workflows if self.matches(w, namespace, command)]
return wfs, malformed # type: ignore
elif cls == Config:
cfg = [c for c in configs if self.matches(c, namespace, command)]
return cfg, malformed # type: ignore
elif cls == MalformedResource:
return [], malformed
else:
return [], [
MalformedResource(message=f"Undefined resource: {cls}")
]