def post(self, request):
obj_pks = json.loads(request.POST.get("obj_pks"))
model_name = request.POST.get("model")
model = getattr(initat.cluster.backbone.models, model_name)
for obj_pk in obj_pks:
obj = model.objects.get(pk=obj_pk)
if hasattr(obj, "enabled"):
obj.enabled = False
obj.save()
if DeleteRequest.objects.filter(obj_pk=obj_pk,
model=model_name).exists():
request.xml_response.error(
"This object is already in the deletion queue.")
else:
del_req = DeleteRequest(obj_pk=obj_pk,
model=model_name,
delete_strategies=request.POST.get(
"delete_strategies", None))
with transaction.atomic():
# save right away, not after request finishes, since cluster server is notified now
del_req.save()
srv_com = server_command.srv_command(command="handle_delete_requests")
contact_server(request,
icswServiceEnum.cluster_server,
srv_com,
log_result=False)
def post(self, request):
# create homedirs
create_user_list = user.objects.exclude(
Q(export=None)
).filter(
Q(home_dir_created=False) & Q(active=True) & Q(group__active=True)
).select_related("export__device")
logger.info("user homes to create: {:d}".format(len(create_user_list)))
for create_user in create_user_list:
logger.info(
"trying to create user_home for '{}' on server {}".format(
str(create_user),
create_user.export.device.full_name,
)
)
srv_com = server_command.srv_command(command="create_user_home")
srv_com["server_key:username"] = create_user.login
_result = contact_server(
request,
icswServiceEnum.cluster_server,
srv_com,
timeout=30,
target_server_id=create_user.export.device_id
)
# force sync_users
request.user.save()
if config_tools.icswServerCheck(service_type_enum=icswServiceEnum.monitor_server).effective_device:
srv_com = server_command.srv_command(command="sync_http_users")
_result = contact_server(request, icswServiceEnum.monitor_server, srv_com)
def post(self, request):
from initat.cluster.backbone.server_enums import icswServiceEnum
_post = request.POST
cd_con_pks = json.loads(_post["cd_pk_list"])
cur_cd_cons = cd_connection.objects.select_related(
"child", "parent").filter(Q(pk__in=cd_con_pks))
command = _post["command"]
logger.info("got hc command '{}' for {}:".format(
command, logging_tools.get_plural("device", len(cd_con_pks))))
for cur_cd_con in cur_cd_cons:
logger.info(" device {} (controlling device: {})".format(
str(cur_cd_con.child), str(cur_cd_con.parent)))
srv_com = server_command.srv_command(command="hard_control")
srv_com["devices"] = srv_com.builder(
"devices", *[
srv_com.builder(
"device",
command=command,
pk="{:d}".format(cur_cd_con.parent_id),
cd_con="{:d}".format(cur_cd_con.pk),
bootserver_hint="{:d}".format(
cur_cd_con.child.bootserver_id),
) for cur_cd_con in cur_cd_cons
])
contact_server(request,
icswServiceEnum.mother_server,
srv_com,
timeout=10)
def post(self, request):
data = json.loads(request.POST["json"])
# salt with user
data["user_idx"] = request.user.idx
srv_com = server_command.srv_command(
command="mon_command",
data=json.dumps(data),
# key_list=data["key_list"]
)
contact_server(request, icswServiceEnum.monitor_server, srv_com)
def post(self, request):
_data = json.loads(request.POST["json"])
_new_state = not _data["current_state"]
# request.xml_response.info("set flag {} to {}".format(_data["name"], _new_state))
srv_com = server_command.srv_command(command="mon_process_handling",
**{_data["name"]: _new_state})
# print srv_com.pretty_print()
contact_server(request,
icswServiceEnum.monitor_server,
srv_com,
timeout=30)
def post(self, request):
_post = request.POST
queue_spec = "{}@{}".format(_post["queue"], _post["host"])
logger.info("{} on {}".format(_post["command"], queue_spec))
srv_com = server_command.srv_command(command="queue_control",
action=_post["command"])
srv_com["queue_list"] = srv_com.builder(
"queue_list", srv_com.builder("queue", queue_spec=queue_spec))
contact_server(request,
icswServiceEnum.rms_server,
srv_com,
timeout=10)
def post(self, request):
_post = request.POST
srv_com = server_command.srv_command(command="job_control",
action="modify_priority")
srv_com["job_list"] = srv_com.builder(
"job_list",
srv_com.builder("job",
job_id=_post["job_id"],
priority=_post["new_pri"]))
contact_server(request,
icswServiceEnum.rms_server,
srv_com,
timeout=10)
def post(self, request):
data = json.loads(request.POST["json"])
import pprint
pprint.pprint(data)
_action = data["action"]["short"]
if _action != "none":
srv_com = server_command.srv_command(command="mon_command",
action=_action,
type=data["type"],
key_list=data["key_list"])
contact_server(request, icswServiceEnum.monitor_server, srv_com)
request.xml_response.info("handled {}".format(data["action"]["long"]))
def post(self, request):
_post = request.POST
c_action = _post["command"]
job_id = ".".join([
entry for entry in [_post["job_id"], _post["task_id"]]
if entry.strip()
])
srv_com = server_command.srv_command(command="job_control",
action=c_action)
srv_com["job_list"] = srv_com.builder(
"job_list", srv_com.builder("job", job_id=job_id))
contact_server(request,
icswServiceEnum.rms_server,
srv_com,
timeout=10)
def post(self, request):
import json
from django.http import HttpResponse
from initat.cluster.backbone.server_enums import icswServiceEnum
from initat.cluster.frontend.helper_functions import contact_server
from initat.tools import server_command
idx_list = request.POST.getlist("idx_list[]", [])
idx_list = [int(item) for item in idx_list]
srv_com = server_command.srv_command(
command="delete_report_history_objects")
srv_com["idx_list"] = json.dumps(idx_list)
(result, _) = contact_server(
request,
icswServiceEnum.report_server,
srv_com,
)
deleted = 0
if result:
deleted = int(result["deleted"].text)
return HttpResponse(json.dumps({'deleted': deleted}))
def post(self, request):
import json
from django.http import HttpResponse
from initat.cluster.backbone.server_enums import icswServiceEnum
from initat.cluster.frontend.helper_functions import contact_server
from initat.tools import server_command
pk_settings, _devices = _init_report_settings(request)
srv_com = server_command.srv_command(command="generate_report")
srv_com['format'] = 'xlsx'
srv_com['pk_settings'] = str(pk_settings)
srv_com['devices'] = str([d.idx for d in _devices])
(result, _) = contact_server(
request,
icswServiceEnum.report_server,
srv_com,
)
if result is not None:
report_id = result.get("report_id")
else:
report_id = 0
return HttpResponse(json.dumps({'report_id': report_id}))
def post(self, request):
_cmd = json.loads(request.POST["cmd"])
# import pprint
# pprint.pprint(_cmd)
logger.info(
"got server_control '{0}' for instance {1} (server_id {2:d})".format(
_cmd["type"],
_cmd["instance"],
int(_cmd["server_id"]),
)
)
srv_com = server_command.srv_command(
command="server_control",
control=_cmd["type"],
services=_cmd["instance"]
)
# cur_routing = routing.SrvTypeRouting()
request.xml_response["result"] = contact_server(
request,
icswServiceEnum.cluster_server,
srv_com,
timeout=10,
connection_id="server_control",
target_server_id=_cmd["server_id"]
)
def post(self, request):
cur_routing = routing.SrvTypeRouting(force=True)
_server_list = []
for _server in cur_routing.resolv_dict.get(icswServiceEnum.cluster_server.name, []):
srv_com = server_command.srv_command(command="server_status")
_res = contact_server(
request,
icswServiceEnum.cluster_server,
srv_com,
timeout=10,
connection_id="server_status",
target_server_id=_server[2],
)
if _res is not None and _res.tree is not None:
# dirty stuff
_res["command"].attrib["server_name"] = _server[0]
_res["command"].attrib["server_id"] = "{:d}".format(_server[2])
_tree = _res.tree
else:
srv_com["command"].attrib["server_name"] = _server[0]
srv_com["command"].attrib["server_id"] = "{:d}".format(_server[2])
_tree = srv_com.tree
for _node in _tree.iter():
if str(_node.tag).startswith("{"):
_node.tag = _node.tag.split("}", 1)[1]
_server_list.append(_tree)
request.xml_response["result"] = _server_list
def post(self, request):
_post = request.POST
if "pk_list" in _post:
pk_list = json.loads(_post["pk_list"])
else:
pk_list = request.POST.getlist("pks[]")
srv_com = server_command.srv_command(command="get_host_config")
srv_com["mode"] = _post["mode"]
srv_com["device_list"] = E.device_list(*[
E.device(
pk="{:d}".format(int(cur_pk)),
only_build="1",
) for cur_pk in pk_list
])
result = contact_server(request,
icswServiceEnum.monitor_server,
srv_com,
timeout=30)
if result:
if _post["mode"] != "fetch":
node_results = result.xpath(".//result", smart_strings=False)
if len(node_results):
request.xml_response["result"] = node_results[0]
else:
request.xml_response.error("no config", logger=logger)
else:
request.xml_response.error("no result", logger=logger)
def reload_searches(request):
srv_com = server_command.srv_command(command="reload_searches")
return contact_server(request,
icswServiceEnum.package_server,
srv_com,
timeout=5,
log_result=False)
def post(self, request):
from initat.cluster.backbone.server_enums import icswServiceEnum
_post = request.POST
if "keys" in _post:
pk_list = json.loads(_post["keys"])
else:
pk_list = [_post["key"]]
srv_com = server_command.srv_command(command="get_config_vars")
srv_com["devices"] = srv_com.builder(
"devices", *[
srv_com.builder("device", pk="{:d}".format(int(cur_pk)))
for cur_pk in pk_list
])
result = contact_server(request,
icswServiceEnum.config_server,
srv_com,
timeout=30,
log_result=False)
if result:
request.xml_response["result"] = E.devices()
for dev_node in result.xpath(".//ns:device", smart_strings=False):
res_node = E.device(dev_node.text, **dev_node.attrib)
for sub_el in dev_node:
res_node.append(sub_el)
request.xml_response["result"].append(res_node)
request.xml_response.log(int(dev_node.attrib["state_level"]),
dev_node.attrib["info_str"],
logger=logger)
def _get_node_rrd(request, dev_pks):
srv_com = server_command.srv_command(command="get_node_rrd")
srv_com["device_list"] = E.device_list(
*[E.device(pk="{:d}".format(int(dev_pk))) for dev_pk in dev_pks],
merge_results="1")
result, _log_lines = contact_server(request,
icswServiceEnum.grapher_server,
srv_com,
timeout=30)
if result is not None:
_log_str, _log_level = result.get_log_tuple()
if _log_level <= logging_tools.LOG_LEVEL_WARN:
node_results = result.xpath(".//ns:result", smart_strings=False)
if len(node_results) and node_results[0].text:
return HttpResponse(node_results[0].text,
content_type="application/json")
else:
return HttpResponse(json.dumps({"error": "no node results"}),
content_type="application/json")
else:
return HttpResponse(json.dumps({"error": _log_str}),
content_type="application/json")
else:
return HttpResponse(json.dumps(
{"error": ", ".join([_line for _level, _line in _log_lines])}),
content_type="application/json")
def post(self, request):
_post = request.POST
img_name = _post["img_name"]
logger.info("use_image called, image_name {}".format(img_name))
srv_com = server_command.srv_command(command="get_image_list")
srv_result = contact_server(request, icswServiceEnum.cluster_server, srv_com, timeout=10, log_result=False)
image.take_image(request.xml_response, srv_result, img_name, logger=logger)
def post(self, request):
srv_com = server_command.srv_command(command="build_host_config", )
result = contact_server(request,
icswServiceEnum.monitor_server,
srv_com,
connection_id="wf_mdrc")
if result:
request.xml_response["result"] = E.devices()
def post(self, request):
# run global fetch command
srv_com = server_command.srv_command(command="fetch_dyn_config", )
result = contact_server(request,
icswServiceEnum.monitor_server,
srv_com,
connection_id="wf_mdrc")
if result:
request.xml_response["result"] = E.devices()
def post(self, request):
srv_com = server_command.srv_command(command="new_config")
result = contact_server(request,
icswServiceEnum.package_server,
srv_com,
timeout=10,
log_result=False)
if result:
# print result.pretty_print()
request.xml_response.info("sent sync to server", logger)
def post(self, request):
from initat.cluster.backbone.server_enums import icswServiceEnum
srv_com = server_command.srv_command(command="get_kpi_source_data")
srv_com['dev_mon_cat_tuples'] = request.POST['dev_mon_cat_tuples']
srv_com['time_range'] = request.POST['time_range']
srv_com['time_range_parameter'] = request.POST['time_range_parameter']
result = contact_server(request, icswServiceEnum.monitor_server, srv_com, log_error=True, log_result=False)
if result:
# print result.pretty_print()
request.xml_response['response'] = result['kpi_set']
def post(self, request):
from initat.cluster.backbone.server_enums import icswServiceEnum
_post = request.POST
dev_pk_list = json.loads(_post["dev_pk_list"])
cur_devs = {
_dev.pk: _dev
for _dev in device.objects.filter(Q(pk__in=dev_pk_list))
}
soft_state = _post["command"]
logger.info("sending soft_control '{}' to {}: {}".format(
soft_state,
logging_tools.get_plural("device", len(dev_pk_list)),
logging_tools.reduce_list(
sorted([str(cur_dev) for cur_dev in cur_devs.values()])),
))
srv_com = server_command.srv_command(command="soft_control")
srv_com["devices"] = srv_com.builder(
"devices", *[
srv_com.builder("device",
soft_command=soft_state,
pk="{:d}".format(cur_dev.pk))
for cur_dev in cur_devs.values()
])
result = contact_server(request,
icswServiceEnum.mother_server,
srv_com,
timeout=10,
log_result=False)
_ok_list, _error_list = (
result.xpath(".//ns:device[@command_sent='1']/@pk"),
result.xpath(".//ns:device[@command_sent='0']/@pk"),
)
if result:
if _ok_list:
request.xml_response.info(
"sent {} to {}".format(
soft_state,
logging_tools.reduce_list(
sorted([
cur_devs[int(_pk)].full_name
for _pk in _ok_list
])),
), logger)
if _error_list:
request.xml_response.warn(
"unable to send {} to {}".format(
soft_state,
logging_tools.reduce_list(
sorted([
cur_devs[int(_pk)].full_name
for _pk in _error_list
])),
), logger)
if not _ok_list and not _error_list:
request.xml_response.warn("nothing to do")
def post(self, request):
_post = request.POST
c_dict = json.loads(_post["change_dict"])
# import pprint
# pprint.pprint(c_dict)
edit_obj = c_dict["edit_obj"]
changed = 0
for cur_pdc in package_device_connection.objects.filter(
Q(pk__in=c_dict["pdc_list"])).prefetch_related(
"kernel_list",
"image_list",
):
change = False
# flags
for f_name in ["force_flag", "nodeps_flag"]:
if f_name in edit_obj and edit_obj[f_name]:
# print "**", f_name, edit_obj[f_name], int(edit_obj[f_name])
t_flag = True if int(edit_obj[f_name]) else False
if t_flag != getattr(cur_pdc, f_name):
setattr(cur_pdc, f_name, t_flag)
change = True
# target state
if edit_obj["target_state"] and edit_obj[
"target_state"] != cur_pdc.target_state:
change = True
cur_pdc.target_state = edit_obj["target_state"]
# dependencies
for dep, dep_obj in [("image", image), ("kernel", kernel)]:
f_name = "{}_dep".format(dep)
if edit_obj[f_name]:
_set = True if int(edit_obj[f_name]) else False
if _set != getattr(cur_pdc, f_name):
setattr(cur_pdc, f_name, _set)
change = True
if edit_obj["{}_change".format(dep)]:
l_name = "{}_list".format(dep)
new_list = dep_obj.objects.filter(
Q(pk__in=edit_obj[l_name]))
setattr(cur_pdc, l_name, new_list)
change = True
if change:
changed += 1
cur_pdc.save()
request.xml_response.info(
"{} updated".format(logging_tools.get_plural("PDC", changed)),
logger)
srv_com = server_command.srv_command(command="new_config")
result = contact_server(request,
icswServiceEnum.package_server,
srv_com,
timeout=10,
log_result=False)
if result:
# print result.pretty_print()
request.xml_response.info("sent sync to server", logger)
def post(self, request):
_post = request.POST
srv_com = server_command.srv_command(command="rescan_kernels")
_srv_result = contact_server(
request,
icswServiceEnum.mother_server,
srv_com,
timeout=180,
log_result=True,
split_send=False
)
def post(self, request):
_pk = int(request.POST["pk"])
srv_com = server_command.srv_command(
command="trigger_sensor_threshold")
srv_com["sensor_threshold"] = E.sensor_threshold(
pk="{:d}".format(_pk),
type=request.POST["type"],
)
_result = contact_server(request,
icswServiceEnum.collectd_server,
srv_com,
timeout=30)
def post(self, request):
_post = request.POST
srv_com = server_command.srv_command(command="get_license_usage")
result = contact_server(request, icswServiceEnum.rms_server, srv_com, timeout=10)
_lic_dump = {}
if result is not None:
result = result.tree
# not needed
# _start_node = result.xpath(".//*[local-name() = 'license_usage']")
# if len(_start_node):
# _lic_dump = _dump_xml(_start_node[0])
request.xml_response["result"] = result
def post(self, request):
lic_file = request.FILES['license_file']
lic_file_content = lic_file.read()
try:
reader = LicenseFileReader(lic_file_content)
except LicenseFileReader.InvalidLicenseFile as e:
request.xml_response.error(unicode(e), logger=logger)
else:
if License.objects.license_exists(lic_file_content):
request.xml_response.warn(
"This license file has already been uploaded")
else:
local_cluster_id = device_variable.objects.get_cluster_id()
file_cluster_ids = reader.get_referenced_cluster_ids()
if local_cluster_id not in file_cluster_ids:
msg = "\n".join([
u"This license file contains licenses for the following clusters: {}"
.format(", ".join(file_cluster_ids)),
u"This cluster has the id {}.".format(
local_cluster_id),
])
request.xml_response.error(msg)
else:
new_lic = License(file_name=lic_file.name,
license_file=lic_file_content)
new_lic.save()
request.xml_response.info(
"Successfully uploaded license file: {}".format(
unicode(new_lic)))
srv_com = server_command.srv_command(
command="check_license_violations")
contact_server(request,
icswServiceEnum.cluster_server,
srv_com,
timeout=60,
log_error=True,
log_result=False)
def post(self, request):
from initat.cluster.backbone.server_enums import icswServiceEnum
data = json.loads(request.POST.get("data"))
# import pprint
# pprint.pprint(data)
for del_struct in data: # obj_pk in obj_pks:
model_name = del_struct["model_name"]
model = apps.get_model("backbone", model_name)
try:
obj = model.objects.get(pk=del_struct["pk"])
except model.DoesNotExist:
request.xml_response.error(
"The {} with pk {} does not exist".format(
model_name,
del_struct["pk"]
)
)
else:
if hasattr(obj, "enabled"):
obj.enabled = False
obj.save(update_fields=["enabled"])
if DeleteRequest.objects.filter(
Q(obj_pk=del_struct["pk"]) &
Q(model=model_name)
).exists():
request.xml_response.error("This object is already in the deletion queue.")
else:
del_req = DeleteRequest(
obj_pk=del_struct["pk"],
model=model_name,
delete_strategies=json.dumps(del_struct["delete_strategies"]),
)
with transaction.atomic():
# save right away, not after request finishes, since cluster server is notified now
del_req.save()
srv_com = server_command.srv_command(command="handle_delete_requests")
contact_server(request, icswServiceEnum.cluster_server, srv_com, log_result=False)
def post(self, request):
_post = request.POST
part_dev = device.objects.get(Q(pk=_post["pk"]))
logger.info("reading partition info from %s" % (unicode(part_dev)))
srv_com = server_command.srv_command(command="fetch_partition_info")
_dev_node = srv_com.builder("device")
_dev_node.attrib.update({
"pk": "{:d}".format(part_dev.pk),
})
srv_com["devices"] = _dev_node
_result = contact_server(request,
icswServiceEnum.discovery_server,
srv_com,
timeout=30)
