redfish-ctl 1.1.0__py3-none-any.whl

idrac_ctl/__init__.py

@@ -0,0 +1,18 @@
+"""idrac_ctl — backward-compatible alias for the redfish_ctl package.
+
+The tool was renamed ``idrac_ctl`` -> ``redfish_ctl``. This shim keeps
+``import idrac_ctl`` and ``from idrac_ctl.<submodule> import ...`` working (resolving
+to the same objects as ``redfish_ctl``) for existing callers. New code should import
+``redfish_ctl``. See .internal/REDFISH_CTL_RENAME_PLAN.md.
+"""
+import importlib
+import sys
+
+# Import the real package (registers the whole command tree via __init_subclass__),
+# then alias it and every submodule under the legacy idrac_ctl name using the SAME
+# module objects, so identities hold across both names.
+_real = importlib.import_module("redfish_ctl")
+
+for _name, _mod in list(sys.modules.items()):
+    if _name == "redfish_ctl" or _name.startswith("redfish_ctl."):
+        sys.modules["idrac_ctl" + _name[len("redfish_ctl"):]] = _mod

redfish_ctl/__init__.py

@@ -0,0 +1,146 @@
+# ruff: noqa: F403, I001
+# from bios import BiosQuery
+# from hardware import HardwareInventorQuery
+from .redfish_shared import *
+
+from .system.cmd_system import *
+from .system.cmd_system_config import *
+from .system.cmd_system_import import *
+#
+from .cmd_boot import *
+from .dell_lc.cmd_dell_lc_api import *
+from .dell_lc.cmd_dell_lc_rs import *
+from .dell_lc.cmd_dell_lc_services import *
+#
+# compute
+from .compute.cmd_power_state import *
+from .compute.cmd_compute_setting import *
+
+from .idrac_shared import *
+from .raid.cmd_raid_service import *
+#
+# bios commands
+from .bios.cmd_bios import *
+from .bios.cmd_bios_clear_pending import *
+from .bios.cmd_bios_pending import *
+from .bios.cmd_change_boot_order import *
+from .bios.bios_registry import *
+from .bios.cmd_change_bios import *
+from .bios.cmd_bios_snapshot import *
+from .bios.cmd_bios_reset_default import *
+#
+from .attribute.cmd_attribute import *
+from .attribute.cmd_attribute_clear_pending import *
+from .attribute.cmd_attribute_update import *
+#
+#
+# # jobs command
+from .jobs.cmd_jobs import *
+from .jobs.cmd_job_get import *
+from .jobs.cmd_job_services import *
+from .jobs.cmd_job_watch import *
+from .jobs.cmd_job_del import *
+from .jobs.cmd_job_dell_services import *
+from .jobs.cmd_job_delete_all import *
+from .jobs.cmd_job_apply import *
+#
+# # firmwares cmds
+from .firmware.cmd_firmware import *
+from .firmware.cmd_firmware_inv import *
+
+from .pci.cmd_pci import *
+
+# manager cmds
+from .manager.cmd_manager import *
+from .manager.cmd_manager_reset import *
+
+
+# virtual medial cmds
+from .virtual_media.cmd_virtual_media_get import *
+from .virtual_media.cmd_virtual_media_insert import *
+from .virtual_media.cmd_virtual_media_eject import *
+from .virtual_media.cmd_smc_virtual_media import *
+from .cmd_current_boot import *
+
+from .cmd_query import *
+from .cmd_wait import *
+
+# storage
+from .storage.cmd_storage_controllers import *
+from .storage.cmd_storage_list import *
+from .storage.cmd_storage_get import *
+from .storage.cmd_drives import *
+from .storage.cmd_convert_none_raid import *
+from .storage.cmd_convert_to_raid import *
+
+# chassis cmd
+from .chassis.cmd_chassis_query import *
+from .chassis.cmd_chasis_reset import *
+from .sensors.cmd_sensors import *
+from .telemetry.cmd_metric_reports import *
+from .telemetry.cmd_metric_definitions import *
+from .telemetry.cmd_exporter import *
+from .component_integrity.cmd_component_integrity import *
+from .network.cmd_network_adapters import *
+from .ports.cmd_nvlink_ports import *
+from .actions.cmd_action_list import *
+from .events.cmd_event_submit_test import *
+from .compute.cmd_system_reset import *
+from .logs.cmd_logs import *
+from .network.cmd_ethernet_interfaces import *
+from .security.cmd_secure_boot import *
+from .firmware.cmd_firmware_update import *
+from .telemetry.cmd_telemetry_triggers import *
+from .network.cmd_network_ports import *
+from .oem.cmd_oem_info import *
+from .manager.cmd_console_info import *
+from .serial_console.cmd_serial_console import *
+from .manager.cmd_manager_time import *
+from .chassis.cmd_chassis_query import *
+
+# dell oem attach
+from .delloem.delloem_attach_status import *
+from .delloem.delloem_actions import *
+from .delloem.delloem_attach import *
+from .delloem.delloem_detach import *
+from .delloem.delloem_disconnect import *
+from .delloem.delloem_get_networkios import *
+from .delloem.delloem_boot_netios import *
+from .delloem.delloem_os_deployment import *
+
+
+# tasks
+from .tasks.cmd_tasks_list import *
+from .tasks.cmd_tasks_get import *
+from .tasks.cmd_task_watch import *
+
+from .volumes.cmd_initilize import *
+from .volumes.cmd_volumes import *
+from .volumes.cmd_virtual_disk import *
+
+# boot options
+from .boot_options.cmd_boot_option_list import *
+from .boot_options.cmd_boot_options_query import *
+
+
+# boot sources
+from .boot_source.cmd_boot_one_shot import *
+from .boot_source.cmd_boot_settings import *
+from .boot_source.cmd_boot_source_get import *
+from .boot_source.cmd_clear_pending import *
+from .boot_source.cmd_pending import *
+from .boot_source.cmd_enable import *
+from .boot_source.cmd_update import *
+from .boot_source.cmd_boot_source_registry import *
+from .boot_source.cmd_boot_state import *
+
+# account
+from .accounts.cmd_accounts import *
+from .accounts.cmd_account_manage import *
+from .accounts.cmd_account_sshkey import *
+from .accounts.cmd_query_account import *
+from .accounts.cmd_account_svc import *
+from .accounts.cmd_privilage_registry import *
+
+from .discovery.cmd_discovery import *
+from .discovery.cmd_bmc_scan import *

redfish_ctl/__main__.py

@@ -0,0 +1,3 @@
+from redfish_ctl.redfish_main import redfish_main_ctl
+if __name__ == "__main__":
+    redfish_main_ctl()

redfish_ctl/accounts/cmd_account_manage.py

@@ -0,0 +1,198 @@
+"""Create, update, and delete Redfish accounts (ManagerAccount).
+
+    redfish_ctl account-create --username test --password '***' --role ReadOnly --confirm
+    redfish_ctl account-update --username test --role Operator --confirm
+    redfish_ctl account-delete --username test --confirm
+
+Vendor-neutral: create POSTs to the AccountService ``Accounts`` collection,
+update PATCHes ``Accounts/<id>``, delete DELETEs it — all standard Redfish that
+works on Dell/HPE/Supermicro/generic. Every command is **dry-run by default**
+(it prints the intended change, password masked, and writes nothing) and only
+mutates with ``--confirm``. Delete additionally refuses to remove the account
+you are logged in as, so a misfire can never lock you out.
+
+Author Mus spyroot@gmail.com
+"""
+from abc import abstractmethod
+from typing import Optional, Tuple
+
+from ..idrac_manager import IDracManager
+from ..idrac_shared import IDRAC_API, ApiRequestType, Singleton
+from ..redfish_manager import CommandResult
+
+# RoleId is the standard Redfish privilege model (present on Dell/HPE/Supermicro).
+DEFAULT_ROLE = "ReadOnly"
+
+
+def build_create_payload(username: str, password: str, role: str) -> dict:
+    """Build the POST body that creates a ManagerAccount."""
+    return {"UserName": username, "Password": password, "RoleId": role or DEFAULT_ROLE}
+
+
+def build_update_payload(password: Optional[str],
+                         role: Optional[str],
+                         enabled: Optional[bool]) -> dict:
+    """Build a PATCH body from only the fields the caller actually set."""
+    payload: dict = {}
+    if password is not None:
+        payload["Password"] = password
+    if role is not None:
+        payload["RoleId"] = role
+    if enabled is not None:
+        payload["Enabled"] = enabled
+    return payload
+
+
+def _mask(payload: dict) -> dict:
+    """Return a copy of a payload with the Password value masked for display."""
+    return {k: ("***" if k == "Password" else v) for k, v in payload.items()}
+
+
+class _AccountBase(IDracManager):
+    """Shared account resolution for the write commands."""
+
+    def _resolve_account(self, username: Optional[str],
+                         account_id: Optional[str]) -> Tuple[Optional[str], dict]:
+        """Find an account by UserName or Id; return (uri, data) or (None, {}).
+
+        Reads the Accounts collection and each member (vendor-neutral — it never
+        assumes an id scheme), so it matches on the real ``UserName``/``Id``. The
+        collection is fetched WITHOUT ``$expand`` because some services (HPE iLO 5)
+        reject an expanded Accounts query with HTTP 400; each member is fetched
+        individually instead.
+        """
+        coll = (self.base_query(IDRAC_API.Accounts).data or {})
+        for m in coll.get("Members", []):
+            data = m if "UserName" in m else (self.base_query(m.get("@odata.id", "")).data or {})
+            uri = data.get("@odata.id") or m.get("@odata.id")
+            if account_id and str(data.get("Id")) == str(account_id):
+                return uri, data
+            if username and data.get("UserName") == username:
+                return uri, data
+        return None, {}
+
+
+class AccountCreate(_AccountBase,
+                    scm_type=ApiRequestType.AccountCreate,
+                    name='account-create',
+                    metaclass=Singleton):
+    """Create a new Redfish account (dry-run unless --confirm)."""
+
+    def __init__(self, *args, **kwargs):
+        super(AccountCreate, self).__init__(*args, **kwargs)
+
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(cls):
+        cmd_parser = cls.base_parser()
+        cmd_parser.add_argument('--username', required=True, type=str, dest='acct_user',
+                                help="new account UserName")
+        cmd_parser.add_argument('--password', required=True, type=str, dest='acct_password',
+                                help="new account password (not logged)")
+        cmd_parser.add_argument('--role', required=False, type=str, dest='acct_role',
+                                default=DEFAULT_ROLE, help="RoleId (default ReadOnly)")
+        cmd_parser.add_argument('--confirm', action='store_true', required=False,
+                                dest='acct_confirm', default=False,
+                                help="actually create (otherwise dry-run)")
+        return cmd_parser, "account-create", "create a Redfish account (guarded)"
+
+    def execute(self, acct_user=None, acct_password=None, acct_role=DEFAULT_ROLE,
+                acct_confirm=False, **kwargs) -> CommandResult:
+        payload = build_create_payload(acct_user, acct_password, acct_role)
+        if not acct_confirm:
+            return CommandResult(
+                {"dry_run": True, "action": "create", "payload": _mask(payload),
+                 "hint": "re-run with --confirm to create"}, None, None, None)
+        res, status = self.base_post(IDRAC_API.Accounts, payload=payload, expected_status=201)
+        return CommandResult(
+            {"action": "create", "username": acct_user, "role": acct_role,
+             "status": str(status), "error": res.error}, None, None, res.error)
+
+
+class AccountUpdate(_AccountBase,
+                    scm_type=ApiRequestType.AccountUpdate,
+                    name='account-update',
+                    metaclass=Singleton):
+    """Update a Redfish account's password/role/enabled (dry-run unless --confirm)."""
+
+    def __init__(self, *args, **kwargs):
+        super(AccountUpdate, self).__init__(*args, **kwargs)
+
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(cls):
+        cmd_parser = cls.base_parser()
+        cmd_parser.add_argument('--username', required=False, type=str, dest='acct_user', default=None)
+        cmd_parser.add_argument('--id', required=False, type=str, dest='acct_id', default=None,
+                                help="target by account Id instead of username")
+        cmd_parser.add_argument('--role', required=False, type=str, dest='acct_role', default=None)
+        cmd_parser.add_argument('--password', required=False, type=str, dest='acct_password', default=None)
+        cmd_parser.add_argument('--enabled', required=False, type=str, dest='acct_enabled', default=None,
+                                help="true/false to enable or disable the account")
+        cmd_parser.add_argument('--confirm', action='store_true', required=False,
+                                dest='acct_confirm', default=False)
+        return cmd_parser, "account-update", "update a Redfish account (guarded)"
+
+    def execute(self, acct_user=None, acct_id=None, acct_role=None, acct_password=None,
+                acct_enabled=None, acct_confirm=False, **kwargs) -> CommandResult:
+        if not acct_user and not acct_id:
+            return CommandResult(None, None, None, "provide --username or --id")
+        enabled = None
+        if acct_enabled is not None:
+            enabled = str(acct_enabled).strip().lower() in ("1", "true", "yes", "on")
+        payload = build_update_payload(acct_password, acct_role, enabled)
+        if not payload:
+            return CommandResult(None, None, None, "nothing to update (set --role/--password/--enabled)")
+        uri, data = self._resolve_account(acct_user, acct_id)
+        if not uri:
+            return CommandResult(None, None, None, f"account not found: {acct_user or acct_id}")
+        if not acct_confirm:
+            return CommandResult(
+                {"dry_run": True, "action": "update", "target": data.get("UserName"),
+                 "uri": uri, "payload": _mask(payload)}, None, None, None)
+        res, status = self.base_patch(uri, payload=payload)
+        return CommandResult(
+            {"action": "update", "target": data.get("UserName"), "status": str(status),
+             "error": res.error}, None, None, res.error)
+
+
+class AccountDelete(_AccountBase,
+                    scm_type=ApiRequestType.AccountDelete,
+                    name='account-delete',
+                    metaclass=Singleton):
+    """Delete a Redfish account (refuses without --confirm; never self-deletes)."""
+
+    def __init__(self, *args, **kwargs):
+        super(AccountDelete, self).__init__(*args, **kwargs)
+
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(cls):
+        cmd_parser = cls.base_parser()
+        cmd_parser.add_argument('--username', required=False, type=str, dest='acct_user', default=None)
+        cmd_parser.add_argument('--id', required=False, type=str, dest='acct_id', default=None)
+        cmd_parser.add_argument('--confirm', action='store_true', required=False,
+                                dest='acct_confirm', default=False,
+                                help="required to actually delete (irreversible)")
+        return cmd_parser, "account-delete", "delete a Redfish account (guarded, irreversible)"
+
+    def execute(self, acct_user=None, acct_id=None, acct_confirm=False, **kwargs) -> CommandResult:
+        if not acct_user and not acct_id:
+            return CommandResult(None, None, None, "provide --username or --id")
+        uri, data = self._resolve_account(acct_user, acct_id)
+        if not uri:
+            return CommandResult(None, None, None, f"account not found: {acct_user or acct_id}")
+        target = data.get("UserName")
+        # Never delete the account we authenticated as — that could lock the box out.
+        if target and target == self._username:
+            return CommandResult(
+                None, None, None,
+                f"refusing to delete the logged-in account '{target}' (self-delete guard)")
+        if not acct_confirm:
+            return CommandResult(
+                {"dry_run": True, "action": "delete", "target": target, "uri": uri,
+                 "hint": "re-run with --confirm to delete (irreversible)"}, None, None, None)
+        res, status = self.base_delete(uri)
+        return CommandResult(
+            {"action": "delete", "target": target, "status": str(status),
+             "error": res.error}, None, None, res.error)

redfish_ctl/accounts/cmd_account_sshkey.py

@@ -0,0 +1,121 @@
+"""Import or remove an authorized SSH public key for an account (HPE iLO OEM).
+
+    redfish_ctl account-import-sshkey --username test --key-file ~/.ssh/id_rsa.pub --confirm
+    redfish_ctl account-import-sshkey --username test --remove --confirm
+
+HPE iLO 5 stores per-account authorized SSH keys under ``Oem.Hpe.SSHKeys`` (a list
+of OpenSSH key strings), set by PATCHing the account resource. This is HPE-specific
+OEM — other vendors expose SSH keys differently (Dell/Supermicro not mapped yet),
+so the command refuses on a non-HPE account rather than sending a payload that
+would not apply.
+
+HPE constraints enforced here: the public key must be RSA (DSA is blocked on iLO
+firmware >= 2.10 in Production mode) and at most 1366 bytes. Deleting the account
+auto-purges its keys, so a leftover test account never leaves a dangling key.
+
+NOTE — acceptance is firmware-dependent. This sends HPE's *documented* body, but a
+live iLO 5 on fw 2.96 rejects it with ``PropertyNotWritableOrUnknown`` (its Web UI
+uses a different, undocumented path there). The offline test asserts the request
+shape against the stateful mock; confirm acceptance against your own firmware.
+
+Author Mus spyroot@gmail.com
+"""
+import os
+from abc import abstractmethod
+from typing import Optional
+
+from ..idrac_shared import ApiRequestType, Singleton
+from ..redfish_manager import CommandResult
+from .cmd_account_manage import _AccountBase
+
+# HPE iLO's documented authorized-SSH-key size limit.
+MAX_SSH_KEY_BYTES = 1366
+
+
+def validate_ssh_key(key: str) -> Optional[str]:
+    """Return an error string if ``key`` is not an iLO-acceptable SSH pubkey, else None."""
+    key = (key or "").strip()
+    if not key:
+        return "empty SSH key"
+    kind = key.split(None, 1)[0]
+    if not (kind.startswith("ssh-") or kind.startswith("ecdsa-")):
+        return "not an OpenSSH public key (expected 'ssh-rsa AAAA...')"
+    if kind == "ssh-dss":
+        return "DSA keys are blocked by iLO (fw >= 2.10, Production mode) — use an RSA key"
+    n = len(key.encode("utf-8"))
+    if n > MAX_SSH_KEY_BYTES:
+        return f"key is {n} bytes, exceeds the iLO limit of {MAX_SSH_KEY_BYTES}"
+    return None
+
+
+class AccountImportSSHKey(_AccountBase,
+                         scm_type=ApiRequestType.AccountImportSSHKey,
+                         name='account-import-sshkey',
+                         metaclass=Singleton):
+    """PATCH an account's Oem.Hpe.SSHKeys to authorize (or clear) an SSH key."""
+
+    def __init__(self, *args, **kwargs):
+        super(AccountImportSSHKey, self).__init__(*args, **kwargs)
+
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(cls):
+        cmd_parser = cls.base_parser()
+        cmd_parser.add_argument('--username', required=False, type=str, dest='acct_user', default=None)
+        cmd_parser.add_argument('--id', required=False, type=str, dest='acct_id', default=None)
+        cmd_parser.add_argument('--key', required=False, type=str, dest='ssh_key', default=None,
+                                help="the SSH public key string (ssh-rsa AAAA...)")
+        cmd_parser.add_argument('--key-file', required=False, type=str, dest='ssh_key_file', default=None,
+                                help="path to a .pub file to read the key from (e.g. ~/.ssh/id_rsa.pub)")
+        cmd_parser.add_argument('--remove', action='store_true', required=False, dest='ssh_remove',
+                                default=False, help="clear the account's authorized SSH keys")
+        cmd_parser.add_argument('--confirm', action='store_true', required=False,
+                                dest='acct_confirm', default=False,
+                                help="actually write (otherwise dry-run)")
+        return cmd_parser, "account-import-sshkey", "authorize/clear an account SSH key (HPE OEM, guarded)"
+
+    def execute(self, acct_user=None, acct_id=None, ssh_key=None, ssh_key_file=None,
+                ssh_remove=False, acct_confirm=False, **kwargs) -> CommandResult:
+        if not acct_user and not acct_id:
+            return CommandResult(None, None, None, "provide --username or --id")
+
+        if ssh_remove:
+            keys = []
+            key = None
+        else:
+            key = ssh_key
+            if key is None and ssh_key_file:
+                path = os.path.expanduser(ssh_key_file)
+                try:
+                    with open(path, "r") as fh:
+                        key = fh.read()
+                except OSError as e:
+                    return CommandResult(None, None, None, f"cannot read key file {path}: {e}")
+            if not key:
+                return CommandResult(None, None, None, "provide --key, --key-file, or --remove")
+            err = validate_ssh_key(key)
+            if err:
+                return CommandResult(None, None, None, f"invalid SSH key: {err}")
+            keys = [key.strip()]
+
+        uri, data = self._resolve_account(acct_user, acct_id)
+        if not uri:
+            return CommandResult(None, None, None, f"account not found: {acct_user or acct_id}")
+        if "Hpe" not in (data.get("Oem") or {}):
+            vendor = list((data.get("Oem") or {}).keys()) or ["unknown"]
+            return CommandResult(
+                None, None, None,
+                f"SSH key import is HPE-only for now (Oem.Hpe.SSHKeys); this account's OEM is {vendor}")
+
+        payload = {"Oem": {"Hpe": {"SSHKeys": keys}}}
+        action = "remove-ssh-key" if ssh_remove else "import-ssh-key"
+        if not acct_confirm:
+            preview = None if ssh_remove else (keys[0][:40] + "...")
+            return CommandResult(
+                {"dry_run": True, "action": action, "target": data.get("UserName"),
+                 "uri": uri, "key_preview": preview,
+                 "hint": "re-run with --confirm to write"}, None, None, None)
+        res, status = self.base_patch(uri, payload=payload)
+        return CommandResult(
+            {"action": action, "target": data.get("UserName"), "status": str(status),
+             "error": res.error}, None, None, res.error)

redfish_ctl/accounts/cmd_account_svc.py

@@ -0,0 +1,121 @@
+"""iDRAC query account services
+
+Command query account services.
+
+Author Mus spyroot@gmail.com
+"""
+from abc import abstractmethod
+from typing import Optional
+
+from ..idrac_manager import IDracManager
+from ..idrac_shared import IDRAC_API
+from ..idrac_shared import Singleton, ApiRequestType
+from ..redfish_manager import CommandResult
+
+
+class QueryAccountService(IDracManager,
+                          scm_type=ApiRequestType.QueryAccountService,
+                          name='query_account_svc',
+                          metaclass=Singleton):
+    """A command query iDRAC account services based on a resource path.
+    """
+    def __init__(self, *args, **kwargs):
+        super(QueryAccountService, self).__init__(*args, **kwargs)
+        # maps from cli choice to a key in respond
+        self._json_filter_dict = {
+            'account-type': 'SupportedAccountTypes',
+            'oem_account-type': 'SupportedOEMAccountTypes',
+            'accounts': 'Accounts',
+            'ldap': 'LDAP',
+            'ad': 'ActiveDirectory',
+            'local': 'LocalAccountAuth',
+            'lockout-reset-after': 'AccountLockoutCounterResetAfter',
+            'lockout-duration': 'AccountLockoutDuration',
+            'lockout-threshold': 'AccountLockoutThreshold',
+            'status': 'Status',
+            'roles': 'Roles'
+        }
+
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(cls):
+        """Register command and all optional flags.
+        :param cls:
+        :return:
+        """
+        cmd_parser = cls.base_parser()
+        help_text = "command query account service."
+        cmd_parser.add_argument('--filter', choices=['account-type',
+                                                     'oem_account-type',
+                                                     'accounts',
+                                                     'ldap',
+                                                     'ad',
+                                                     'local',
+                                                     'lockout-reset-after',
+                                                     'lockout-duration',
+                                                     'lockout-threshold',
+                                                     'status',
+                                                     'roles'],
+
+                                default=None, required=False, dest="schema_filter",
+                                help="filter show account types, ldap, roles etc")
+
+        cmd_parser.add_argument(
+            '--account_types', action='store_true',
+            required=False, dest="account_types",
+            default=False, help="return account types.")
+
+        cmd_parser.add_argument(
+            '--oem_account_types', action='store_true',
+            required=False, dest="oem_account_types",
+            default=False, help="return oem account types.")
+
+        return cmd_parser, "account-svc", help_text
+
+    def execute(self,
+                schema_filter: Optional[str] = None,
+                filename: Optional[str] = None,
+                data_type: Optional[str] = "json",
+                verbose: Optional[bool] = False,
+                do_async: Optional[bool] = False,
+                do_expanded: Optional[bool] = False,
+                account_types: Optional[bool] = False,
+                oem_account_types: Optional[bool] = False,
+                **kwargs) -> CommandResult:
+        """Executes query command
+        python redfish_ctl.py query
+
+        :param oem_account_types:  return list of oem account types
+        :param account_types: return list account types
+        :param schema_filter: filter account services based on schema filter key.
+        :param do_async: note async will subscribe to an event loop.
+        :param do_expanded:  will do expand query
+        :param filename: if filename indicate call will save a bios setting to a file.
+        :param verbose: enables verbose output
+        :param data_type: json or xml
+        :return: CommandResult and if filename provide will save to a file.
+        """
+        json_filter = ""
+        is_expanded = False
+
+        if schema_filter is not None and len(schema_filter) > 0 or do_expanded:
+            is_expanded = True
+            if schema_filter in self._json_filter_dict:
+                json_filter = self._json_filter_dict[schema_filter]
+
+        cmd_result = self.base_query(IDRAC_API.AccountServiceQuery,
+                                     filename=filename,
+                                     do_async=do_async,
+                                     do_expanded=is_expanded)
+
+        if account_types and 'SupportedAccountTypes' in cmd_result.data:
+            return CommandResult(cmd_result.data['SupportedAccountTypes'], None, None, None)
+
+        if oem_account_types and 'SupportedOEMAccountTypes' in cmd_result.data:
+            return CommandResult(cmd_result.data['SupportedOEMAccountTypes'], None, None, None)
+
+        if cmd_result.error is None:
+            if len(json_filter) > 0 and json_filter in cmd_result.data:
+                cmd_result = CommandResult(cmd_result.data[json_filter], None, None, None)
+
+        return cmd_result