def get(self, request, *args, **kwargs): """Return form for adding a remotepower.""" fqdn = request.GET.get('fqdn', None) try: result = get_machine(fqdn, redirect_to='api:remotepower_add', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json if machine.has_remotepower(): return InfoMessage("Machine has already a remote power.").as_json form = RemotePowerAPIForm(machine=machine) input = InputSerializer(form.as_dict(), self.URL_POST.format(fqdn=machine.fqdn), form.get_order()) return input.as_json
def get(self, request, *args, **kwargs): """Dispatcher for the 'delete' command.""" arguments = request.GET.get('args', None) if arguments: arguments = arguments.split() item = arguments[0].lower() sub_arguments = arguments[1:] else: return ErrorMessage("Item is missing!").as_json if item == Delete.MACHINE: if sub_arguments: return ErrorMessage( "Invalid number of arguments for 'machine'!").as_json return redirect(reverse('api:machine_delete')) elif item == Delete.SERIALCONSOLE: if sub_arguments: return ErrorMessage( "Invalid number of arguments for 'serialconsole'!").as_json return redirect(reverse('api:serialconsole_delete')) elif item == Delete.REMOTEPOWER: if sub_arguments: return ErrorMessage( "Invalid number of arguments for 'remotepower'!").as_json return redirect(reverse('api:remotepower_delete')) return ErrorMessage("Unknown item '{}'!".format(item)).as_json
def post(self, request, *args, **kwargs): """Add remotepowerdevice.""" if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json data = json.loads(request.body.decode('utf-8'))['form'] form = RemotePowerDeviceAPIForm(data) if form.is_valid(): cleaned_data = form.cleaned_data new_device = RemotePowerDevice(username=cleaned_data['username'], password=cleaned_data['password'], mac=cleaned_data['mac'], fqdn=cleaned_data['fqdn']) try: new_device.save() except Exception as e: logger.exception(e) return ErrorMessage("Something went wrong!").as_json return Message('Ok.').as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def get(self, request, *args, **kwargs): """Perform machine setup.""" fqdn = request.GET.get('fqdn', None) option_or_choice = request.GET.get('option_or_choice', None) choice = None try: result = get_machine(fqdn, redirect_to='api:setup', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if option_or_choice.lower() == 'list': return self._list(request, machine) else: choice = option_or_choice return self._setup(request, machine, choice) return ErrorMessage("Something went wrong!").as_json
def post(self, request, fqdn, *args, **kwargs): """Add annotation to machine.""" try: result = get_machine(fqdn, redirect_to='api:annotation_add', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json data = json.loads(request.body.decode('utf-8'))['form'] form = AnnotationAPIForm(data, machine=machine) if form.is_valid(): try: cleaned_data = form.cleaned_data annotation = Annotation(machine_id=machine.pk, reporter=request.user, text=cleaned_data['text']) annotation.save() except Exception as e: logger.exception(e) return ErrorMessage("Something went wrong!").as_json return Message('Ok.').as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def _setup(self, request, machine, distribution): """Trigger machine setup for `machine` with `distribution`.""" if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json machinegroup = None if machine.group and not machine.group.setup_use_architecture: machinegroup = machine.group.name valid = machine.fqdn_domain.is_valid_setup_choice( distribution, machine.architecture.name, machinegroup=machinegroup) if not valid: return ErrorMessage( "Unknown choice '{}'! Use 'SETUP <fqdn> list'.".format( distribution)).as_json try: result = machine.setup(distribution) if result: message = "OK." if not machine.has_remotepower(): message += " This machine has no remote power - "\ "a manuall reboot may be required." return Message(message).as_json else: return ErrorMessage( "Machine has no setup capability! Please contact '{}'.". format(machine.get_support_contact())).as_json except Exception as e: return ErrorMessage(str(e)).as_json
def post(self, request, *args, **kwargs): """Add machine.""" if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json data = json.loads(request.body.decode('utf-8'))['form'] form = MachineAPIForm(data) if form.is_valid(): cleaned_data = form.cleaned_data mac_address = cleaned_data['mac_address'] del cleaned_data['mac_address'] hypervisor = None if cleaned_data['hypervisor_fqdn']: hypervisor = Machine.objects.get( fqdn=cleaned_data['hypervisor_fqdn']) del cleaned_data['hypervisor_fqdn'] new_machine = Machine(**cleaned_data) new_machine.hypervisor = hypervisor new_machine.mac_address = mac_address try: new_machine.save() except Exception as e: logger.exception(e) return ErrorMessage("Something went wrong!").as_json return Message('Ok.').as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def get(self, request, *args, **kwargs): """Trigger regeneration of machine-related/service files.""" fqdn = request.GET.get('fqdn', None) option = request.GET.get('option', None) service = request.GET.get('service', None) if service and (service.lower() in {Regenerate.COBBLER, Regenerate.SERIALCONSOLE}): if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!" ).as_json # regenerate Cobbler entries if service.lower() == Regenerate.COBBLER: signal_cobbler_regenerate.send(sender=None, domain_id=None) return Message("Regenerate Cobbler entries...").as_json # regenerate serial console entries iterating over all cscreen servers elif service.lower() == Regenerate.SERIALCONSOLE: machines = SerialConsole.objects.all().values_list( 'cscreen_server__fqdn', flat=True) for fqdn in machines.distinct(): signal_serialconsole_regenerate.send( sender=None, cscreen_server_fqdn=fqdn) return Message("Regenerate serial console entries...").as_json elif (fqdn is not None) and (option is not None): try: result = get_machine(fqdn, redirect_to='api:regenerate', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if option.lower() != Regenerate.MOTD: return ErrorMessage( "Unknown option '{}'!".format(option)).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json try: if option.lower() == Regenerate.MOTD: machine.update_motd(user=request.user) return Message("OK.").as_json except Exception as e: return ErrorMessage(str(e)).as_json return ErrorMessage("Unknown service '{}'!".format(service)).as_json
def get(self, request, *args, **kwargs): """Return reservation history of machine.""" fqdn = request.GET.get('fqdn', None) option = request.GET.get('option', None) try: result = get_machine(fqdn, redirect_to='api:rescan', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if option not in MachineCheck.Scan.Action.as_list: return ErrorMessage("Unknown option '{}'!".format(option)).as_json try: machine.scan(option) if not machine.collect_system_information: return InfoMessage( "Collecting system information is disabled for this machine." ).as_json except Exception as e: return ErrorMessage(str(e)).as_json return Message("OK.").as_json
def post(self, request, *args, **kwargs): """Delete machine.""" if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json data = json.loads(request.body.decode('utf-8'))['form'] form = DeleteMachineAPIForm(data) if form.is_valid(): try: cleaned_data = form.cleaned_data machine = Machine.objects.get( fqdn__iexact=cleaned_data['fqdn']) if machine.is_virtual_machine(): host = machine.get_hypervisor() if host.virtualization_api is None: return ErrorMessage( "No virtualization API found!").as_json if host.virtualization_api.remove(machine): result = machine.delete() else: result = machine.delete() theader = [ { 'objects': 'Deleted objects' }, { 'count': '#' }, ] response = { 'header': { 'type': 'TABLE', 'theader': theader }, 'data': [], } for key, value in result[1].items(): response['data'].append({ 'objects': key.replace('data.', ''), 'count': value }) return JsonResponse(response) except Exception as e: logger.exception(e) return ErrorMessage("Something went wrong!").as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def post(self, request, architecture, *args, **kwargs): """Add virtual machine for specific `architecture`.""" data = json.loads(request.body.decode('utf-8'))['form'] try: host = Machine.api.get(fqdn__iexact=data['host'], vm_dedicated_host=True) except Machine.DoesNotExist: return ErrorMessage("Host doesn't exist!").as_json except Exception as e: return ErrorMessage(str(e)).as_json if not host.virtualization_api: return ErrorMessage("No virtualization API available!").as_json form = VirtualMachineAPIForm( data, virtualization_api=host.virtualization_api) if form.is_valid(): try: vm = host.virtualization_api.create(**form.cleaned_data) vm.reserve(reason='VM of {}'.format(request.user), until=add_offset_to_date(30), user=request.user) theader = [ { 'fqdn': 'FQDN' }, { 'mac_address': 'MAC address' }, ] if vm.vnc['enabled']: theader.append({'vnc': 'VNC'}) response = { 'header': { 'type': 'TABLE', 'theader': theader }, 'data': [{ 'fqdn': vm.fqdn, 'mac_address': vm.mac_address }], } if vm.vnc['enabled']: response['data'][0]['vnc'] = '{}:{}'.format( host.fqdn, vm.vnc['port']) return JsonResponse(response) except Exception as e: return ErrorMessage(str(e)).as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def get(self, request, *args, **kwargs): """Show server configuration.""" if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json config = ServerConfig.objects.all() if config.count() == 0: return InfoMessage("No configurations available.").as_json theader = [{'key': 'Key'}, {'value': 'Value'}] response = { 'header': { 'type': 'TABLE', 'theader': theader }, 'data': [] } for item in config: response['data'].append({'key': item.key, 'value': item.value}) return JsonResponse(response)
def get(self, request, *args, **kwargs): """Return form for adding a virtual machine.""" architectures = self._get_available_architectures() architecture = request.GET.get('arch', None) if architecture.lower() not in architectures: return Message("Available architectures: {}".format( '|'.join(architectures))).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json hosts = Machine.api.filter(vm_dedicated_host=True, architecture__name=architecture) host = None for host_ in hosts: if host_.virtualization_api and ( host_.get_virtual_machines().count() < host_.vm_max): host = host_ break if host is None: return ErrorMessage("No virtual machine hosts left!").as_json form = VirtualMachineAPIForm( virtualization_api=host.virtualization_api) input = InputSerializer(form.as_dict(host), self.URL_POST.format(arch=architecture), form.get_order()) return input.as_json
def _list(self, request, machine): """Return list of available distributions for `machine`.""" machinegroup = None if not machine.has_setup_capability(): return InfoMessage("Machine has no setup capability.").as_json if machine.group and not machine.group.setup_use_architecture: machinegroup = machine.group.name grouped_records = machine.fqdn_domain.get_setup_records( machine.architecture.name, machinegroup=machinegroup) if not grouped_records: return ErrorMessage("No setup records found!").as_json response = '' theader = [{'full': 'Available Distributions'}] response = { 'header': { 'type': 'TABLE', 'theader': theader }, 'data': [] } for distribution, records in grouped_records.items(): logger.info("Distros: {} - records: {}".format( distribution, records)) for record in records: response['data'].append({ 'full': distribution + ':' + record, }) return JsonResponse(response)
def get(self, request, *args, **kwargs): """Return reservation form for valid machine.""" fqdn = request.GET.get('fqdn', None) try: result = get_machine(fqdn, redirect_to='api:reserve', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json form = ReserveMachineAPIForm(username=request.user.username, reason=machine.reserved_reason) input = InputSerializer(form.as_dict(), self.URL_POST.format(id=machine.pk), form.get_order()) return input.as_json
def get(self, request, *args, **kwargs): """Return form for adding an annotation.""" fqdn = request.GET.get('fqdn', None) try: result = get_machine( fqdn, redirect_to='api:annotation_add', data=request.GET ) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json form = AnnotationAPIForm(machine=machine) input = InputSerializer( form.as_dict(), self.URL_POST.format(fqdn=machine.fqdn), form.get_order() ) return input.as_json
def get(self, request, *args, **kwargs): """Return machine information.""" fqdn = request.GET.get('fqdn', None) response = {} try: result = get_machine(fqdn, redirect_to='api:machine', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json machine.enclosure.fetch_location(machine.pk) machine = MachineSerializer(machine) order = [ 'fqdn', 'architecture', 'ipv4', 'ipv6', 'serial_number', 'product_code', 'comment', 'nda', None, 'system', 'enclosure', 'group', None, 'location_room', 'location_rack', 'location_rack_position', None, 'reserved_by', 'reserved_reason', 'reserved_at', 'reserved_until', None, 'status_ipv4', 'status_ipv6', 'status_ssh', 'status_login', None, 'cpu_model', 'cpu_id', 'cpu_physical', 'cpu_cores', 'cpu_threads', 'cpu_flags', 'ram_amount', None, 'serial_type', 'serial_cscreen_server', 'serial_management_bmc', 'serial_console_server', 'serial_device', 'serial_port', 'serial_command', 'serial_comment', 'serial_baud_rate', 'serial_kernel_device', None, 'power_type', 'power_management_bmc', 'power_host', 'power_port', 'power_device', 'power_comment', None, 'bmc_fqdn', 'bmc_mac', 'bmc_username', 'bmc_password', [ 'installations', [ 'distribution', 'active', 'partition', 'architecture', 'kernelversion' ] ], [ 'networkinterfaces', [ 'mac_address', 'name', 'ethernet_type', 'driver_module', 'primary', ] ], ['annotations', ['text', 'reporter', 'created']] ] response['header'] = {'type': 'INFO', 'order': order} response['data'] = machine.data_info return JsonResponse(response)
def post(self, request, id, *args, **kwargs): """Process reservation.""" try: machine = Machine.objects.get(pk=id) except Machine.DoesNotExist: return ErrorMessage("Machine doesn't exist!").as_json try: data = json.loads(request.body.decode('utf-8'))['form'] if data['until'] == 0 and request.user.is_superuser: # set to 'infinite' data['until'] = datetime.date.max else: # set 'until' field (=offset) to concrete date for form validation data['until'] = add_offset_to_date(data['until'], as_string=True) form = ReserveMachineAPIForm(data) except (KeyError, ValueError): return ErrorMessage("Data format is invalid!").as_json if form.is_valid(): reason = form.cleaned_data['reason'] until = form.cleaned_data['until'] username = form.cleaned_data['username'] try: user = User.objects.get(username=username) except Exception: return ErrorMessage("User doesn't exist!").as_json try: machine.reserve(reason, until, user=request.user, reserve_for_user=user) return Message('OK.').as_json except Exception as e: return ErrorMessage(str(e)).as_json else: return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def post(self, request, *args, **kwargs): """Return query result.""" response = {} try: query_str = json.loads(request.body.decode('utf-8'))['data'] except (KeyError, ValueError): return ErrorMessage("Data format is invalid!").as_json try: query = APIQuery(query_str) query.execute(user=request.user) except APIQuery.EmptyResult as e: return InfoMessage(str(e)).as_json except Exception as e: return ErrorMessage(str(e)).as_json response['header'] = {'type': 'TABLE', 'theader': query.get_theader()} response['data'] = query.data return JsonResponse(response, safe=False)
def get(self, request, *args, **kwargs): """Return reservation history of machine.""" fqdn = request.GET.get('fqdn', None) try: result = get_machine(fqdn, redirect_to='api:history', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json history = ReservationHistory.objects.filter(machine__fqdn=machine.fqdn) if history.count() == 0: return InfoMessage("No history available yet.").as_json theader = [{ 'user': '******' }, { 'at': 'Reserved at' }, { 'until': 'Reserved until' }, { 'reason': 'Reason' }] response = { 'header': { 'type': 'TABLE', 'theader': theader }, 'data': [] } for item in history: response['data'].append({ 'user': item.reserved_by, 'at': item.reserved_at, 'until': item.reserved_until, 'reason': item.reserved_reason.replace('\n', '') }) return JsonResponse(response)
def get(self, request, *args, **kwargs): """Return form for deleting a remote power.""" if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json form = DeleteRemotePowerAPIForm() input = InputSerializer(form.as_dict(), self.URL_POST, form.get_order()) return input.as_json
def post(self, request, *args, **kwargs): """Add remote power to machine.""" if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json try: fqdn = request.path.split("/")[-1] result = get_machine(fqdn, redirect_to='api:remotepower_add', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if machine.has_remotepower(): return InfoMessage("Machine has already a remote power.").as_json data = json.loads(request.body.decode('utf-8'))['form'] form = RemotePowerAPIForm(data, machine=machine) if form.is_valid(): try: remotepower = RemotePower(**form.cleaned_data) remotepower.save() except Exception as e: logger.exception(e) return ErrorMessage("Something went wrong!").as_json return Message('Ok.').as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def post(self, request, *args, **kwargs): """Add BMC to machine.""" try: fqdn = request.path.split("/")[-1] result = get_machine(fqdn, redirect_to='api:bmc_add', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json data = json.loads(request.body.decode('utf-8'))['form'] form = BMCAPIForm(data, machine=machine) if form.is_valid(): try: cleaned_data = form.cleaned_data bmc = BMC(machine=machine, fqdn=cleaned_data['fqdn'], mac=cleaned_data['mac'], username=cleaned_data['username'], password=cleaned_data['password'], fence_name=cleaned_data['fence_name']) bmc.save() except Exception as e: logger.exception(e) return ErrorMessage("Something went wrong!").as_json return Message('Ok.').as_json return ErrorMessage("\n{}".format( format_cli_form_errors(form))).as_json
def get(self, request, *args, **kwargs): """Release a machine.""" fqdn = request.GET.get('fqdn', None) try: result = get_machine(fqdn, redirect_to='api:release', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json try: machine.release(user=request.user) return Message('OK.').as_json except Exception as e: return ErrorMessage(str(e)).as_json
def get(self, request, *args, **kwargs): """Dispatcher for the 'add' command.""" arguments = request.GET.get('args', None) if arguments: arguments = arguments.split() item = arguments[0].lower() sub_arguments = arguments[1:] else: return ErrorMessage("Item is missing!").as_json if item == Add.VIRTUALMACHINE: if len(sub_arguments) != 1: return ErrorMessage("Invalid number of arguments for 'virtualmachine'!").as_json return redirect('{}?arch={}'.format(reverse('api:vm_add'), sub_arguments[0])) elif item == Add.MACHINE: if sub_arguments: return ErrorMessage("Invalid number of arguments for 'machine'!").as_json return redirect(reverse('api:machine_add')) elif item == Add.SERIALCONSOLE: if len(sub_arguments) != 1: return ErrorMessage("Invalid number of arguments for 'serialconsole'!").as_json return redirect('{}?fqdn={}'.format(reverse('api:serialconsole_add'), sub_arguments[0])) elif item == Add.ANNOTATION: if len(sub_arguments) != 1: return ErrorMessage("Invalid number of arguments for 'annotation'!").as_json return redirect('{}?fqdn={}'.format(reverse('api:annotation_add'), sub_arguments[0])) elif item == Add.REMOTEPOWER: if len(sub_arguments) != 1: return ErrorMessage("Invalid number of arguments for 'remotepower'!").as_json return redirect('{}?fqdn={}'.format(reverse('api:remotepower_add'), sub_arguments[0])) return ErrorMessage("Unknown item '{}'!".format(item)).as_json
def get(self, request, *args, **kwargs): """Perform machine power cycle.""" fqdn = request.GET.get('fqdn', None) action = request.GET.get('action', None) if action.lower() not in RemotePower.Action.as_list: return ErrorMessage("Unknown action '{}'!".format(action)).as_json try: result = get_machine(fqdn, redirect_to='api:powercycle', data=request.GET) if isinstance(result, Serializer): return result.as_json elif isinstance(result, HttpResponseRedirect): return result machine = result except Exception as e: return ErrorMessage(str(e)).as_json if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json if not machine.has_remotepower(): return ErrorMessage("Machine has no remote power!").as_json try: result = machine.powercycle(action.lower(), user=request.user) if action.lower() == RemotePower.Action.STATUS: return Message("Status: {} ({})".format( result.capitalize(), machine.remotepower.name)).as_json if result: return Message("OK.").as_json else: return ErrorMessage("Something went wrong!").as_json except Exception as e: return ErrorMessage(str(e)).as_json return ErrorMessage("Something went wrong!").as_json
def get(self, request, *args, **kwargs): """Trigger regeneration of machine-related/service files.""" service = request.GET.get('service', None) fqdn = request.GET.get('fqdn', None) machine = None if isinstance(request.user, AnonymousUser) or not request.auth: return AuthRequiredSerializer().as_json if not request.user.is_superuser: return ErrorMessage( "Only superusers are allowed to perform this action!").as_json if not service: return ErrorMessage("Service not set").as_json if fqdn: try: machine = get_machine(fqdn, redirect_to='api:regenerate', data=request.GET) if not machine: return ErrorMessage( "machine {} not found".format(fqdn)).as_json if isinstance(machine, Serializer): return machine.as_json elif isinstance(machine, HttpResponseRedirect): return machine except Exception as e: return ErrorMessage(str(e)).as_json # regenerate Cobbler entries if service.lower() == RegenerateCommand.COBBLER: domain_id = None if fqdn: domain = get_domain(fqdn) if not domain: return ErrorMessage("No domain found for machine: " + fqdn).as_json o_domain = Domain.objects.get(name=domain) if not o_domain: return ErrorMessage("No orthos domain found for domain: " + domain).as_json domain_id = getattr(o_domain, 'id', None) if not domain_id: return ErrorMessage( "Could not find id for orthos domain: " + domain).as_json msg = 'domain ' + domain else: domain = None msg = 'all domains' signal_cobbler_regenerate.send(sender=None, domain_id=domain_id) return Message("Regenerate Cobbler entries for " + msg).as_json # regenerate serial console entries iterating over all cscreen servers elif service.lower() == RegenerateCommand.SERIALCONSOLE: machines = SerialConsole.objects.all().values_list( 'cscreen_server__fqdn', flat=True) if fqdn: if fqdn in machines.distinct(): signal_serialconsole_regenerate.send( sender=None, cscreen_server_fqdn=fqdn) msg = fqdn else: return ErrorMessage("Not a serial console server: " + fqdn).as_json else: msg = '' for fqdn in machines.distinct(): signal_serialconsole_regenerate.send( sender=None, cscreen_server_fqdn=fqdn) msg += ' ' + fqdn return Message( "Regenerated serial console entries for serial console servers: " + msg).as_json # regenerate MOTD (only works per machine atm) elif service.lower() == RegenerateCommand.MOTD: if not fqdn: return Message("regenerte motd needs fqdn parameter").as_json machine.update_motd(user=request.user) return Message("OK.").as_json else: return ErrorMessage("Unknown service {}".format(service)).as_json return ErrorMessage("Unknown error - params: {} - {}".format( service, fqdn)).as_json