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)