def handle_PUT(self):
algorithm_name = self.get_param("algorithm")
runtime_name = self.get_param("runtime")
if algorithm_name:
a = algorithm_api.get(self.splunk, algorithm_name)
r = a.runtime
def set_value(name, value):
return a.set_param(name, value)
elif runtime_name:
r = runtime.get(self.splunk, runtime_name)
def set_value(name, value):
old = r.get_param(name)
r.set_param(name, value)
else:
raise Exception("requires algorithm or runtime")
changed_value = False
for name in r.algorithm_param_names:
value = self.get_param(name)
if value is not None:
set_value(name, value)
changed_value = True
if changed_value and algorithm_name:
for d in a.deployments:
d.trigger_deploying()
def handle_GET(self):
algorithm_name = self.get_param("algorithm")
runtime_name = self.get_param("runtime")
include_deployments = is_truthy(self.get_param("include_deployments"))
if include_deployments and not algorithm_name:
raise Exception(
"include_deployments only works with algorithm_name")
if algorithm_name:
a = algorithm_api.get(self.splunk, algorithm_name)
r = a.runtime
get_default = r.get_param
def get_value(name):
return a.get_param(name, inherit=False)
elif runtime_name:
r = runtime.get(self.splunk, runtime_name)
get_default = r.get_param
def get_value(_):
return None
else:
raise Exception("requires algorithm or runtime")
params = []
params.extend([
{
"name": name,
"label": get_label_for_name(name),
"default": get_default(name),
"value": get_value(name),
"type": "text", # "picker" "text",
"mandatory": False,
"important": True,
} for name in r.algorithm_param_names
])
if include_deployments:
for d in deployment.get_all_for_algorithm(self.splunk,
algorithm_name):
e = d.environment
params.extend([
{
"environment":
e.name,
"name":
name,
"label":
get_label_for_name(name),
"default":
deployment.get_default_param(name, e, algorithm=a),
"value":
d.get_param(name, inherit=False),
"type":
"text", # "picker" "text",
"mandatory":
False,
"important":
True,
} for name in r.deployment_param_names
])
self.send_entries(params)
def handle_POST(self):
algorithm_name = self.get_param("name")
runtime_name = self.get_param("runtime")
if not algorithm_name:
raise Exception("missing name")
if algorithm_api.exists(self.splunk, algorithm_name):
raise Exception("algo already exist")
r = runtime.get(self.splunk, runtime_name)
a = algorithm_api.create(self.splunk, algorithm_name, r.name)
source_code = self.get_param("source_code")
if source_code:
a.update_source_code(code=source_code, )
def get(splunk, algorithm_name):
if not exists(splunk, algorithm_name):
raise Exception("algorithm with name %s doesn't exist" %
algorithm_name)
algorithm_stanza = conf.get(splunk)[algorithm_name]
runtime_name = algorithm_stanza["runtime"]
if not runtime.exists(splunk, runtime_name):
raise Exception(
"algorithm '%s' refers to runtime '%s' which is unknown" % (
algorithm_name,
runtime_name,
))
r = runtime.get(splunk, runtime_name)
algorithm_handler = r.algorithm_handler
AlgorithmClass = get_class(algorithm_handler)
return AlgorithmClass(splunk, algorithm_stanza)
def create(splunk, algorithm_name, runtime_name):
if exists(splunk, algorithm_name):
raise Exception("algorithm with name %s already exists" %
algorithm_name)
r = runtime.get(splunk, runtime_name)
stanza = conf.get(splunk).create(algorithm_name)
stanza.submit({
"runtime": runtime_name,
})
stanza.refresh()
algorithm = get(splunk, algorithm_name)
algorithm.update_source_code(
code=r.source_code,
version=1,
)
algorithm.update_deployment_code(
code=r.deployment_code,
version=1,
)
return algorithm
def handle_GET(self):
algorithm_name = self.get_param("algorithm")
runtime_name = self.get_param("runtime")
environment_name = self.get_param("environment")
if algorithm_name and environment_name:
d = deployment.get(self.splunk, algorithm_name, environment_name)
a = d.algorithm
e = d.environment
r = a.runtime
def get_default(name):
return get_default_param(name, e, algorithm=a)
def get_value(name):
return d.get_param(name, inherit=False)
if runtime_name and environment_name:
e = environment.get(self.splunk, environment_name)
r = runtime.get(self.splunk, runtime_name)
def get_default(name):
return get_default_param(name, e, runtime=r)
def get_value(_):
return None
params = [
{
"name": name,
"label": get_label_for_name(name),
"default": get_default(name),
"value": get_value(name),
"type": "text", # "picker" "text",
"mandatory": False,
"important":
True, # True if name == "executor_instance_count" else False,
} for name in r.deployment_param_names
]
self.send_entries(params)
def runtime(self):
if not self._runtime:
self._runtime = runtime.get(self._splunk, self.runtime_name)
return self._runtime