diff --git a/confluent_server/aiohmi/__init__.py b/confluent_server/aiohmi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/cmd/__init__.py b/confluent_server/aiohmi/cmd/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/cmd/fakebmc.py b/confluent_server/aiohmi/cmd/fakebmc.py
new file mode 100755
index 00000000..ec24e3e8
--- /dev/null
+++ b/confluent_server/aiohmi/cmd/fakebmc.py
@@ -0,0 +1,97 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""this is a quick sample of how to write something that acts like a bmc
+to play:
+run fakebmc
+# ipmitool -I lanplus -U admin -P password -H 127.0.0.1 power status
+Chassis Power is off
+# ipmitool -I lanplus -U admin -P password -H 127.0.0.1 power on
+Chassis Power Control: Up/On
+# ipmitool -I lanplus -U admin -P password -H 127.0.0.1 power status
+Chassis Power is on
+# ipmitool -I lanplus -U admin -P password -H 127.0.0.1 mc reset cold
+Sent cold reset command to MC
+(fakebmc exits)
+"""
+
+import argparse
+import sys
+
+import aiohmi.ipmi.bmc as bmc
+
+
+class FakeBmc(bmc.Bmc):
+    def __init__(self, authdata, port):
+        super(FakeBmc, self).__init__(authdata, port)
+        self.powerstate = 'off'
+        self.bootdevice = 'default'
+
+    def get_boot_device(self):
+        return self.bootdevice
+
+    def set_boot_device(self, bootdevice):
+        self.bootdevice = bootdevice
+
+    def cold_reset(self):
+        # Reset of the BMC, not managed system, here we will exit the demo
+        print('shutting down in response to BMC cold reset request')
+        sys.exit(0)
+
+    def get_power_state(self):
+        return self.powerstate
+
+    def power_off(self):
+        # this should be power down without waiting for clean shutdown
+        self.powerstate = 'off'
+        print('abruptly remove power')
+
+    def power_on(self):
+        self.powerstate = 'on'
+        print('powered on')
+
+    def power_reset(self):
+        pass
+
+    def power_shutdown(self):
+        # should attempt a clean shutdown
+        print('politely shut down the system')
+        self.powerstate = 'off'
+
+    def is_active(self):
+        return self.powerstate == 'on'
+
+    def iohandler(self, data):
+        print(data)
+        if self.sol:
+            self.sol.send_data(data)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='fakebmc',
+        description='Pretend to be a BMC',
+    )
+    parser.add_argument('--port',
+                        dest='port',
+                        type=int,
+                        default=623,
+                        help='Port to listen on; defaults to 623')
+    args = parser.parse_args()
+    mybmc = FakeBmc({'admin': 'password'}, port=args.port)
+    mybmc.listen()
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/confluent_server/aiohmi/cmd/pyghmicons.py b/confluent_server/aiohmi/cmd/pyghmicons.py
new file mode 100755
index 00000000..590ff3b5
--- /dev/null
+++ b/confluent_server/aiohmi/cmd/pyghmicons.py
@@ -0,0 +1,88 @@
+# Copyright 2013 IBM Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""" A simple little script to exemplify/test ipmi.console module """
+
+import fcntl
+import os
+import select
+import sys
+import termios
+import threading
+import tty
+
+
+from aiohmi.ipmi import console
+
+
+def _doinput(sol):
+    while True:
+        select.select((sys.stdin,), (), (), 600)
+        try:
+            data = sys.stdin.read()
+        except (IOError, OSError) as e:
+            if e.errno == 11:
+                continue
+            raise
+
+        sol.send_data(data)
+
+
+def _print(data):
+    bailout = False
+    if not isinstance(data, str):
+        bailout = True
+        data = repr(data)
+    sys.stdout.write(data)
+    sys.stdout.flush()
+    if bailout:
+        raise Exception(data)
+
+
+def main():
+    tcattr = termios.tcgetattr(sys.stdin)
+    newtcattr = tcattr
+    # TODO(jbjohnso): add our exit handler
+    newtcattr[-1][termios.VINTR] = 0
+    newtcattr[-1][termios.VSUSP] = 0
+    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, newtcattr)
+
+    tty.setraw(sys.stdin.fileno())
+    currfl = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
+    fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, currfl | os.O_NONBLOCK)
+
+    try:
+        if sys.argv[3] is None:
+            passwd = os.environ['IPMIPASSWORD']
+        else:
+            passwd_file = sys.argv[3]
+            with open(passwd_file, "r") as f:
+                passwd = f.read()
+
+        sol = console.Console(bmc=sys.argv[1], userid=sys.argv[2],
+                              password=passwd, iohandler=_print, force=True)
+        inputthread = threading.Thread(target=_doinput, args=(sol,))
+        inputthread.daemon = True
+        inputthread.start()
+        sol.main_loop()
+
+    except Exception:
+        currfl = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
+        fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, currfl ^ os.O_NONBLOCK)
+        termios.tcsetattr(sys.stdin, termios.TCSANOW, tcattr)
+        return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/confluent_server/aiohmi/cmd/pyghmiutil.py b/confluent_server/aiohmi/cmd/pyghmiutil.py
new file mode 100755
index 00000000..2231d406
--- /dev/null
+++ b/confluent_server/aiohmi/cmd/pyghmiutil.py
@@ -0,0 +1,92 @@
+# Copyright 2013 IBM Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This is an example of using the library in a synchronous fashion. For now,
+it isn't conceived as a general utility to actually use, just help developers
+understand how the ipmi_command class workes.
+"""
+
+import functools
+import os
+import sys
+
+from aiohmi.ipmi import command
+
+
+def docommand(args, result, ipmisession):
+    command = args[0]
+    args = args[1:]
+    print("Logged into %s" % ipmisession.bmc)
+    if 'error' in result:
+        print(result['error'])
+        return
+    if command == 'power':
+        if args:
+            print(ipmisession.set_power(args[0], wait=True))
+        else:
+            value = ipmisession.get_power()
+            print("%s: %s" % (ipmisession.bmc, value['powerstate']))
+    elif command == 'bootdev':
+        if args:
+            print(ipmisession.set_bootdev(args[0]))
+        else:
+            print(ipmisession.get_bootdev())
+    elif command == 'sensors':
+        for reading in ipmisession.get_sensor_data():
+            print(reading)
+    elif command == 'health':
+        print(ipmisession.get_health())
+    elif command == 'inventory':
+        for item in ipmisession.get_inventory():
+            print(item)
+    elif command == 'leds':
+        for led in ipmisession.get_leds():
+            print(led)
+    elif command == 'graphical':
+        print(ipmisession.get_graphical_console())
+    elif command == 'net':
+        print(ipmisession.get_net_configuration())
+    elif command == 'raw':
+        print(ipmisession.raw_command(
+              netfn=int(args[0]),
+              command=int(args[1]),
+              data=map(lambda x: int(x, 16), args[2:])))
+
+
+def main():
+    if (len(sys.argv) < 3) or 'IPMIPASSWORD' not in os.environ:
+        print("Usage:")
+        print(" IPMIPASSWORD=password %s bmc username <cmd> <optarg>" %
+              sys.argv[0])
+        return 1
+
+    password = os.environ['IPMIPASSWORD']
+    os.environ['IPMIPASSWORD'] = ""
+    bmc = sys.argv[1]
+    userid = sys.argv[2]
+
+    bmcs = bmc.split(',')
+    ipmicmd = None
+    for bmc in bmcs:
+        # NOTE(etingof): is it right to have `ipmicmd` overridden?
+        ipmicmd = command.Command(
+            bmc=bmc, userid=userid, password=password,
+            onlogon=functools.partial(docommand, sys.argv[3:]))
+
+    if ipmicmd:
+        ipmicmd.eventloop()
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/confluent_server/aiohmi/cmd/virshbmc.py b/confluent_server/aiohmi/cmd/virshbmc.py
new file mode 100755
index 00000000..787db83c
--- /dev/null
+++ b/confluent_server/aiohmi/cmd/virshbmc.py
@@ -0,0 +1,161 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This is a simple, but working proof of concept of using aiohmi.ipmi.bmc to
+control a VM
+"""
+
+import argparse
+import sys
+import threading
+
+import libvirt
+
+import aiohmi.ipmi.bmc as bmc
+
+
+def lifecycle_callback(connection, domain, event, detail, console):
+    console.state = console.domain.state(0)
+
+
+def error_handler(unused, error):
+    if (error[0] == libvirt.VIR_ERR_RPC
+            and error[1] == libvirt.VIR_FROM_STREAMS):
+        return
+
+
+def stream_callback(stream, events, console):
+    try:
+        data = console.stream.recv(1024)
+    except Exception:
+        return
+    if console.sol:
+        console.sol.send_data(data)
+
+
+class LibvirtBmc(bmc.Bmc):
+    """A class to provide an IPMI interface to the VirtualBox APIs."""
+
+    def __init__(self, authdata, hypervisor, domain, port):
+        super(LibvirtBmc, self).__init__(authdata, port)
+        # Rely on libvirt to throw on bad data
+        self.conn = libvirt.open(hypervisor)
+        self.name = domain
+        self.domain = self.conn.lookupByName(domain)
+        self.state = self.domain.state(0)
+        self.stream = None
+        self.run_console = False
+        self.conn.domainEventRegister(lifecycle_callback, self)
+        self.sol_thread = None
+
+    def cold_reset(self):
+        # Reset of the BMC, not managed system, here we will exit the demo
+        print('shutting down in response to BMC cold reset request')
+        sys.exit(0)
+
+    def get_power_state(self):
+        if self.domain.isActive():
+            return 'on'
+        else:
+            return 'off'
+
+    def power_off(self):
+        if not self.domain.isActive():
+            return 0xd5  # Not valid in this state
+        self.domain.destroy()
+
+    def power_on(self):
+        if self.domain.isActive():
+            return 0xd5  # Not valid in this state
+        self.domain.create()
+
+    def power_reset(self):
+        if not self.domain.isActive():
+            return 0xd5  # Not valid in this state
+        self.domain.reset()
+
+    def power_shutdown(self):
+        if not self.domain.isActive():
+            return 0xd5  # Not valid in this state
+        self.domain.shutdown()
+
+    def is_active(self):
+        return self.domain.isActive()
+
+    def check_console(self):
+        if (self.state[0] == libvirt.VIR_DOMAIN_RUNNING
+                or self.state[0] == libvirt.VIR_DOMAIN_PAUSED):
+            if self.stream is None:
+                self.stream = self.conn.newStream(libvirt.VIR_STREAM_NONBLOCK)
+                self.domain.openConsole(None, self.stream, 0)
+                self.stream.eventAddCallback(libvirt.VIR_STREAM_EVENT_READABLE,
+                                             stream_callback, self)
+        else:
+            if self.stream:
+                self.stream.eventRemoveCallback()
+                self.stream = None
+
+        return self.run_console
+
+    def activate_payload(self, request, session):
+        super(LibvirtBmc, self).activate_payload(request, session)
+        self.run_console = True
+        self.sol_thread = threading.Thread(target=self.loop)
+        self.sol_thread.start()
+
+    def deactivate_payload(self, request, session):
+        self.run_console = False
+        self.sol_thread.join()
+        super(LibvirtBmc, self).deactivate_payload(request, session)
+
+    def iohandler(self, data):
+        if self.stream:
+            self.stream.send(data)
+
+    def loop(self):
+        while self.check_console():
+            libvirt.virEventRunDefaultImpl()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='virshbmc',
+        description='Pretend to be a BMC and proxy to virsh',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument('--port',
+                        dest='port',
+                        type=int,
+                        default=623,
+                        help='(UDP) port to listen on')
+    parser.add_argument('--connect',
+                        dest='hypervisor',
+                        default='qemu:///system',
+                        help='The hypervisor to connect to')
+    parser.add_argument('--domain',
+                        dest='domain',
+                        required=True,
+                        help='The name of the domain to manage')
+    args = parser.parse_args()
+
+    libvirt.virEventRegisterDefaultImpl()
+    libvirt.registerErrorHandler(error_handler, None)
+
+    mybmc = LibvirtBmc({'admin': 'password'},
+                       hypervisor=args.hypervisor,
+                       domain=args.domain,
+                       port=args.port)
+    mybmc.listen()
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/confluent_server/aiohmi/constants.py b/confluent_server/aiohmi/constants.py
new file mode 100644
index 00000000..0a60960c
--- /dev/null
+++ b/confluent_server/aiohmi/constants.py
@@ -0,0 +1,18 @@
+# Copyright 2014 IBM Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Health(object):
+    Ok = 0
+    Warning, Critical, Failed = [2**x for x in range(0, 3)]
diff --git a/confluent_server/aiohmi/exceptions.py b/confluent_server/aiohmi/exceptions.py
new file mode 100644
index 00000000..3c6427ef
--- /dev/null
+++ b/confluent_server/aiohmi/exceptions.py
@@ -0,0 +1,74 @@
+# Copyright 2013 IBM Corporation
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# The Exceptions that Pyghmi can throw
+
+
+class PyghmiException(Exception):
+    pass
+
+
+class IpmiException(PyghmiException):
+    def __init__(self, text='', code=0):
+        super(IpmiException, self).__init__(text)
+        self.ipmicode = code
+
+
+class RedfishError(PyghmiException):
+    def __init__(self, text='', msgid=None):
+        super(RedfishError, self).__init__(text)
+        self.msgid = msgid
+
+
+class UnrecognizedCertificate(Exception):
+    def __init__(self, text='', certdata=None):
+        super(UnrecognizedCertificate, self).__init__(text)
+        self.certdata = certdata
+
+
+class TemporaryError(Exception):
+    # A temporary condition that should clear, but warrants reporting to the
+    # caller
+    pass
+
+
+class InvalidParameterValue(PyghmiException):
+    pass
+
+
+class BmcErrorException(IpmiException):
+    # This denotes when library detects an invalid BMC behavior
+    pass
+
+
+class UnsupportedFunctionality(PyghmiException):
+    # Indicates when functionality is requested that is not supported by
+    # current endpoint
+    pass
+
+
+class BypassGenericBehavior(PyghmiException):
+    # Indicates that an OEM handler wants to abort any standards based
+    # follow up
+    pass
+
+
+class FallbackData(PyghmiException):
+    # Indicates the OEM handler has data to be used if the generic
+    # check comes up empty
+    def __init__(self, fallbackdata):
+        self.fallbackdata = fallbackdata
+
+    pass
diff --git a/confluent_server/aiohmi/ipmi/__init__.py b/confluent_server/aiohmi/ipmi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/ipmi/bmc.py b/confluent_server/aiohmi/ipmi/bmc.py
new file mode 100644
index 00000000..92e55968
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/bmc.py
@@ -0,0 +1,198 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import struct
+import traceback
+
+import aiohmi.ipmi.command as ipmicommand
+import aiohmi.ipmi.console as console
+import aiohmi.ipmi.private.serversession as serversession
+import aiohmi.ipmi.private.session as ipmisession
+
+
+__author__ = 'jjohnson2@lenovo.com'
+
+
+class Bmc(serversession.IpmiServer):
+
+    activated = False
+    sol = None
+    iohandler = None
+
+    def get_system_guid(self):
+        raise NotImplementedError
+
+    def cold_reset(self):
+        raise NotImplementedError
+
+    def power_off(self):
+        raise NotImplementedError
+
+    def power_on(self):
+        raise NotImplementedError
+
+    def power_cycle(self):
+        raise NotImplementedError
+
+    def power_reset(self):
+        raise NotImplementedError
+
+    def pulse_diag(self):
+        raise NotImplementedError
+
+    def power_shutdown(self):
+        raise NotImplementedError
+
+    def get_power_state(self):
+        raise NotImplementedError
+
+    def is_active(self):
+        raise NotImplementedError
+
+    def activate_payload(self, request, session):
+        if self.iohandler is None:
+            session.send_ipmi_response(code=0x81)
+        elif not self.is_active():
+            session.send_ipmi_response(code=0x81)
+        elif self.activated:
+            session.send_ipmi_response(code=0x80)
+        else:
+            self.activated = True
+            solport = list(struct.unpack('BB', struct.pack('!H', self.port)))
+            session.send_ipmi_response(
+                data=[0, 0, 0, 0, 1, 0, 1, 0] + solport + [0xff, 0xff])
+            self.sol = console.ServerConsole(session, self.iohandler)
+
+    def deactivate_payload(self, request, session):
+        if self.iohandler is None:
+            session.send_ipmi_response(code=0x81)
+        elif not self.activated:
+            session.send_ipmi_response(code=0x80)
+        else:
+            session.send_ipmi_response()
+            self.sol.close()
+            self.activated = False
+            self.sol = None
+
+    @staticmethod
+    def handle_missing_command(session):
+        session.send_ipmi_response(code=0xc1)
+
+    def get_chassis_status(self, session):
+        try:
+            powerstate = self.get_power_state()
+        except NotImplementedError:
+            return session.send_ipmi_response(code=0xc1)
+        if powerstate in ipmicommand.power_states:
+            powerstate = ipmicommand.power_states[powerstate]
+        if powerstate not in (0, 1):
+            raise Exception('BMC implementation mistake')
+        statusdata = [powerstate, 0, 0]
+        session.send_ipmi_response(data=statusdata)
+
+    def control_chassis(self, request, session):
+        rc = 0
+        try:
+            directive = request['data'][0]
+            if directive == 0:
+                rc = self.power_off()
+            elif directive == 1:
+                rc = self.power_on()
+            elif directive == 2:
+                rc = self.power_cycle()
+            elif directive == 3:
+                rc = self.power_reset()
+            elif directive == 4:
+                # i.e. Pulse a diagnostic interrupt(NMI) directly
+                rc = self.pulse_diag()
+            elif directive == 5:
+                rc = self.power_shutdown()
+            if rc is None:
+                rc = 0
+            session.send_ipmi_response(code=rc)
+        except NotImplementedError:
+            session.send_ipmi_response(code=0xcc)
+
+    def get_boot_device(self):
+        raise NotImplementedError
+
+    def get_system_boot_options(self, request, session):
+        if request['data'][0] == 5:  # boot flags
+            try:
+                bootdevice = self.get_boot_device()
+            except NotImplementedError:
+                session.send_ipmi_response(data=[1, 5, 0, 0, 0, 0, 0])
+            if (type(bootdevice) != int
+                    and bootdevice in ipmicommand.boot_devices):
+                bootdevice = ipmicommand.boot_devices[bootdevice]
+            paramdata = [1, 5, 0b10000000, bootdevice, 0, 0, 0]
+            return session.send_ipmi_response(data=paramdata)
+        else:
+            session.send_ipmi_response(code=0x80)
+
+    def set_boot_device(self, bootdevice):
+        raise NotImplementedError
+
+    def set_system_boot_options(self, request, session):
+        if request['data'][0] in (0, 3, 4):
+            # for now, just smile and nod at boot flag bit clearing
+            # implementing it is a burden and implementing it does more to
+            # confuse users than serve a useful purpose
+            session.send_ipmi_response()
+        elif request['data'][0] == 5:
+            bootdevice = (request['data'][2] >> 2) & 0b1111
+            try:
+                bootdevice = ipmicommand.boot_devices[bootdevice]
+            except KeyError:
+                session.send_ipmi_response(code=0xcc)
+                return
+            self.set_boot_device(bootdevice)
+            session.send_ipmi_response()
+        else:
+            raise NotImplementedError
+
+    def handle_raw_request(self, request, session):
+        try:
+            if request['netfn'] == 6:
+                if request['command'] == 1:  # get device id
+                    return self.send_device_id(session)
+                elif request['command'] == 2:  # cold reset
+                    return session.send_ipmi_response(code=self.cold_reset())
+                elif request['command'] == 0x37:  # get system guid
+                    guid = self.get_system_guid()
+                    return session.send_ipmi_response(code=0x00, data=guid.bytes_le)
+                elif request['command'] == 0x48:  # activate payload
+                    return self.activate_payload(request, session)
+                elif request['command'] == 0x49:  # deactivate payload
+                    return self.deactivate_payload(request, session)
+            elif request['netfn'] == 0:
+                if request['command'] == 1:  # get chassis status
+                    return self.get_chassis_status(session)
+                elif request['command'] == 2:  # chassis control
+                    return self.control_chassis(request, session)
+                elif request['command'] == 8:  # set boot options
+                    return self.set_system_boot_options(request, session)
+                elif request['command'] == 9:  # get boot options
+                    return self.get_system_boot_options(request, session)
+            session.send_ipmi_response(code=0xc1)
+        except NotImplementedError:
+            session.send_ipmi_response(code=0xc1)
+        except Exception:
+            session._send_ipmi_net_payload(code=0xff)
+            traceback.print_exc()
+
+    @classmethod
+    def listen(cls, timeout=30):
+        while True:
+            ipmisession.Session.wait_for_rsp(timeout)
diff --git a/confluent_server/aiohmi/ipmi/command.py b/confluent_server/aiohmi/ipmi/command.py
new file mode 100644
index 00000000..32d6ab1d
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/command.py
@@ -0,0 +1,2314 @@
+# Copyright 2013 IBM Corporation
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This represents the low layer message framing portion of IPMI"""
+
+from itertools import chain
+import os
+import socket
+import struct
+import threading
+
+import asyncio
+import aiohmi.constants as const
+import aiohmi.exceptions as exc
+import aiohmi.ipmi.events as sel
+import aiohmi.ipmi.fru as fru
+import aiohmi.ipmi.oem.generic as genericoem
+from aiohmi.ipmi.oem.lookup import get_oem_handler
+import aiohmi.ipmi.private.util as util
+from aiohmi.ipmi import sdr
+
+
+try:
+    from aiohmi.ipmi.private import session
+except ImportError:
+    session = None
+try:
+    from aiohmi.ipmi.private import localsession
+except ImportError:
+    localsession = None
+
+try:
+    range = xrange
+except NameError:
+    pass
+try:
+    buffer
+except NameError:
+    buffer = memoryview
+
+boot_devices = {
+    'net': 4,
+    'network': 4,
+    'pxe': 4,
+    'hd': 8,
+    'safe': 0xc,
+    'cd': 0x14,
+    'cdrom': 0x14,
+    'optical': 0x14,
+    'dvd': 0x14,
+    'floppy': 0x3c,
+    'usb': 0x3c,
+    'default': 0x0,
+    'setup': 0x18,
+    'bios': 0x18,
+    'f1': 0x18,
+    1: 'network',
+    2: 'hd',
+    3: 'safe',
+    5: 'optical',
+    6: 'setup',
+    15: 'floppy',
+    0: 'default'
+}
+
+power_states = {
+    "off": 0,
+    "on": 1,
+    "reset": 3,
+    "diag": 4,
+    "softoff": 5,
+    "shutdown": 5,
+    # NOTE(jbjohnso): -1 is not a valid direct boot state,
+    #                 but here for convenience of 'in' statement
+    "boot": -1,
+}
+
+
+def select_simplesession():
+    global session
+    import aiohmi.ipmi.private.simplesession as session
+
+
+def _mask_to_cidr(mask):
+    maskn = struct.unpack_from('>I', mask)[0]
+    cidr = 32
+    while maskn & 0b1 == 0 and cidr > 0:
+        cidr -= 1
+        maskn >>= 1
+    return cidr
+
+
+def _cidr_to_mask(prefix):
+    return struct.pack('>I', 2 ** prefix - 1 << (32 - prefix))
+
+
+class Housekeeper(threading.Thread):
+    """A Maintenance thread for housekeeping
+
+    Long lived use of aiohmi may warrant some recurring asynchronous behavior.
+    This stock thread provides a simple minimal context for these housekeeping
+    tasks to run in.  To use, do 'aiohmi.ipmi.command.Maintenance().start()'
+    and from that point forward, aiohmi should execute any needed ongoing
+    tasks automatically as needed.  This is an alternative to calling
+    wait_for_rsp or eventloop in a thread of the callers design.
+    """
+
+    def run(self):
+        Command.eventloop()
+
+
+class Command(object):
+    """Send IPMI commands to BMCs.
+
+    This object represents a persistent session to an IPMI device (bmc) and
+    allows the caller to reuse a single session to issue multiple commands.
+    This class can be used in a synchronous (wait for answer and return) or
+    asynchronous fashion (return immediately and provide responses by
+    callbacks).  Synchronous mode is the default behavior.
+
+    For asynchronous mode, simply pass in a callback function.  It is
+    recommended to pass in an instance method to callback and ignore the
+    callback_args parameter. However, callback_args can optionally be populated
+    if desired.
+
+    :param bmc: hostname or ip address of the BMC (default is local)
+    :param userid: username to use to connect (default to no user)
+    :param password: password to connect to the BMC (defaults to no password)
+    :param onlogon: function to run when logon completes in an asynchronous
+                    fashion.  This will result in a greenthread behavior.
+    :param kg: Optional parameter to use if BMC has a particular Kg configured
+    :param verifycallback: For OEM extensions that use HTTPS, this function
+                           will be used to evaluate the certificate.
+    :param keepalive: If False, then an idle connection will logout rather
+                      than keepalive unless held open by console or ongoing
+                      activity.
+    """
+
+    @classmethod
+    async def create(cls, bmc=None, userid=None, password=None, port=623,
+                 kg=None, privlevel=None, verifycallback=None,
+                 keepalive=True, **kwargs):
+        self = cls()
+        # TODO(jbjohnso): accept tuples and lists of each parameter for mass
+        # operations without pushing the async complexities up the stack
+        self.bmc = bmc
+        self._sdrcachedir = None
+        self._sdr = None
+        self._oem = None
+        self._oemknown = False
+        self._netchannel = None
+        self._ipv6support = None
+        self.certverify = verifycallback
+        self.kwargs = kwargs
+        if bmc is None:
+            self.ipmi_session = localsession.Session()
+        else:
+            self.ipmi_session = await session.Session(bmc=self.bmc,
+                                                userid=userid,
+                                                password=password,
+                                                port=port,
+                                                kg=kg,
+                                                privlevel=privlevel,
+                                                keepalive=keepalive)
+            # induce one iteration of the loop, now that we would be
+            # prepared for it in theory
+            await session.Session.wait_for_rsp(0)
+        return self
+
+    def set_sdr_cachedir(self, path):
+        """Register use of a directory for SDR cache.
+
+        Takes the given directory and uses it to persist SDR cache run to run.
+        This can greatly improve performance across runs.
+
+        :param path:
+        :return:
+        """
+        self._sdrcachedir = path
+
+    def register_key_handler(self, callback, type='tls'):
+        """Assign a verification handler for a public key
+
+        When the library attempts to communicate with the management target
+        using a non-IPMI protocol, it will try to verify a key.  This
+        allows a caller to register a key handler for accepting or rejecting
+        a public key/certificate.  The callback will be passed the peer public
+        key or certificate.
+
+        :param callback:  The function to call with public key/certificate
+        :param type: Whether the callback is meant to handle 'tls' or 'ssh',
+                     defaults to 'tls'
+        """
+        if type == 'tls':
+            self.certverify = callback
+
+    @classmethod
+    async def eventloop(cls):
+        while True:
+            await session.Session.wait_for_rsp()
+
+    @classmethod
+    async def wait_for_rsp(cls, timeout):
+        """Delay for no longer than timeout for next response.
+
+        This acts like a sleep that exits on activity.
+
+        :param timeout: Maximum number of seconds before returning
+        """
+        return await session.Session.wait_for_rsp(timeout=timeout)
+
+    async def _get_device_id(self):
+        response = await self.raw_command(netfn=0x06, command=0x01)
+        return {
+            'device_id': response['data'][0],
+            'device_revision': response['data'][1] & 0b1111,
+            'manufacturer_id': struct.unpack(
+                '<I', struct.pack('3B', *response['data'][6:9]) + b'\x00')[0],
+            'product_id': struct.unpack(
+                '<H', struct.pack('2B', *response['data'][9:11]))[0],
+            'firmware_version': '{0}.{1}{2}'.format(
+                response['data'][2] & 0b1111111,
+                response['data'][3] >> 4 & 0b1111,
+                response['data'][3] & 0b1111)
+        }
+
+    async def oem_init(self):
+        """Initialize the command object for OEM capabilities
+
+        A number of capabilities are either totally OEM defined or
+        else augmented somehow by knowledge of the OEM.  This
+        method does an interrogation to identify the OEM.
+
+        """
+        if self._oemknown:
+            return
+        if self.bmc is None:
+            self._oem = await genericoem.OEMHandler.create(None, None)
+            self._oemknown = True
+            return
+        self._oem, self._oemknown = await get_oem_handler(await self._get_device_id(),
+                                                    self)
+
+    async def get_bootdev(self):
+        """Get current boot device override information.
+
+        Provides the current requested boot device.  Be aware that not all IPMI
+        devices support this.  Even in BMCs that claim to, occasionally the
+        BIOS or UEFI fail to honor it. This is usually only applicable to the
+        next reboot.
+
+        :raises: IpmiException on an error.
+        :returns: dict --The response will be provided in the return as a dict
+        """
+        response = await self.raw_command(netfn=0, command=9, data=(5, 0, 0))
+        # interpret response per 'get system boot options'
+        # this should only be invoked for get system boot option complying to
+        # ipmi spec and targeting the 'boot flags' parameter
+        assert (response['command'] == 9
+                and response['netfn'] == 1
+                and response['data'][0] == 1
+                and (response['data'][1] & 0b1111111) == 5)
+        if (response['data'][1] & 0b10000000
+                or not response['data'][2] & 0b10000000):
+            return {'bootdev': 'default', 'persistent': True}
+        else:  # will consult data2 of the boot flags parameter for the data
+            persistent = False
+            uefimode = False
+            if response['data'][2] & 0b1000000:
+                persistent = True
+            if response['data'][2] & 0b100000:
+                uefimode = True
+            bootnum = (response['data'][3] & 0b111100) >> 2
+            bootdev = boot_devices.get(bootnum)
+            if bootdev:
+                return {'bootdev': bootdev,
+                        'persistent': persistent,
+                        'uefimode': uefimode}
+            else:
+                return {'bootdev': bootnum,
+                        'persistent': persistent,
+                        'uefimode': uefimode}
+
+    async def reseat_bay(self, bay):
+        """Request the reseat of a bay
+
+        Request the enclosure manager to reseat the system in a particular
+        bay.
+
+        :param bay: The bay identifier to reseat
+        :return:
+        """
+        await self.oem_init()
+        await self._oem.reseat_bay(bay)
+
+    async def set_power(self, powerstate, wait=False, bridge_request=None):
+        """Request power state change (helper)
+
+        :param powerstate:
+                            * on -- Request system turn on
+                            * off -- Request system turn off without waiting
+                                     for OS to shutdown
+                            * shutdown -- Have system request OS proper
+                                          shutdown
+                            * reset -- Request system reset without waiting for
+                              OS
+                            * boot -- If system is off, then 'on', else 'reset'
+        :param wait: If True, do not return until system actually completes
+                     requested state change for 300 seconds.
+                     If a non-zero number, adjust the wait time to the
+                     requested number of seconds
+        :param bridge_request: The target slave address and channel number for
+                               the bridge request.
+        :raises: IpmiException on an error
+        :returns: dict -- A dict describing the response retrieved
+        """
+        await self.oem_init()
+
+        if hasattr(self._oem, 'set_power'):
+            return self._oem.set_power(powerstate,
+                                       bridge_request=bridge_request)
+
+        if hasattr(self._oem, 'process_power_state'):
+            powerstate = self._oem.process_power_state(
+                powerstate, bridge_request=bridge_request)
+
+        if powerstate not in power_states:
+            raise exc.InvalidParameterValue(
+                "Unknown power state %s requested" % powerstate)
+        newpowerstate = powerstate
+        oldpowerstate = await self._get_power_state(bridge_request=bridge_request)
+        if oldpowerstate == newpowerstate:
+            return {'powerstate': oldpowerstate}
+        if newpowerstate == 'boot':
+            newpowerstate = 'on' if oldpowerstate == 'off' else 'reset'
+        response = await self.raw_command(
+            netfn=0, command=2, data=[power_states[newpowerstate]],
+            bridge_request=bridge_request)
+        lastresponse = {'pendingpowerstate': newpowerstate}
+        waitattempts = 300
+        if not isinstance(wait, bool):
+            waitattempts = wait
+        if wait and newpowerstate in ('on', 'off', 'shutdown', 'softoff'):
+            if newpowerstate in ('softoff', 'shutdown'):
+                waitpowerstate = 'off'
+            else:
+                waitpowerstate = newpowerstate
+            currpowerstate = None
+            while currpowerstate != waitpowerstate and waitattempts > 0:
+                await asyncio.sleep(1)
+                currpowerstate = await self._get_power_state(
+                    bridge_request=bridge_request)
+                waitattempts -= 1
+            if currpowerstate != waitpowerstate:
+                raise exc.IpmiException(
+                    "System did not accomplish power state change")
+            return {'powerstate': currpowerstate}
+        else:
+            return lastresponse
+
+    async def _get_power_state(self, bridge_request=None):
+        response = await self.raw_command(netfn=0, command=1,
+                                    bridge_request=bridge_request)
+        assert (response['command'] == 1 and response['netfn'] == 1)
+        curr_power_state = 'on' if (response['data'][0] & 1) else 'off'
+        return curr_power_state
+
+    async def get_video_launchdata(self):
+        """Get data required to launch a remote video session to target.
+
+        This is a highly proprietary scenario, the return data may vary greatly
+        host to host.  The return should be a dict describing the type of data
+        and the data.  For example {'jnlp': jnlpstring}
+        """
+        await self.oem_init()
+        return await self._oem.get_video_launchdata()
+
+    async def reset_bmc(self):
+        """Do a cold reset in BMC"""
+        response = await self.raw_command(netfn=6, command=2, retry=False)
+        if response and 'error' in response:
+            raise exc.IpmiException(response['error'])
+
+    async def set_bootdev(self,
+                    bootdev,
+                    persist=False,
+                    uefiboot=False):
+        """Set boot device to use on next reboot (helper)
+
+        :param bootdev:
+                        *network -- Request network boot
+                        *hd -- Boot from hard drive
+                        *safe -- Boot from hard drive, requesting 'safe mode'
+                        *optical -- boot from CD/DVD/BD drive
+                        *setup -- Boot into setup utility
+                        *default -- remove any IPMI directed boot device
+                                    request
+        :param persist: If true, ask that system firmware use this device
+                        beyond next boot.  Be aware many systems do not honor
+                        this
+        :param uefiboot: If true, request UEFI boot explicitly.  Strictly
+                         speaking, the spec sugests that if not set, the system
+                         should BIOS boot and offers no "don't care" option.
+                         In practice, this flag not being set does not preclude
+                         UEFI boot on any system I've encountered.
+        :raises: IpmiException on an error.
+        :returns: dict or True -- If callback is not provided, the response
+        """
+        if bootdev not in boot_devices:
+            return {'error': "Unknown bootdevice %s requested" % bootdev}
+        bootdevnum = boot_devices[bootdev]
+        # first, we disable timer by way of set system boot options,
+        # then move on to set chassis capabilities
+        # Set System Boot Options is netfn=0, command=8, data
+        response = await self.raw_command(netfn=0, command=8, data=(3, 8))
+        if 'error' in response:
+            raise exc.IpmiException(response['error'])
+        bootflags = 0x80
+        if uefiboot:
+            bootflags |= 1 << 5
+        if persist:
+            bootflags |= 1 << 6
+        if bootdevnum == 0:
+            bootflags = 0
+        data = (5, bootflags, bootdevnum, 0, 0, 0)
+        response = await self.raw_command(netfn=0, command=8, data=data)
+        if 'error' in response:
+            raise exc.IpmiException(response['error'])
+        return {'bootdev': bootdev}
+
+    async def xraw_command(self, **kwargs):
+        raise Exception("Don't use this anymore")
+        return await self.raw_command(**kwargs)
+
+    async def raw_command(self, netfn, command, bridge_request=(), data=(),
+                     retry=True, timeout=None, rslun=0):
+        """Send raw ipmi command to BMC, raising exception on error
+
+        This is identical to raw_command, except it raises exceptions
+        on IPMI errors and returns data as a buffer.  This is the recommend
+        function to use.  The response['data'] being a buffer allows
+        traditional indexed access as well as works nicely with
+        struct.unpack_from when certain data is coming back.
+
+        :param netfn: Net function number
+        :param command: Command value
+        :param bridge_request: The target slave address and channel number for
+                               the bridge request.
+        :param data: Command data as a tuple or list
+        :param retry: Whether to retry this particular payload or not, defaults
+                      to true.
+        :param timeout: A custom time to wait for initial reply, useful for
+                        a slow command.  This may interfere with retry logic.
+        :returns: dict -- The response from IPMI device
+        """
+        rsp = await self.ipmi_session.raw_command(netfn=netfn, command=command,
+                                            bridge_request=bridge_request,
+                                            data=data,
+                                            retry=retry, timeout=timeout,
+                                            rslun=rslun)
+        if rsp and 'error' in rsp:
+            raise exc.IpmiException(rsp['error'], rsp['code'])
+        if rsp and 'data' in rsp:
+            rsp['data'] = buffer(rsp['data'])
+        return rsp
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        if os.path.exists(savefile) and not os.path.isdir(savefile):
+            raise exc.InvalidParameterValue(
+                'Not allowed to overwrite existing file: {0}'.format(
+                    savefile))
+        await self.oem_init()
+        return await self._oem.get_diagnostic_data(savefile, progress, autosuffix)
+
+    async def get_description(self):
+        """Get physical attributes for the system, e.g. for GUI use
+
+        :returns: dict -- dict containing attributes, 'height' is for
+               how many U tall, 'slot' for what slot in a blade enclosure
+               or 0 if not blade, for example.
+        """
+        await self.oem_init()
+        return await self._oem.get_description()
+
+    async def oldraw_command(self, netfn, command, bridge_request=(), data=(),
+                    retry=True, timeout=None, rslun=0):
+        """Send raw ipmi command to BMC
+
+        This allows arbitrary IPMI bytes to be issued.  This is commonly used
+        for certain vendor specific commands.
+
+        Example: ipmicmd.raw_command(netfn=0,command=4,data=(5))
+
+        :param netfn: Net function number
+        :param command: Command value
+        :param bridge_request: The target slave address and channel number for
+                               the bridge request.
+        :param data: Command data as a tuple or list
+        :param retry: Whether or not to retry command if no response received.
+                      Defaults to True
+        :param timeout: A custom amount of time to wait for initial reply
+        :returns: dict -- The response from IPMI device
+        """
+        rsp = await self.ipmi_session.raw_command(netfn=netfn, command=command,
+                                            bridge_request=bridge_request,
+                                            data=data,
+                                            retry=retry, timeout=timeout,
+                                            rslun=rslun)
+        return rsp
+
+    async def get_power(self, bridge_request=None):
+        """Get current power state of the managed system
+
+        The response, if successful, should contain 'powerstate' key and
+        either 'on' or 'off' to indicate current state.
+
+        :param bridge_request: The target slave address and channel number for
+                               the bridge request.
+        :returns: dict -- {'powerstate': value}
+        """
+        await self.oem_init()
+        if hasattr(self._oem, 'get_power'):
+            return {'powerstate': await self._oem.get_power(
+                bridge_request=bridge_request)}
+
+        return {'powerstate': await self._get_power_state(
+            bridge_request=bridge_request)}
+
+    async def set_identify(self, on=True, duration=None, blink=False):
+        """Request identify light
+
+        Request the identify light to turn off, on for a duration,
+        or on indefinitely.  Other than error exceptions,
+
+        :param on: Set to True to force on or False to force off
+        :param duration: Set if wanting to request turn on for a duration
+                         rather than indefinitely on
+        """
+        await self.oem_init()
+        try:
+            await self._oem.set_identify(on, duration, blink)
+            return
+        except exc.BypassGenericBehavior:
+             return
+        except exc.UnsupportedFunctionality:
+            pass
+        if blink:
+            raise exc.IpmiException('Blink not supported with generic IPMI')
+        if duration is not None:
+            duration = int(duration)
+            if duration > 255:
+                duration = 255
+            if duration < 0:
+                duration = 0
+            response = await self.raw_command(netfn=0, command=4, data=[duration])
+            return
+        forceon = 0
+        if on:
+            forceon = 1
+        if self.ipmi_session.ipmiversion < 2.0:
+            # ipmi 1.5 made due with just one byte, make best effort
+            # to imitate indefinite as close as possible
+            identifydata = [255 * forceon]
+        else:
+            identifydata = [0, forceon]
+        response = await self.raw_command(netfn=0, command=4, data=identifydata)
+
+    async def init_sdr(self):
+        """Initialize SDR
+
+        Do the appropriate action to have a relevant sensor description
+        repository for the current management controller
+        """
+        # For now, return current sdr if it exists and still connected
+        # future, check SDR timestamp for continued relevance
+        # further future, optionally support a cache directory/file
+        # to store cached copies for given device id, product id, mfg id,
+        # sdr timestamp, our data version revision, aux firmware revision,
+        # and oem defined field
+        await self.oem_init()
+        if self._sdr is None:
+            if hasattr(self._oem, 'init_sdr'):
+                self._sdr = await self._oem.init_sdr()
+            else:
+                self._sdr = sdr.SDR(self, self._sdrcachedir)
+                await self._sdr.initialize()
+        return self._sdr
+
+    async def get_event_constants(self):
+        await self.oem_init()
+        return await self._oem.get_oem_event_const()
+
+    async def get_event_log(self, clear=False):
+        """Retrieve the log of events, optionally clearing
+
+        The contents of the SEL are returned as an iterable.  Timestamps
+        are given as local time, ISO 8601 (whether the target has an accurate
+        clock or not).  Timestamps may be omitted for events that cannot be
+        given a timestamp, leaving only the raw timecode to provide relative
+        time information.  clear set to true will result in the log being
+        cleared as it is returned.  This allows an atomic fetch and clear
+        behavior so that no log entries will be lost between the fetch and
+        clear actions.  There is no 'clear_event_log' function to encourage
+        users to create code that is not at risk for losing events.
+
+        :param clear:  Whether to remove the SEL entries from the target BMC
+        """
+        await self.oem_init()
+        evthdlr = await sel.EventHandler.create(await self.init_sdr(), self)
+        async for logent in evthdlr.fetch_sel(self, clear):
+            yield logent
+
+    async def decode_pet(self, specifictrap, petdata):
+        """Decode PET to an event
+
+        In IPMI, the alert format are PET alerts.  It is a particular set of
+        data put into an SNMPv1 trap and sent. It bears no small resemblence
+        to the SEL entries.  This function takes data that would have been
+        received by an SNMP trap handler, and provides an event decode, similar
+        to one entry of get_event_log.
+
+        :param specifictrap: The specific trap, as either a bytearray or int
+        :param petdata: An iterable of the octet data of varbind for
+                        1.3.6.1.4.1.3183.1.1.1
+        :returns: A dict event similar to one iteration of get_event_log
+        """
+        await self.oem_init()
+        evthdlr = await sel.EventHandler.create(await self.init_sdr(), self)
+        return await evthdlr.decode_pet(specifictrap, petdata)
+
+    async def get_ikvm_methods(self):
+        await self.oem_init()
+        return await self._oem.get_ikvm_methods()
+
+    async def get_ikvm_launchdata(self):
+        await self.oem_init()
+        return await self._oem.get_ikvm_launchdata()
+
+    async def get_inventory_descriptions(self):
+        """Retrieve list of things that could be inventoried
+
+        This permits a caller to examine the available items
+        without actually causing the inventory data to be gathered.  It
+        returns an iterable of string descriptions
+        """
+        yield "System"
+        await self.init_sdr()
+        for fruid in sorted(self._sdr.fru):
+            yield self._sdr.fru[fruid].fru_name
+        await self.oem_init()
+        async for compname in self._oem.get_oem_inventory_descriptions():
+            yield compname
+
+    async def get_inventory_of_component(self, component):
+        """Retrieve inventory of a component
+
+        Retrieve detailed inventory information for only the requested
+        component.
+        """
+        await self.oem_init()
+        if component == 'System':
+            return await self._get_zero_fru()
+        await self.init_sdr()
+        for fruid in self._sdr.fru:
+            if self._sdr.fru[fruid].fru_name == component:
+                return self._oem.process_fru(fru.FRU(
+                    ipmicmd=self, fruid=fruid,
+                    sdr=self._sdr.fru[fruid]).info, component)
+        return await self._oem.get_inventory_of_component(component)
+
+    async def _get_zero_fru(self):
+        # Add some fields returned by get device ID command to FRU 0
+        # Also rename them to something more in line with FRU 0 field naming
+        # standards
+        device_id = await self._get_device_id()
+        device_id['Device ID'] = device_id.pop('device_id')
+        device_id['Device Revision'] = device_id.pop('device_revision')
+        device_id['Manufacturer ID'] = device_id.pop('manufacturer_id')
+        device_id['Product ID'] = device_id.pop('product_id')
+        tfru = fru.FRU(ipmicmd=self, fruid=0)
+        await tfru.initialize()
+        zerofru = tfru.info
+        if zerofru is None:
+            zerofru = {}
+        zerofru.update(device_id)
+        zerofru = await self._oem.process_zero_fru(zerofru)
+        # If uuid is not returned in OEM processing,
+        # then it is expected that a manufacturer matches SMBIOS to IPMI
+        # get system uuid return data.
+        if 'UUID' not in zerofru:
+            guiddata = await self.raw_command(netfn=6, command=0x37)
+            zerofru['UUID'] = util.\
+                decode_wireformat_uuid(guiddata['data'])
+        return zerofru
+
+    async def get_inventory(self):
+        """Retrieve inventory of system
+
+        Retrieve inventory of the targeted system.  This frequently includes
+        serial numbers, sometimes hardware addresses, sometimes memory modules
+        This function will retrieve whatever the underlying platform provides
+        and apply some structure.  Iterating over the return yields tuples
+        of a name for the inventoried item and dictionary of descriptions
+        or None for items not present.
+        """
+        await self.oem_init()
+        yield ("System", await self._get_zero_fru())
+        await self.init_sdr()
+        for fruid in sorted(self._sdr.fru):
+            tfru = fru.FRU(ipmicmd=self, fruid=fruid,
+                            sdr=self._sdr.fru[fruid])
+            await tfru.initialize()
+            fruinf = tfru.info
+            if fruinf is not None:
+                fruinf = await self._oem.process_fru(fruinf,
+                                               self._sdr.fru[fruid].fru_name)
+            # check the fruinf again as the oem process may return None
+            if fruinf:
+                yield (self._sdr.fru[fruid].fru_name, fruinf)
+        async for componentpair in self._oem.get_oem_inventory():
+            yield componentpair
+
+    async def get_leds(self):
+        """Get LED status information
+
+        This provides a detailed view of the LEDs of the managed system.
+        """
+        await self.oem_init()
+        return await self._oem.get_leds()
+
+    async def get_ntp_enabled(self):
+        await self.oem_init()
+        return await self._oem.get_ntp_enabled()
+
+    async def set_ntp_enabled(self, enable):
+        await self.oem_init()
+        return await self._oem.set_ntp_enabled(enable)
+
+    async def get_ntp_servers(self):
+        await self.oem_init()
+        return await self._oem.get_ntp_servers()
+
+    async def set_ntp_server(self, server, index=0):
+        await self.oem_init()
+        return await self._oem.set_ntp_server(server, index)
+
+    async def get_health(self):
+        """Summarize health of managed system
+
+        This provides a summary of the health of the managed system.
+        It additionally provides an iterable list of reasons for
+        warning, critical, or failed assessments.
+        """
+        summary = {'badreadings': [], 'health': const.Health.Ok}
+        fallbackreadings = []
+        try:
+            await self.oem_init()
+            fallbackreadings = await self._oem.get_health(summary)
+            async for reading in self.get_sensor_data():
+                if reading.health != const.Health.Ok:
+                    summary['health'] |= reading.health
+                    summary['badreadings'].append(reading)
+        except exc.BypassGenericBehavior:
+            pass
+        if not summary['badreadings']:
+            summary['badreadings'] = fallbackreadings
+        return summary
+
+    async def get_system_power_watts(self):
+        await self.oem_init()
+        return await self._oem.get_system_power_watts(self)
+    
+    async def get_inlet_temperature(self):
+        await self.oem_init()
+        return await self._oem.get_inlet_temperature(self)
+
+    async def get_average_processor_temperature(self):
+        await self.oem_init()
+        return await self._oem.get_average_processor_temperature(self)
+
+    async def get_sensor_reading(self, sensorname):
+        """Get a sensor reading by name
+
+        Returns a single decoded sensor reading per the name
+        passed in
+
+        :param sensorname:  Name of the desired sensor
+        :returns: sdr.SensorReading object
+        """
+        await self.init_sdr()
+        for sensor in self._sdr.get_sensor_numbers():
+            if self._sdr.sensors[sensor].name == sensorname:
+                currsensor = self._sdr.sensors[sensor]
+                rsp = await self.raw_command(command=0x2d, netfn=4,
+                                       rslun=currsensor.sensor_lun,
+                                       data=(currsensor.sensor_number,))
+                return self._sdr.sensors[sensor].decode_sensor_reading(
+                    self, rsp['data'])
+        await self.oem_init()
+        return await self._oem.get_sensor_reading(sensorname)
+
+    async def _fetch_lancfg_param(self, channel, param, prefixlen=False):
+        """Internal helper for fetching lan cfg parameters
+
+        If the parameter revison != 0x11, bail.  Further, if 4 bytes, return
+        string with ipv4.  If 6 bytes, colon delimited hex (mac address).  If
+        one byte, return the int value
+        """
+        fetchcmd = bytearray((channel, param, 0, 0))
+        try:
+            fetched = await self.oldraw_command(0xc, 2, data=fetchcmd)
+        except exc.IpmiException as ie:
+            if ie.ipmicode == 0x80:
+                return None
+            raise
+        fetchdata = fetched['data']
+        if bytearray(fetchdata)[0] != 17:
+            return None
+        if param == 0x14:
+            vlaninfo = struct.unpack('<H', fetchdata[1:])[0]
+            if vlaninfo & 0x8000 == 0x8000:
+                return vlaninfo & 0xfff
+            else:
+                return 'off'      
+        if len(fetchdata) == 5:  # IPv4 address
+            if prefixlen:
+                return _mask_to_cidr(fetchdata[1:])
+            else:
+                ip = socket.inet_ntoa(fetchdata[1:])
+                if ip == '0.0.0.0':
+                    return None
+                return ip
+        elif len(fetchdata) == 7:  # MAC address
+            mac = '{0:02x}:{1:02x}:{2:02x}:{3:02x}:{4:02x}:{5:02x}'.format(
+                *bytearray(fetchdata[1:]))
+            if mac == '00:00:00:00:00:00':
+                return None
+            return mac
+        elif len(fetchdata) == 2:
+            return bytearray(fetchdata)[1]
+        else:
+            raise Exception("Unrecognized data format " + repr(fetchdata))
+
+    def get_extended_bmc_configuration(self):
+        self.oem_init()
+        return self._oem.get_extended_bmc_configuration()
+
+    async def get_bmc_configuration(self):
+        await self.oem_init()
+        return await self._oem.get_bmc_configuration()
+
+    async def set_bmc_configuration(self, changeset):
+        await self.oem_init()
+        return await self._oem.set_bmc_configuration(changeset)
+
+    async def clear_bmc_configuration(self):
+        await self.oem_init()
+        return await self._oem.clear_bmc_configuration()
+
+    async def get_system_configuration(self, hideadvanced=True):
+        await self.oem_init()
+        return await self._oem.get_system_configuration(hideadvanced)
+
+    async def set_system_configuration(self, changeset):
+        await self.oem_init()
+        return await self._oem.set_system_configuration(changeset)
+
+    async def clear_system_configuration(self):
+        """Clear the Bios/UEFI configuration
+
+        This requests the system revert to factory default settings
+        """
+        await self.oem_init()
+        return await self._oem.clear_system_configuration()
+
+    async def set_net6_configuration(self, static_addresses=None, static_gateway=None, channel=None):
+        if static_addresses is None and static_gateway is None:
+            return
+        if channel is None:
+            channel = await self.get_network_channel()
+        if static_addresses is not None:
+            i = 0
+            for va in static_addresses:
+                if '/' in va:
+                    va, plen = va.split('/', 1)
+                else:
+                    plen = '64'
+                plen = int(plen)
+                vab = bytearray(socket.inet_pton(socket.AF_INET6, va))
+                cmddata = bytearray([channel, 56, 0, 0x80]) + vab + bytearray([plen, 0])
+                await self.raw_command(netfn=0xc, command=1, data=cmddata)
+        if static_gateway is not None:
+            gwb = bytearray(socket.inet_pton(socket.AF_INET6, static_gateway))
+            cmddata = bytearray([channel, 65]) + gwb
+            await self.raw_command(netfn=0xc, command=1, data=cmddata)
+    
+    async def get_net6_configuration(self, channel=None):
+        if channel is None:
+            channel = await self.get_network_channel()
+        retdata = {}
+        ip6a = await self.raw_command(netfn=0xc, command=2, data=(channel, 56, 0, 0))
+        ip6d = bytearray(ip6a['data'])
+        if ip6d[0] != 0x11:
+            raise Exception('Unsupported reply')
+        if ip6d[2] & 0x80 == 0x80:
+            ip6b = ip6d[3:19]
+            ip6addr = socket.inet_ntop(socket.AF_INET6, ip6b)
+            plen = ip6d[19]
+            retdata['static_addrs'] = ['{}/{}'.format(ip6addr, plen)]
+        ip6g = await self.raw_command(netfn=0xc, command=2, data=(channel, 65, 0, 0))
+        ip6gd = bytearray(ip6g['data'])
+        if ip6gd[0] != 0x11:
+            raise Exception('Unsupported reply')
+        gwa = socket.inet_ntop(socket.AF_INET6, bytes(ip6gd[1:17]))
+        retdata['static_gateway'] = gwa
+        return retdata
+
+    async def set_net_configuration(self, ipv4_address=None, ipv4_configuration=None,
+                              ipv4_gateway=None, vlan_id=None, channel=None):
+        """Set network configuration data.
+
+        Apply desired network configuration data, leaving unspecified
+        parameters alone.
+
+        :param ipv4_address:  CIDR notation for IP address and netmask
+                          Example: '192.168.0.10/16'
+        :param ipv4_configuration: Method to use to configure the network.
+                        'DHCP' or 'Static'.
+        :param ipv4_gateway: IP address of gateway to use.
+        :param channel:  LAN channel to configure, defaults to autodetect
+        """
+        if (ipv4_address is None and ipv4_configuration is None
+                and ipv4_gateway is None and vlan_id is None):
+            return
+        if channel is None:
+            channel = await self.get_network_channel()
+        if ipv4_configuration is not None:
+            cmddata = [channel, 4, 0]
+            if ipv4_configuration.lower() == 'dhcp':
+                cmddata[-1] = 2
+            elif ipv4_configuration.lower() == 'static':
+                cmddata[-1] = 1
+            else:
+                raise Exception('Unrecognized ipv4cfg parameter {0}'.format(
+                    ipv4_configuration))
+            await self.raw_command(netfn=0xc, command=1, data=cmddata)
+        if ipv4_address is not None:
+            netmask = None
+            if '/' in ipv4_address:
+                ipv4_address, prefix = ipv4_address.split('/')
+                netmask = _cidr_to_mask(int(prefix))
+            cmddata = bytearray((channel, 3)) + socket.inet_aton(ipv4_address)
+            await self.raw_command(netfn=0xc, command=1, data=cmddata)
+            if netmask is not None:
+                cmddata = bytearray((channel, 6)) + netmask
+                await self.raw_command(netfn=0xc, command=1, data=cmddata)
+        if ipv4_gateway is not None:
+            cmddata = bytearray((channel, 12)) + socket.inet_aton(ipv4_gateway)
+            await self.raw_command(netfn=0xc, command=1, data=cmddata)
+        if vlan_id in ('off', 0, '0'):
+            cmddata = bytearray((channel, 0x14, 0, 0))
+            await self.raw_command(netfn=0xc, command=1, data=cmddata)
+        elif vlan_id is not None:
+            cmddata = bytearray((channel, 0x14)) + struct.pack('<H', int(vlan_id) | 0x8000)
+            await self.raw_command(netfn=0xc, command=1, data=cmddata)        
+
+    async def get_storage_configuration(self):
+        """"Get storage configuration data
+
+        Retrieves the storage configuration from the target.  Data is given
+        about disks, pools, and volumes.  When referencing something, use the
+        relevant 'cfgpath' attribute to describe it.  It is not guaranteed that
+        cfgpath will be consistent version to version, so a lookup is suggested
+        in end user applications.
+
+        :return: A aiohmi.storage.ConfigSpec object describing current config
+        """
+        await self.oem_init()
+        return await self._oem.get_storage_configuration()
+
+    async def clear_storage_arrays(self):
+        """Remove all array and dependent volumes from the system
+
+        :return:
+        """
+        await self.oem_init()
+        await self._oem.clear_storage_arrays()
+
+    async def remove_storage_configuration(self, cfgspec):
+        """Remove specified storage configuration from controller.
+
+        :param cfgspec: A aiohmi.storage.ConfigSpec describing what to remove
+        :return:
+        """
+        await self.oem_init()
+        return await self._oem.remove_storage_configuration(cfgspec)
+
+    async def apply_storage_configuration(self, cfgspec=None):
+        """Evaluate a configuration for validity
+
+        This will check if configuration is currently available and, if given,
+        whether the specified cfgspec can be applied.
+        :param cfgspec: A aiohmi.storage.ConfigSpec describing desired oonfig
+        :return:
+        """
+        await self.oem_init()
+        return await self._oem.apply_storage_configuration(cfgspec)
+
+    async def check_storage_configuration(self, cfgspec=None):
+        """Evaluate a configuration for validity
+
+        This will check if configuration is currently available and, if given,
+        whether the specified cfgspec can be applied.
+        :param cfgspec: A aiohmi.storage.ConfigSpec describing desired oonfig
+        :return:
+        """
+        await self.oem_init()
+        return await self._oem.check_storage_configuration(cfgspec)
+
+    async def get_net_configuration(self, channel=None, gateway_macs=True):
+        """Get network configuration data
+
+        Retrieve network configuration from the target
+
+        :param channel: Channel to configure, defaults to None for 'autodetect'
+        :param gateway_macs: Whether to retrieve mac addresses for gateways
+        :returns: A dictionary of network configuration data
+        """
+        await self.oem_init()
+
+        # support for huawei 2288H server
+        if hasattr(self._oem, 'get_oem_net_configuration'):
+            return await self._oem.get_oem_net_configuration()
+
+        if channel is None:
+            channel = await self.get_network_channel()
+        retdata = {}
+        v4addr = await self._fetch_lancfg_param(channel, 3)
+        if v4addr is None:
+            retdata['ipv4_address'] = None
+        else:
+            v4masklen = await self._fetch_lancfg_param(channel, 6, prefixlen=True)
+            retdata['ipv4_address'] = '{0}/{1}'.format(v4addr, v4masklen)
+        v4cfgmethods = {
+            0: 'Unspecified',
+            1: 'Static',
+            2: 'DHCP',
+            3: 'BIOS',
+            4: 'Other',
+        }
+        retdata['ipv4_configuration'] = v4cfgmethods[await self._fetch_lancfg_param(
+            channel, 4)]
+        retdata['mac_address'] = await self._fetch_lancfg_param(channel, 5)
+        retdata['ipv4_gateway'] = await self._fetch_lancfg_param(channel, 12)
+        retdata['ipv4_backup_gateway'] = await self._fetch_lancfg_param(channel, 14)
+        if gateway_macs:
+            retdata['ipv4_gateway_mac'] = await self._fetch_lancfg_param(channel, 13)
+            retdata['ipv4_backup_gateway_mac'] = await self._fetch_lancfg_param(
+                channel, 15)
+        retdata['vlan_id'] = await self._fetch_lancfg_param(channel, 0x14)
+        await self._oem.add_extra_net_configuration(retdata, channel)
+        return retdata
+
+    async def get_sensor_data(self):
+        """Get sensor reading objects
+
+        Iterates sensor reading objects pertaining to the currently
+        managed BMC.
+
+        :returns: Iterator of sdr.SensorReading objects
+        """
+        await self.init_sdr()
+        for sensor in self._sdr.get_sensor_numbers():
+            currsensor = self._sdr.sensors[sensor]
+            rsp = await self.raw_command(command=0x2d, netfn=4,
+                                          rslun=currsensor.sensor_lun,
+                                          data=(currsensor.sensor_number,))
+            if 'error' in rsp:
+                if rsp['code'] == 203:  # Sensor does not exist, optional dev
+                    continue
+                raise exc.IpmiException(rsp['error'], code=rsp['code'])
+            yield self._sdr.sensors[sensor].\
+                decode_sensor_reading(self, rsp['data'])
+        await self.oem_init()
+        async for reading in self._oem.get_sensor_data():
+            yield reading
+
+    async def get_sensor_descriptions(self):
+        """Get available sensor names
+
+        Iterates over the available sensor descriptions
+
+        :returns: Iterator of dicts describing each sensor
+        """
+        await self.init_sdr()
+        for sensor in self._sdr.get_sensor_numbers():
+            yield {'name': self._sdr.sensors[sensor].name,
+                   'type': self._sdr.sensors[sensor].sensor_type}
+        await self.oem_init()
+        async for sensor in self._oem.get_sensor_descriptions():
+            yield sensor
+
+    async def get_network_channel(self):
+        """Get a reasonable 'default' network channel.
+
+        When configuring/examining network configuration, it's desirable to
+        find the correct channel.  Here we run with the 'real' number of the
+        current channel if it is a LAN channel, otherwise it evaluates
+        all of the channels to find the first workable LAN channel and returns
+        that
+        """
+        if self._netchannel is None:
+            for channel in chain((0xe,), range(1, 0xc)):
+                try:
+                    rsp = await self.raw_command(
+                        netfn=6, command=0x42, data=(channel,))
+                except exc.IpmiException as ie:
+                    if ie.ipmicode == 0xcc:
+                        # We have hit an invalid channel, move on to next
+                        # candidate
+                        continue
+                    else:
+                        raise
+                chantype = bytearray(rsp['data'])[1]
+                chantype = chantype & 0b1111111
+                if chantype in (4, 6):
+                    try:
+                        # Some implementations denote an inactive channel
+                        # by refusing to do parameter retrieval
+                        if channel != 0xe:
+                            # skip checking if channel is active if we are
+                            # actively using the channel
+                            await self.raw_command(
+                                netfn=0xc, command=2, data=(channel, 5, 0, 0))
+                        # If still here, the channel seems serviceable...
+                        # However some implementations may still have
+                        # ambiguous channel info, that will need to be
+                        # picked up on an OEM extension...
+                        netchan = bytearray(rsp['data'])[0]
+                        self._netchannel = netchan & 0b1111
+                        break
+                    except exc.IpmiException:
+                        # This means the attempt to fetch parameter 5 failed,
+                        # therefore move on to next candidate channel
+                        continue
+        return self._netchannel
+
+    async def get_alert_destination_count(self, channel=None):
+        """Get the number of supported alert destinations
+
+        :param channel: Channel for alerts to be examined, defaults to current
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        rqdata = (channel, 0x11, 0, 0)
+        rsp = await self.raw_command(netfn=0xc, command=2, data=rqdata)
+        await self.oem_init()
+        if hasattr(self._oem, 'get_alert_destination_count'):
+            return await self._oem.get_alert_destination_count(ord(rsp['data'][1]))
+        return bytearray(rsp['data'])[1]
+
+    async def get_alert_destination(self, destination=0, channel=None):
+        """Get alert destination
+
+        Get a specified alert destination.  Returns a dictionary of relevant
+        configuration.  The following keys may be present:
+        acknowledge_required - Indicates whether the target expects an
+                               acknowledgement
+        acknowledge_timeout - How long it will wait for an acknowledgment
+                                  before retrying
+        retries - How many attempts will be made to deliver the alert to this
+                  destination
+        address_format - 'ipv4' or 'ipv6'
+        address - The IP address of the target
+
+        :param destination:  The destination number.  Defaults to 0
+        :param channel: The channel for alerting.  Defaults to current channel
+        """
+        await self.oem_init()
+        if hasattr(self._oem, 'get_alert_destination'):
+            return await self._oem.get_alert_destination(destination, channel)
+
+        destinfo = {}
+        if channel is None:
+            channel = await self.get_network_channel()
+        rqdata = (channel, 18, destination, 0)
+        rsp = await self.raw_command(netfn=0xc, command=2, data=rqdata)
+        dtype, acktimeout, retries = struct.unpack('BBB', rsp['data'][2:])
+        destinfo['acknowledge_required'] = dtype & 0b10000000 == 0b10000000
+        # Ignore destination type for now...
+        if destinfo['acknowledge_required']:
+            destinfo['acknowledge_timeout'] = acktimeout
+        destinfo['retries'] = retries
+        rqdata = (channel, 19, destination, 0)
+        rsp = await self.raw_command(netfn=0xc, command=2, data=rqdata)
+        if bytearray(rsp['data'])[2] & 0b11110000 == 0:
+            destinfo['address_format'] = 'ipv4'
+            destinfo['address'] = socket.inet_ntoa(rsp['data'][4:8])
+        elif bytearray(rsp['data'])[2] & 0b11110000 == 0b10000:
+            destinfo['address_format'] = 'ipv6'
+            destinfo['address'] = socket.inet_ntop(socket.AF_INET6,
+                                                   rsp['data'][3:])
+        return destinfo
+
+    async def clear_alert_destination(self, destination=0, channel=None):
+        """Clear an alert destination
+
+        Remove the specified alert destination configuration.
+
+        :param destination:  The destination to clear (defaults to 0)
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        await self.set_alert_destination(
+            '0.0.0.0', False, 0, 0, destination, channel)
+
+    async def set_alert_community(self, community, channel=None):
+        """Set the community string for alerts
+
+        This configures the string the BMC will use as the community string
+        for PET alerts/traps.
+
+        :param community: The community string
+        :param channel: The LAN channel (defaults to auto detect)
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        community = community.encode('utf-8')
+        community += b'\x00' * (18 - len(community))
+        cmddata = bytearray((channel, 16))
+        cmddata += community
+        await self.raw_command(netfn=0xc, command=1, data=cmddata)
+
+    async def _assure_alert_policy(self, channel, destination):
+        """Make sure an alert policy exists
+
+        Each policy will be a dict with the following keys:
+        -'index' - The policy index number
+        :returns: An iterable of currently configured alert policies
+        """
+        # First we do a get PEF configuration parameters to get the count
+        # of entries.  We have no guarantee that the meaningful data will
+        # be contiguous
+        rsp = await self.raw_command(netfn=4, command=0x13, data=(8, 0, 0))
+        numpol = bytearray(rsp['data'])[1]
+        desiredchandest = (channel << 4) | destination
+        availpolnum = None
+        for polnum in range(1, numpol + 1):
+            currpol = await self.raw_command(netfn=4, command=0x13,
+                                        data=(9, polnum, 0))
+            polidx, chandest = struct.unpack_from('>BB', currpol['data'][2:4])
+            if not polidx & 0b1000:
+                if availpolnum is None:
+                    availpolnum = polnum
+                continue
+            if chandest == desiredchandest:
+                return True
+        # If chandest did not equal desiredchandest ever, we need to use a slot
+        if availpolnum is None:
+            raise Exception("No available alert policy entry")
+        # 24 = 1 << 4 | 8
+        # 1 == set to which this rule belongs
+        # 8 == 0b1000, in other words, enable this policy, always send to
+        # indicated destination
+        await self.raw_command(netfn=4, command=0x12,
+                          data=(9, availpolnum, 24,
+                                desiredchandest, 0))
+
+    async def get_alert_community(self, channel=None):
+        """Get the current community string for alerts
+
+        Returns the community string that will be in SNMP traps from this
+        BMC
+
+        :param channel: The channel to get configuration for, autodetect by
+                        default
+        :returns: The community string
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        rsp = await self.raw_command(netfn=0xc, command=2, data=(channel, 16, 0, 0))
+        return rsp['data'][1:].partition('\x00')[0]
+
+    async def _supports_standard_ipv6(self):
+        # Supports the *standard* ipv6 commands for various things
+        # used to internally steer some commands to standard or OEM
+        # handler of commands
+        lanchan = await self.get_network_channel()
+        if self._ipv6support is None:
+            rsp = await self.raw_command(netfn=0xc, command=0x2, data=(2, lanchan,
+                                                                 0x32, 0, 0))
+            self._ipv6support = rsp['code'] == 0
+        return self._ipv6support
+
+    async def set_alert_destination(self, ip=None, acknowledge_required=None,
+                              acknowledge_timeout=None, retries=None,
+                              destination=0, channel=None):
+        """Configure one or more parameters of an alert destination
+
+        If any parameter is 'None' (default), that parameter is left unchanged.
+        Otherwise, all given parameters are set by this command.
+
+        :param ip: IP address of the destination.  It is currently expected
+                   that the calling code will handle any name lookup and
+                   present this data as IP address.
+        :param acknowledge_required: Whether or not the target should expect
+                                     an acknowledgement from this alert target.
+        :param acknowledge_timeout: Time to wait for acknowledgement if enabled
+        :param retries:  How many times to attempt transmit of an alert.
+        :param destination:  Destination index, defaults to 0.
+        :param channel: The channel to configure the alert on.  Defaults to
+                current
+        """
+        await self.oem_init()
+        if hasattr(self._oem, 'set_alert_destination'):
+            await self._oem.set_alert_destination(ip)
+            return
+        if channel is None:
+            channel = await self.get_network_channel()
+
+        if (acknowledge_required is not None
+                or retries is not None
+                or acknowledge_timeout is not None):
+            currtype = await self.raw_command(netfn=0xc, command=2, data=(
+                channel, 18, destination, 0))
+            if currtype['data'][0] != b'\x11':
+                raise exc.PyghmiException("Unknown parameter format")
+            currtype = bytearray(currtype['data'][1:])
+            if acknowledge_required is not None:
+                if acknowledge_required:
+                    currtype[1] |= 0b10000000
+                else:
+                    currtype[1] &= 0b1111111
+            # set PET trap destination
+            currtype[1] &= 0b1111000
+            if acknowledge_timeout is not None:
+                currtype[2] = acknowledge_timeout
+            if retries is not None:
+                currtype[3] = retries
+            destreq = bytearray((channel, 18))
+            destreq.extend(currtype)
+            await self.raw_command(netfn=0xc, command=1, data=destreq)
+        if ip is not None:
+            destdata = bytearray((channel, 19, destination))
+            try:
+                parsedip = socket.inet_pton(socket.AF_INET, ip)
+                destdata.extend((0, 0))
+                destdata.extend(parsedip)
+                destdata.extend('\x00\x00\x00\x00\x00\x00')
+            except socket.error:
+                parsedip = socket.inet_pton(socket.AF_INET6, ip)
+                destdata.append(0b10000000)
+                destdata.extend(parsedip)
+            await self.raw_command(netfn=0xc, command=1, data=destdata)
+        if not ip == '0.0.0.0':
+            await self._assure_alert_policy(channel, destination)
+
+    async def get_hostname(self):
+        """Get the hostname used by the BMC in various contexts
+
+        This can vary somewhat in interpretation, but generally speaking
+        this should be the name that shows up on UIs and in DHCP requests and
+        DNS registration requests, as applicable.
+
+        :return: current hostname
+        """
+        await self.oem_init()
+        try:
+            return await self._oem.get_hostname()
+        except exc.UnsupportedFunctionality:
+            # Use the DCMI MCI field as a fallback, since it's the closest
+            # thing in the IPMI Spec for this
+            return await self.get_mci()
+
+    async def get_mci(self):
+        """Set the management controller identifier.
+
+        Try the OEM command first,if False, then set it per DCMI specification
+
+        :returns: The identifier as a string
+        """
+        await self.oem_init()
+        identifier = await self._oem.get_oem_identifier()
+        if identifier:
+            return identifier
+        return await self._chunkwise_dcmi_fetch(9)
+
+    async def set_hostname(self, hostname):
+        """Set the hostname to be used by the BMC in various contexts.
+
+        See get_hostname for details
+
+        :param hostname: The hostname to set
+        :return: Nothing
+        """
+        await self.oem_init()
+        try:
+            return await self._oem.set_hostname(hostname)
+        except exc.UnsupportedFunctionality:
+            return await self.set_mci(hostname)
+
+    async def set_mci(self, mci):
+        """Set the management controller identifier.
+
+        Try the OEM command first, if False, then set it per DCMI specification
+        """
+        await self.oem_init()
+        if not isinstance(mci, bytes):
+            mci = mci.encode('utf8')
+        ret = await self._oem.set_oem_identifier(mci)
+        if ret:
+            return
+        return await self._chunkwise_dcmi_set(0xa, mci + b'\x00')
+
+    async def get_asset_tag(self):
+        """Get the system asset tag, per DCMI specification
+
+        :returns: The asset tag
+        """
+        await self.oem_init()
+        if hasattr(self._oem, 'get_asset_tag'):
+            return await self._oem.get_asset_tag()
+        return await self._chunkwise_dcmi_fetch(6)
+
+    async def set_asset_tag(self, tag):
+        """Set the asset tag value
+
+        """
+        await self.oem_init()
+        if hasattr(self._oem, 'set_asset_tag'):
+            return await self._oem.set_asset_tag(tag)
+        return await self._chunkwise_dcmi_set(8, tag)
+
+    async def _chunkwise_dcmi_fetch(self, command):
+        szdata = await self.raw_command(
+            netfn=0x2c, command=command, data=(0xdc, 0, 0))
+        totalsize = bytearray(szdata['data'])[1]
+        chksize = 0xf
+        offset = 0
+        retstr = b''
+        while offset < totalsize:
+            if (offset + chksize) > totalsize:
+                chksize = totalsize - offset
+            chk = await self.raw_command(
+                netfn=0x2c, command=command, data=(0xdc, offset, chksize))
+            retstr += chk['data'][2:]
+            offset += chksize
+        if not isinstance(retstr, str):
+            retstr = retstr.decode('utf-8')
+        return retstr
+
+    async def _chunkwise_dcmi_set(self, command, data):
+        chunks = [data[i:i + 15] for i in range(0, len(data), 15)]
+        offset = 0
+        for chunk in chunks:
+            chunk = bytearray(chunk)
+            cmddata = bytearray((0xdc, offset, len(chunk)))
+            cmddata += chunk
+            # set offset, otherwise the last setting will override
+            # the previous setting
+            offset += len(chunk)
+            await self.raw_command(netfn=0x2c, command=command, data=cmddata)
+
+    async def set_channel_access(self, channel=None,
+                           access_update_mode='non_volatile',
+                           alerting=False, per_msg_auth=False,
+                           user_level_auth=False, access_mode='always',
+                           privilege_update_mode='non_volatile',
+                           privilege_level='administrator'):
+        """Set channel access
+
+        :param channel: number [1:7]
+
+        :param access_update_mode:
+            dont_change  = don't set or change Channel Access
+            non_volatile = set non-volatile Channel Access
+            volatile     = set volatile (active) setting of Channel Access
+
+        :param alerting: PEF Alerting Enable/Disable
+        True  = enable PEF Alerting
+        False = disable PEF Alerting on this channel
+                (Alert Immediate command can still be used to generate alerts)
+
+        :param per_msg_auth: Per-message Authentication
+        True  = enable
+        False = disable Per-message Authentication. [Authentication required to
+                activate any session on this channel, but authentication not
+                used on subsequent packets for the session.]
+
+        :param user_level_auth: User Level Authentication Enable/Disable.
+        True  = enable User Level Authentication. All User Level commands are
+            to be authenticated per the Authentication Type that was
+            negotiated when the session was activated.
+        False = disable User Level Authentication. Allow User Level commands to
+            be executed without being authenticated.
+            If the option to disable User Level Command authentication is
+            accepted, the BMC will accept packets with Authentication Type
+            set to None if they contain user level commands.
+            For outgoing packets, the BMC returns responses with the same
+            Authentication Type that was used for the request.
+
+        :param access_mode: Access Mode for IPMI messaging
+        (PEF Alerting is enabled/disabled separately from IPMI messaging)
+        disabled = disabled for IPMI messaging
+        pre_boot = pre-boot only channel only available when system is in a
+                powered down state or in BIOS prior to start of boot.
+        always   = channel always available regardless of system mode.
+                BIOS typically dedicates the serial connection to the BMC.
+        shared   = same as always available, but BIOS typically leaves the
+                serial port available for software use.
+
+        :param privilege_update_mode: Channel Privilege Level Limit.
+            This value sets the maximum privilege level
+            that can be accepted on the specified channel.
+            dont_change  = don't set or change channel Privilege Level Limit
+            non_volatile = non-volatile Privilege Level Limit according
+            volatile     = volatile setting of Privilege Level Limit
+
+        :param privilege_level: Channel Privilege Level Limit
+            * reserved      = unused
+            * callback
+            * user
+            * operator
+            * administrator
+            * proprietary   = used by OEM
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        data = []
+        data.append(channel & 0b00001111)
+        access_update_modes = {
+            'dont_change': 0,
+            'non_volatile': 1,
+            'volatile': 2,
+            # 'reserved': 3
+        }
+        b = 0
+        b |= (access_update_modes[access_update_mode] << 6) & 0b11000000
+        if alerting:
+            b |= 0b00100000
+        if per_msg_auth:
+            b |= 0b00010000
+        if user_level_auth:
+            b |= 0b00001000
+        access_modes = {
+            'disabled': 0,
+            'pre_boot': 1,
+            'always': 2,
+            'shared': 3,
+        }
+        b |= access_modes[access_mode] & 0b00000111
+        data.append(b)
+        b = 0
+        privilege_update_modes = {
+            'dont_change': 0,
+            'non_volatile': 1,
+            'volatile': 2,
+            # 'reserved': 3
+        }
+        b |= (privilege_update_modes[privilege_update_mode] << 6) & 0b11000000
+        privilege_levels = {
+            'reserved': 0,
+            'callback': 1,
+            'user': 2,
+            'operator': 3,
+            'administrator': 4,
+            'proprietary': 5,
+            # 'no_access': 0x0F,
+        }
+        b |= privilege_levels[privilege_level] & 0b00000111
+        data.append(b)
+        response = self.raw_command(netfn=0x06, command=0x40, data=data)
+        if 'error' in response:
+            raise Exception(response['error'])
+        return True
+
+    async def get_channel_access(self, channel=None, read_mode='volatile'):
+        """Get channel access
+
+        :param channel: number [1:7]
+        :param read_mode:
+        non_volatile  = get non-volatile Channel Access
+        volatile      = get present volatile (active) setting of Channel Access
+
+        :return: A Python dict with the following keys/values:
+          {
+            - alerting:
+            - per_msg_auth:
+            - user_level_auth:
+            - access_mode:{
+                0: 'disabled',
+                1: 'pre_boot',
+                2: 'always',
+                3: 'shared'
+              }
+            - privilege_level: {
+                1: 'callback',
+                2: 'user',
+                3: 'operator',
+                4: 'administrator',
+                5: 'proprietary',
+              }
+           }
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        data = []
+        data.append(channel & 0b00001111)
+        b = 0
+        read_modes = {
+            'non_volatile': 1,
+            'volatile': 2,
+        }
+        b |= (read_modes[read_mode] << 6) & 0b11000000
+        data.append(b)
+
+        response = await self.raw_command(netfn=0x06, command=0x41, data=data)
+        if 'error' in response:
+            raise Exception(response['error'])
+
+        data = response['data']
+        if len(data) != 2:
+            raise Exception('expecting 2 data bytes')
+
+        r = {}
+        r['alerting'] = data[0] & 0b10000000 > 0
+        r['per_msg_auth'] = data[0] & 0b01000000 > 0
+        r['user_level_auth'] = data[0] & 0b00100000 > 0
+        access_modes = {
+            0: 'disabled',
+            1: 'pre_boot',
+            2: 'always',
+            3: 'shared'
+        }
+        r['access_mode'] = access_modes[data[0] & 0b00000011]
+        privilege_levels = {
+            0: 'reserved',
+            1: 'callback',
+            2: 'user',
+            3: 'operator',
+            4: 'administrator',
+            5: 'proprietary',
+            # 0x0F: 'no_access'
+        }
+        r['privilege_level'] = privilege_levels[data[1] & 0b00001111]
+        return r
+
+    async def get_screenshot(self, outfile):
+        await self.oem_init()
+        return await self._oem.get_screenshot(outfile)
+
+    async def get_channel_info(self, channel=None):
+        """Get channel info
+
+        :param channel: number [1:7]
+
+        :return:
+        session_support:
+            no_session: channel is session-less
+            single: channel is single-session
+            multi: channel is multi-session
+            auto: channel is session-based (channel could alternate between
+                single- and multi-session operation, as can occur with a
+                serial/modem channel that supports connection mode auto-detect)
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        data = []
+        data.append(channel & 0b00001111)
+        response = await self.raw_command(netfn=0x06, command=0x42, data=data)
+        if 'error' in response:
+            raise Exception(response['error'])
+        data = response['data']
+        if len(data) != 9:
+            raise Exception('expecting 10 data bytes got: {0}'.format(data))
+        r = {}
+        r['Actual channel'] = data[0] & 0b00000111
+        channel_medium_types = {
+            0: 'reserved',
+            1: 'IPMB',
+            2: 'ICMB v1.0',
+            3: 'ICMB v0.9',
+            4: '802.3 LAN',
+            5: 'Asynch. Serial/Modem (RS-232)',
+            6: 'Other LAN',
+            7: 'PCI SMBus',
+            8: 'SMBus v1.0/1.1',
+            9: 'SMBus v2.0',
+            0x0a: 'reserved for USB 1.x',
+            0x0b: 'reserved for USB 2.x',
+            0x0c: 'System Interface (KCS, SMIC, or BT)',
+            # 60h-7Fh: OEM
+            # all other  reserved
+        }
+        t = data[1] & 0b01111111
+        if t in channel_medium_types:
+            r['Channel Medium type'] = channel_medium_types[t]
+        else:
+            r['Channel Medium type'] = 'OEM {:02X}'.format(t)
+        r['5-bit Channel IPMI Messaging Protocol Type'] = data[2] & 0b00001111
+        session_supports = {
+            0: 'no_session',
+            1: 'single',
+            2: 'multi',
+            3: 'auto'
+        }
+        r['session_support'] = session_supports[(data[3] & 0b11000000) >> 6]
+        r['active_session_count'] = data[3] & 0b00111111
+        r['Vendor ID'] = [data[4], data[5], data[6]]
+        r['Auxiliary Channel Info'] = [data[7], data[8]]
+        return r
+
+    async def set_user_access(self, uid, channel=None, callback=False,
+                        link_auth=True, ipmi_msg=True, privilege_level='user'):
+        """Set user access
+
+        :param uid: user number [1:16]
+
+        :param channel: number [1:7]
+
+        :param callback: User Restricted to Callback
+        False = User Privilege Limit is determined by the User Privilege Limit
+            parameter, below, for both callback and non-callback connections.
+        True  = User Privilege Limit is determined by the User Privilege Limit
+            parameter for callback connections, but is restricted to Callback
+            level for non-callback connections. Thus, a user can only initiate
+            a Callback when they 'call in' to the BMC, but once the callback
+            connection has been made, the user could potentially establish a
+            session as an Operator.
+
+        :param link_auth: User Link authentication
+        enable/disable (used to enable whether this
+        user's name and password information will be used for link
+        authentication, e.g. PPP CHAP) for the given channel. Link
+        authentication itself is a global setting for the channel and is
+        enabled/disabled via the serial/modem configuration parameters.
+
+        :param ipmi_msg: User IPMI Messaginge:
+        (used to enable/disable whether
+        this user's name and password information will be used for IPMI
+        Messaging. In this case, 'IPMI Messaging' refers to the ability to
+        execute generic IPMI commands that are not associated with a
+        particular payload type. For example, if IPMI Messaging is disabled for
+        a user, but that user is enabled for activatallow_authing the SOL
+        payload type, then IPMI commands associated with SOL and session
+        management, such as Get SOL Configuration Parameters and Close Session
+        are available, but generic IPMI commands such as Get SEL Time are
+        unavailable.)
+
+        :param privilege_level:
+        User Privilege Limit. (Determines the maximum privilege level that the
+        user is allowed to switch to on the specified channel.)
+            * callback
+            * user
+            * operator
+            * administrator
+            * proprietary
+            * no_access
+            * custom.<name>
+        """
+        await self.oem_init()
+        if hasattr(self._oem, 'oem_user_access'):
+            callback, privilege_level = self._oem.oem_user_access(
+                callback, privilege_level)
+
+        if channel is None:
+            channel = await self.get_network_channel()
+        b = 0b10000000
+        if callback:
+            b |= 0b01000000
+        if link_auth:
+            b |= 0b00100000
+        if ipmi_msg:
+            b |= 0b00010000
+        b |= channel & 0b00001111
+        privilege_levels = {
+            'reserved': 0,
+            'callback': 1,
+            'user': 2,
+            'operator': 3,
+            'administrator': 4,
+            'proprietary': 5,
+            'no_access': 0x0F,
+        }
+        await self._oem.set_user_access(
+            uid, channel, callback, link_auth, ipmi_msg, privilege_level)
+        if privilege_level.startswith('custom.'):
+            return True  # unable to proceed with standard support
+        data = [b, uid & 0b00111111,
+                privilege_levels[privilege_level] & 0b00001111, 0]
+        response = await self.raw_command(netfn=0x06, command=0x43, data=data)
+        if 'error' in response:
+            raise Exception(response['error'])
+        # Set KVM and VMedia Allowed if is administrator
+        if privilege_level == 'administrator':
+            await self.set_extended_privilleges(uid)
+        return True
+
+    async def get_user_access(self, uid, channel=None):
+        """Get user access
+
+        :param uid: user number [1:16]
+        :param channel: number [1:7]
+
+        :return:
+        channel_info:
+            max_user_count = maximum number of user IDs on this channel
+            enabled_users = count of User ID slots presently in use
+            users_with_fixed_names = count of user IDs with fixed names
+
+        access:
+            callback
+            link_auth
+            ipmi_msg
+            privilege_level: [reserved, callback, user,
+                              operatorm administrator, proprietary, no_access]
+        """
+        # user access available during call-in or callback direct connection
+        if channel is None:
+            channel = await self.get_network_channel()
+        data = [channel, uid]
+        response = await self.raw_command(netfn=0x06, command=0x44, data=data)
+        if 'error' in response:
+            raise Exception(response['error'])
+        data = response['data']
+        if len(data) != 4:
+            raise Exception('expecting 4 data bytes')
+        r = {'channel_info': {}, 'access': {}}
+        r['channel_info']['max_user_count'] = data[0]
+        r['channel_info']['enabled_users'] = data[1] & 0b00111111
+        r['channel_info']['users_with_fixed_names'] = data[2] & 0b00111111
+        r['access']['callback'] = (data[3] & 0b01000000) != 0
+        r['access']['link_auth'] = (data[3] & 0b00100000) != 0
+        r['access']['ipmi_msg'] = (data[3] & 0b00010000) != 0
+        await self.oem_init()
+        oempriv = await self._oem.get_user_privilege_level(uid)
+        if oempriv:
+            r['access']['privilege_level'] = oempriv
+        else:
+            privilege_levels = {
+                0: 'reserved',
+                1: 'callback',
+                2: 'user',
+                3: 'operator',
+                4: 'administrator',
+                5: 'proprietary',
+                0x0F: 'no_access'
+            }
+            r['access']['privilege_level'] = privilege_levels[data[3] & 0b00001111]
+        return r
+
+    async def set_user_name(self, uid, name):
+        """Set user name
+
+        :param uid: user number [1:16]
+        :param name: username (limit of 16bytes)
+        """
+        data = [uid]
+        if not isinstance(name, bytes):
+            name = name.encode('utf-8')
+        if len(name) > 16:
+            raise Exception('name must be less than or = 16 chars')
+        name = name.ljust(16, b'\x00')
+        name = bytearray(name)
+        data.extend(name)
+        # set timeout to 2s to avoid retry causing enable failure
+        await self.raw_command(netfn=0x06, command=0x45, data=data, timeout=2)
+        return True
+
+    async def get_user_name(self, uid, return_none_on_error=True):
+        """Get user name
+
+        :param uid: user number [1:16]
+        :param return_none_on_error: return None on error
+            TODO: investigate return code on error
+        """
+        response = await self.raw_command(netfn=0x06, command=0x46, data=(uid,))
+        if 'error' in response:
+            if return_none_on_error:
+                return None
+            raise Exception(response['error'])
+        name = None
+        if 'data' in response:
+            data = response['data']
+            if len(data) == 16:
+                # convert int array to string
+                n = ''.join(chr(data[i]) for i in range(0, len(data)))
+                # remove padded \x00 chars
+                n = n.rstrip("\x00")
+                if len(n) > 0:
+                    name = n
+        return name
+
+    async def set_user_password(self, uid, mode='set_password', password=None):
+        """Set user password and (modes)
+
+        :param uid: id number of user.  see: get_names_uid()['name']
+
+        :param mode:
+            disable       = disable user connections
+            enable        = enable user connections
+            set_password  = set or ensure password
+            test_password = test password is correct
+
+        :param password: max 16 char string
+            (optional when mode is [disable or enable])
+
+        :return:
+            True on success
+            when mode = test_password, return False on bad password
+        """
+        mode_mask = {
+            'disable': 0,
+            'enable': 1,
+            'set_password': 2,
+            'test_password': 3
+        }
+        data = [uid, mode_mask[mode]]
+        if password:
+            if not isinstance(password, bytes):
+                password = password.encode('utf8')
+            if 21 > len(password) > 16:
+                password = password.ljust(20, b'\x00')
+                data[0] |= 0b10000000
+            elif len(password) > 20:
+                raise Exception('password has limit of 20 chars')
+            else:
+                password = password.ljust(16, b'\x00')
+            data.extend(bytearray(password))
+
+        await self.oem_init()
+        data = await self._oem.process_password(password, data)
+        try:
+            await self.raw_command(netfn=0x06, command=0x47, data=data)
+        except exc.IpmiException as ie:
+            if mode == 'test_password':
+                return False
+            elif mode in ('enable', 'disable') and ie.ipmicode == 0xcc:
+                # Some BMCs see redundant calls to password disable/enable
+                # as invalid
+                return True
+            raise
+        return True
+
+    async def get_channel_max_user_count(self, channel=None):
+        """Get max users in channel (helper)
+
+        :param channel: number [1:7]
+        :return: int -- often 16
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        access = await self.get_user_access(channel=channel, uid=1)
+        return access['channel_info']['max_user_count']
+
+    async def get_user(self, uid, channel=None):
+        """Get user (helper)
+
+        :param uid: user number [1:16]
+        :param channel: number [1:7]
+
+        :return:
+            name: (str)
+            uid: (int)
+            channel: (int)
+            access:
+                callback (bool)
+                link_auth (bool)
+                ipmi_msg (bool)
+                privilege_level: (str)[callback, user, operatorm administrator,
+                                       proprietary, no_access]
+            expiration:
+                None for 'unknown', 0 for no expiry, days to expire otherwise.
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        name = await self.get_user_name(uid)
+        access = await self.get_user_access(uid, channel)
+        await self.oem_init()
+        expiration = await self._oem.get_user_expiration(uid)
+        data = {'name': name, 'uid': uid, 'channel': channel,
+                'access': access['access'], 'expiration': expiration}
+        return data
+
+    async def get_name_uids(self, name, channel=None):
+        """get list of users (helper)
+
+        :param channel: number [1:7]
+
+        :return: list of users
+        """
+        if channel is None:
+            channel = await self.get_network_channel()
+        uid_list = []
+        max_ids = await self.get_channel_max_user_count(channel)
+        for uid in range(1, max_ids):
+            if name == await self.get_user_name(uid=uid):
+                uid_list.append(uid)
+        return uid_list
+
+    async def get_users(self, channel=None):
+        """get list of users and channel access information (helper)
+
+        :param channel: number [1:7]
+
+        :return:
+            name: (str)
+            uid: (int)
+            channel: (int)
+            access:
+                callback (bool)
+                link_auth (bool)
+                ipmi_msg (bool)
+                privilege_level: (str)[callback, user, operatorm administrator,
+                                       proprietary, no_access]
+        """
+        await self.oem_init()
+        if channel is None:
+            channel = await self.get_network_channel()
+        names = {}
+        max_ids = await self.get_channel_max_user_count(channel)
+        for uid in range(1, max_ids + 1):
+            name = await self.get_user_name(uid=uid)
+            if await self._oem.is_valid(name):
+                names[uid] = await self.get_user(uid=uid, channel=channel)
+        return names
+
+    async def create_user(self, uid, name, password, channel=None, callback=False,
+                    link_auth=True, ipmi_msg=True,
+                    privilege_level='user'):
+        """create/ensure a user is created with provided settings (helper)
+
+        :param privilege_level:
+            User Privilege Limit. (Determines the maximum privilege level that
+            the user is allowed to switch to on the specified channel.)
+            * callback
+            * user
+            * operator
+            * administrator
+            * proprietary
+            * no_access
+        """
+        # current user might be trying to update.. dont disable
+        # set_user_password(uid, password, mode='disable')
+        if channel is None:
+            channel = await self.get_network_channel()
+        await self.set_user_name(uid, name)
+        await self.set_user_password(uid, password=password)
+        await self.set_user_password(uid, mode='enable', password=password)
+        await self.set_user_access(uid, channel, callback=callback,
+                             link_auth=link_auth, ipmi_msg=ipmi_msg,
+                             privilege_level=privilege_level)
+        return True
+
+    async def user_delete(self, uid, channel=None):
+        """Delete user (helper)
+
+        Note that in IPMI, user 'deletion' isn't a concept.  This function
+        will make a best effort to provide the expected result (e.g.
+        web interfaces skipping names and ipmitool skipping as well.
+
+        :param uid: user number [1:16]
+        :param channel: number [1:7]
+        """
+        # TODO(jjohnson2): Provide OEM extensibility to cover user deletion
+        await self.oem_init()
+        if hasattr(self._oem, 'user_delete'):
+            try:
+                await self._oem.user_delete(uid, channel)
+            except exc.BypassGenericBehavior:
+                return
+        if hasattr(self._oem, 'user_delete_privilege_level'):
+            privilege_level = await self._oem.user_delete_privilege_level()
+        else:
+            privilege_level = 'no_access'
+
+        if channel is None:
+            channel = await self.get_network_channel()
+        await self.set_user_password(uid, mode='disable', password=None)
+        # TODO(steveweber) perhaps should set user access on all channels
+        # so new users dont get extra access
+        await self.set_user_access(uid, channel=channel, callback=False,
+                             link_auth=False, ipmi_msg=False,
+                             privilege_level=privilege_level)
+        try:
+            # First try to set name to all \x00 explicitly
+            # Fix bug-174389, don't try to send \xff command,
+            # will cause IMM1 can't login
+            await self.set_user_name(uid, '')
+        except exc.IpmiException:
+            raise
+        return True
+
+    async def disable_user(self, uid, mode):
+        """Disable User
+
+        Just disable the User.
+        This will not disable the password or revoke privileges.
+
+        :param uid: user number [1:16]
+        :param mode:
+            disable       = disable user connections
+            enable        = enable user connections
+        """
+        await self.set_user_password(uid, mode)
+        return True
+
+    async def update_user(self, user):
+        """Update User
+
+        Update user attributes, include name, password, access
+
+        :param user: user attributes
+        """
+        if 'username' in user:
+            await self.set_user_name(uid=user['uid'], name=user['username'])
+
+        privilege_level = None
+        if 'privilege_level' in user:
+            privilege_level = user['privilege_level']
+
+        if privilege_level and privilege_level == 'no_access':
+            return await self.upate_user_no_access(user, privilege_level)
+        else:
+            return await self.update_user_default(user, privilege_level)
+
+    async def upate_user_no_access(self, user, privilege_level):
+        # if set to no_access, modify password first
+        if 'password' in user:
+            await self.set_user_password(uid=user['uid'], password=user['password'])
+        await self.set_user_access(uid=user['uid'], privilege_level=privilege_level)
+
+        return True
+
+    async def update_user_default(self, user, privilege_level):
+        if privilege_level:
+            await self.set_user_access(uid=user['uid'],
+                                 privilege_level=privilege_level)
+        if 'password' in user:
+            await self.set_user_password(uid=user['uid'],
+                                   password=user['password'])
+            await self.set_user_password(uid=user['uid'], mode='enable',
+                                   password=user['password'])
+        if 'enabled' in user:
+            if user['enabled'] == 'yes':
+                mode = 'enable'
+            else:
+                mode = 'disable'
+            await self.disable_user(user['uid'], mode)
+
+        return True
+
+    async def get_firmware(self, components=(), category=None):
+        """Retrieve OEM Firmware information"""
+
+        await self.oem_init()
+        mcinfo = await self.raw_command(netfn=6, command=1)
+        major, minor = struct.unpack('BB', mcinfo['data'][2:4])
+        bmcver = '{0}.{1}'.format(major, hex(minor)[2:])
+        async for x in self._oem.get_oem_firmware(bmcver, components, category):
+            yield x
+
+    async def get_capping_enabled(self):
+        """Get PSU based power capping status
+
+        :return: True if enabled and False if disabled
+        """
+        await self.oem_init()
+        return await self._oem.get_oem_capping_enabled()
+
+    async def set_capping_enabled(self, enable):
+        """Set PSU based power capping
+
+        :param enable: True for enable and False for disable
+        """
+        await self.oem_init()
+        return await self._oem.set_oem_capping_enabled(enable)
+
+    async def set_server_capping(self, value):
+        await self.oem_init()
+        await self._oem.set_oem_server_capping(value)
+
+    async def get_server_capping(self):
+        await self.oem_init()
+        return await self._oem.get_oem_server_capping()
+
+    async def get_remote_kvm_available(self):
+        """Get remote KVM availability"""
+
+        await self.oem_init()
+        return await self._oem.get_oem_remote_kvm_available()
+
+    async def get_domain_name(self):
+        """Get Domain name"""
+
+        await self.oem_init()
+        return await self._oem.get_oem_domain_name()
+
+    async def set_domain_name(self, name):
+        """Set Domain name
+
+        :param name: domain name to be set
+        """
+        await self.oem_init()
+        await self._oem.set_oem_domain_name(name)
+
+    async def get_graphical_console(self):
+        """Get graphical console launcher"""
+        await self.oem_init()
+        return await self._oem.get_graphical_console()
+ 
+    async def get_update_status(self):
+        await self.oem_init()
+        return await self._oem.get_update_status()
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        """Send file to BMC to perform firmware update
+
+         :param filename: The filename to upload to the target BMC
+         :param data: The payload of the firmware.  Default is to read from
+                      specified filename.
+         :param progress: A callback that will be given a dict describing
+                          update process.  Provide if
+         :param bank: Indicate a target 'bank' of firmware if supported
+        """
+
+        await self.oem_init()
+        if progress is None:
+            progress = lambda x: True
+        return await self._oem.update_firmware(filename, data, progress, bank)
+
+    async def attach_remote_media(self, url, username=None, password=None):
+        """Attach remote media by url
+
+        Given a url, attach remote media (cd/usb image) to the target system.
+
+        :param url:  URL to indicate where to find image (protocol support
+                     varies by BMC)
+        :param username: Username for endpoint to use when accessing the URL.
+                         If applicable, 'domain' would be indicated by '@' or
+                         '\' syntax.
+        :param password: Password for endpoint to use when accessing the URL.
+        """
+        await self.oem_init()
+        return await self._oem.attach_remote_media(url, username, password)
+
+    async def detach_remote_media(self):
+        await self.oem_init()
+        return await self._oem.detach_remote_media()
+
+    async def upload_media(self, filename, progress=None, data=None):
+        """Upload a file to be hosted on the target BMC
+
+        This will upload the specified data to
+        the BMC so that it will make it available to the system as an emulated
+        USB device.
+
+        :param filename: The filename to use, the basename of the parameter
+                         will be given to the bmc.
+        :param progress: Optional callback for progress updates
+        """
+        await self.oem_init()
+        return await self._oem.upload_media(filename, progress, data)
+
+    async def list_media(self):
+        """List attached remote media
+
+        :returns: An iterable list of attached media
+        """
+        await self.oem_init()
+        async for m in self._oem.list_media():
+            yield m
+    
+    async def get_licenses(self):
+        await self.oem_init()
+        async for x in self._oem.get_licenses():
+            yield x
+
+    async def delete_license(self, name):
+        await self.oem_init()
+        return await self._oem.delete_license(name)
+
+    async def save_licenses(self, directory):
+        if os.path.exists(directory) and not os.path.isdir(directory):
+            raise exc.InvalidParameterValue(
+                'Not allowed to overwrite existing file: {0}'.format(
+                    directory))
+        await self.oem_init()
+        async for lic in self._oem.save_licenses(directory):
+            yield lic
+
+    async def apply_license(self, filename, progress=None, data=None):
+        await self.oem_init()
+        async for x in self._oem.apply_license(filename, progress, data):
+            yield x
+
+    async def set_extended_privilleges(self, uid):
+        """Set user extended privillege as 'KVM & VMedia Allowed'
+
+        """
+        await self.oem_init()
+        return await self._oem.set_oem_extended_privilleges(uid)
\ No newline at end of file
diff --git a/confluent_server/aiohmi/ipmi/console.py b/confluent_server/aiohmi/ipmi/console.py
new file mode 100644
index 00000000..6479b938
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/console.py
@@ -0,0 +1,551 @@
+# Copyright 2014 IBM Corporation
+# Copyright 2015-2019 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""This represents the low layer message framing portion of IPMI"""
+
+import struct
+import threading
+
+import aiohmi.exceptions as exc
+from aiohmi.ipmi.private import constants
+from aiohmi.ipmi.private import session
+from aiohmi.ipmi.private.util import _monotonic_time
+
+
+class Console(object):
+    """IPMI SOL class.
+
+    This object represents an SOL channel, multiplexing SOL data with
+    commands issued by ipmi.command.
+
+    :param bmc: hostname or ip address of BMC
+    :param userid: username to use to connect
+    :param password: password to connect to the BMC
+    :param iohandler: Either a function to call with bytes, a filehandle to
+                      use for input and output, or a tuple of (input, output)
+                      handles
+    :param force: Set to True to force on or False to force off
+    :param kg: optional parameter for BMCs configured to require it
+    """
+
+    # TODO(jbjohnso): still need an exit and a data callin function
+    def __init__(self, bmc, userid, password,
+                 iohandler, port=623,
+                 force=False, kg=None):
+        self.outputlock = threading.RLock()
+        self.keepaliveid = None
+        self.connected = False
+        self.broken = False
+        self.out_handler = iohandler
+        self.remseq = 0
+        self.myseq = 0
+        self.lastsize = 0
+        self.retriedpayload = 0
+        self.pendingoutput = []
+        self.awaitingack = False
+        self.activated = False
+        self.force_session = force
+        self.port = port
+        self.ipmi_session = None
+        self.callgotsession = None
+        self.bmc = bmc
+        self.userid = userid
+        self.password = password
+        self.port = port
+        self.kg = kg
+        self.broken = False
+
+    async def connect(self):
+        bmc = self.bmc
+        userid = self.userid
+        password = self.password
+        port = self.port
+        kg = self.kg
+        self.ipmi_session = await session.Session(
+            bmc=bmc, userid=userid, password=password, port=port, kg=kg)
+        # induce one iteration of the loop, now that we would be
+        # prepared for it in theory
+        await self._got_session({})
+
+
+    async def _got_session(self, response):
+        """Private function to navigate SOL payload activation"""
+        if 'error' in response:
+            await self._print_error(response['error'])
+            return
+        if not self.ipmi_session:
+            self.callgotsession = response
+            return
+        # Send activate sol payload directive
+        # netfn= 6 (application)
+        # command = 0x48 (activate payload)
+        # data = (1, sol payload type
+        #        1, first instance
+        #        0b11000000, -encrypt, authenticate,
+        #                      disable serial/modem alerts, CTS fine
+        #        0, 0, 0 reserved
+        response = await self.ipmi_session.raw_command(netfn=0x6, command=0x48,
+                                                       data=(1, 1, 192, 0, 0, 0))
+        # given that these are specific to the command,
+        # it's probably best if one can grep the error
+        # here instead of in constants
+        sol_activate_codes = {
+            0x81: 'SOL is disabled',
+            0x82: 'Maximum SOL session count reached',
+            0x83: 'Cannot activate payload with encryption',
+            0x84: 'Cannot activate payload without encryption',
+        }
+        if 'code' in response and response['code']:
+            if response['code'] in constants.ipmi_completion_codes:
+                await self._print_error(
+                    constants.ipmi_completion_codes[response['code']])
+                return
+            elif response['code'] == 0x80:
+                if self.force_session and not self.retriedpayload:
+                    self.retriedpayload = 1
+                    sessrsp = await self.ipmi_session.raw_command(
+                        netfn=0x6,
+                        command=0x49,
+                        data=(1, 1, 0, 0, 0, 0))
+                    await self._got_session(sessrsp)
+                    return
+                else:
+                    await self._print_error('SOL Session active for another client')
+                    return
+            elif response['code'] in sol_activate_codes:
+                await self._print_error(sol_activate_codes[response['code']])
+                return
+            else:
+                await self._print_error(
+                    'SOL encountered Unrecognized error code %d' %
+                    response['code'])
+                return
+        if 'error' in response:
+            self._print_error(response['error'])
+            return
+        self.activated = True
+        # data[0:3] is reserved except for the test mode, which we don't use
+        data = response['data']
+        self.maxoutcount = (data[5] << 8) + data[4]
+        # BMC tells us this is the maximum allowed size
+        # data[6:7] is the promise of how small packets are going to be, but we
+        # don't have any reason to worry about it
+        # some BMCs disagree on the endianness, so do both
+        valid_ports = (self.port, struct.unpack(
+            '<H', struct.pack('>H', self.port))[0])
+        if (data[8] + (data[9] << 8)) not in valid_ports:
+            # TODO(jbjohnso): support atypical SOL port number
+            raise NotImplementedError("Non-standard SOL Port Number")
+        # ignore data[10:11] for now, the vlan detail, shouldn't matter to this
+        # code anyway...
+        # NOTE(jbjohnso):
+        # We will use a special purpose keepalive
+        if self.ipmi_session.sol_handler is not None:
+            # If there is erroneously another SOL handler already, notify
+            # it of newly established session
+            await self.ipmi_session.sol_handler({'error': 'Session Disconnected'})
+        self.keepaliveid = self.ipmi_session.register_keepalive(
+            cmd={'netfn': 6, 'command': 0x4b, 'data': (1, 1)},
+            callback=self._got_payload_instance_info)
+        self.ipmi_session.sol_handler = self._got_sol_payload
+        self.connected = True
+        # self._sendpendingoutput() checks len(self._sendpendingoutput)
+        await self._sendpendingoutput()
+
+    async def _got_payload_instance_info(self, response):
+        if 'error' in response:
+            self.activated = False
+            await self._print_error(response['error'])
+            return
+        currowner = struct.unpack(
+            "<I", struct.pack('4B', *response['data'][:4]))
+        if currowner[0] != self.ipmi_session.sessionid:
+            # the session is deactivated or active for something else
+            self.activated = False
+            await self._print_error('SOL deactivated')
+            return
+        # ok, still here, that means session is alive, but another
+        # common issue is firmware messing with mux on reboot
+        # this would be a nice thing to check, but the serial channel
+        # number is needed and there isn't an obvious means to reliably
+        # discern which channel or even *if* the serial port in question
+        # correlates at all to an ipmi channel to check mux
+
+    def _addpendingdata(self, data):
+        with self.outputlock:
+            if isinstance(data, dict):
+                self.pendingoutput.append(data)
+            else:  # it is a text situation
+                if (len(self.pendingoutput) == 0
+                        or isinstance(self.pendingoutput[-1], dict)):
+                    self.pendingoutput.append(data)
+                else:
+                    self.pendingoutput[-1] += data
+
+    def _got_cons_input(self, handle):
+        """Callback for handle events detected by ipmi session"""
+
+        self._addpendingdata(handle.read())
+        if not self.awaitingack:
+            self._sendpendingoutput()
+
+    async def close(self):
+        """Shut down an SOL session"""
+
+        if self.ipmi_session:
+            self.ipmi_session.unregister_keepalive(self.keepaliveid)
+        if self.activated and self.ipmi_session is not None:
+            try:
+                await self.ipmi_session.raw_command(netfn=6, command=0x49,
+                                              data=(1, 1, 0, 0, 0, 0))
+            except exc.IpmiException:
+                # if underlying ipmi session is not working, then
+                # run with the implicit success
+                pass
+
+    async def send_data(self, data):
+        if self.broken:
+            return
+        self._addpendingdata(data)
+        if not self.connected:
+            return
+        if not self.awaitingack:
+            await self._sendpendingoutput()
+
+    async def send_break(self):
+        self._addpendingdata({'break': 1})
+        if not self.connected:
+            return
+        if not self.awaitingack:
+            await self._sendpendingoutput()
+
+    @classmethod
+    def wait_for_rsp(cls, timeout):
+        """Delay for no longer than timeout for next response.
+
+        This acts like a sleep that exits on activity.
+
+        :param timeout: Maximum number of seconds before returning
+        """
+        return session.Session.wait_for_rsp(timeout=timeout)
+
+    async def _sendpendingoutput(self):
+        with self.outputlock:
+            dobreak = False
+            chunk = ''
+            if len(self.pendingoutput) == 0:
+                return
+            if isinstance(self.pendingoutput[0], dict):
+                if 'break' in self.pendingoutput[0]:
+                    dobreak = True
+                else:
+                    del self.pendingoutput[0]
+                    raise ValueError
+                del self.pendingoutput[0]
+            elif len(self.pendingoutput[0]) > self.maxoutcount:
+                chunk = self.pendingoutput[0][:self.maxoutcount]
+                self.pendingoutput[0] = self.pendingoutput[0][
+                    self.maxoutcount:]
+            else:
+                chunk = self.pendingoutput[0]
+                del self.pendingoutput[0]
+            await self._sendoutput(chunk, sendbreak=dobreak)
+
+    async def _sendoutput(self, output, sendbreak=False):
+        self.myseq += 1
+        self.myseq &= 0xf
+        if self.myseq == 0:
+            self.myseq = 1
+        # currently we don't try to combine ack with outgoing data
+        # so we use 0 for ack sequence number and accepted character
+        # count
+        breakbyte = 0
+        if sendbreak:
+            breakbyte = 0b10000
+        try:
+            payload = bytearray((self.myseq, 0, 0, breakbyte)) + output
+        except TypeError:  # bytearray hits unicode...
+            payload = bytearray((self.myseq, 0, 0, breakbyte
+                                 )) + output.encode('utf8')
+        self.lasttextsize = len(output)
+        needskeepalive = False
+        if self.lasttextsize == 0:
+            needskeepalive = True
+        self.awaitingack = True
+        self.lastpayload = payload
+        await self.send_payload(payload, retry=False, needskeepalive=needskeepalive)
+        retries = 5
+        while retries and self.awaitingack:
+            expiry = _monotonic_time() + 5.5 - retries
+            while self.awaitingack and _monotonic_time() < expiry:
+                await self.wait_for_rsp(0.5)
+            if self.awaitingack:
+                await self.send_payload(payload, retry=False,
+                                        needskeepalive=needskeepalive)
+            retries -= 1
+        if not retries:
+            await self._print_error('Connection lost')
+
+    async def send_payload(self, payload, payload_type=1, retry=True,
+                     needskeepalive=False):
+        while not (self.connected or self.broken):
+            session.Session.wait_for_rsp(timeout=10)
+        if self.ipmi_session is None or not self.ipmi_session.logged:
+            await self._print_error('Session no longer connected')
+            raise exc.IpmiException('Session no longer connected')
+        await self.ipmi_session.send_payload(payload,
+                                       payload_type=payload_type,
+                                       retry=retry,
+                                       needskeepalive=needskeepalive)
+
+    async def _print_info(self, info):
+        await self._print_data({'info': info})
+
+    async def _print_error(self, error):
+        self.broken = True
+        if self.ipmi_session:
+            self.ipmi_session.unregister_keepalive(self.keepaliveid)
+            if (self.ipmi_session.sol_handler
+                    and self.ipmi_session.sol_handler.__self__ is self):
+                self.ipmi_session.sol_handler = None
+            self.ipmi_session = None
+        if type(error) == dict:
+            await self._print_data(error)
+        else:
+            await self._print_data({'error': error})
+
+    async def _print_data(self, data):
+        """Convey received data back to caller in the format of their choice.
+
+        Caller may elect to provide this class filehandle(s) or else give a
+        callback function that this class will use to convey data back to
+        caller.
+        """
+        await self.out_handler(data)
+
+    async def _got_sol_payload(self, payload):
+        """SOL payload callback"""
+
+        # TODO(jbjohnso) test cases to throw some likely scenarios at functions
+        # for example, retry with new data, retry with no new data
+        # retry with unexpected sequence number
+        if type(payload) == dict:  # we received an error condition
+            self.activated = False
+            await self._print_error(payload)
+            return
+        newseq = payload[0] & 0b1111
+        ackseq = payload[1] & 0b1111
+        ackcount = payload[2]
+        nacked = payload[3] & 0b1000000
+        poweredoff = payload[3] & 0b100000
+        deactivated = payload[3] & 0b10000
+        breakdetected = payload[3] & 0b100
+        # for now, ignore overrun.  I assume partial NACK for this reason or
+        # for no reason would be treated the same, new payload with partial
+        # data.
+        remdata = ""
+        remdatalen = 0
+        if newseq != 0:  # this packet at least has some data to send to us..
+            if len(payload) > 4:
+                remdatalen = len(payload[4:])  # store remote len before dupe
+                # retry logic, we must ack *this* many even if it is
+                # a retry packet with new partial data
+                remdata = bytes(payload[4:])
+            if newseq == self.remseq:  # it is a retry, but could have new data
+                if remdatalen > self.lastsize:
+                    remdata = bytes(remdata[4 + self.lastsize:])
+                else:  # no new data...
+                    remdata = ""
+            else:  # TODO(jbjohnso) what if remote sequence number is wrong??
+                self.remseq = newseq
+            self.lastsize = remdatalen
+            if remdata:  # Do not subject callers to empty data
+                await self._print_data(remdata)
+            ackpayload = bytearray((0, self.remseq, remdatalen, 0))
+            # Why not put pending data into the ack? because it's rare
+            # and might be hard to decide what to do in the context of
+            # retry situation
+            try:
+                await self.send_payload(ackpayload, retry=False)
+            except exc.IpmiException:
+                # if the session is broken, then close the SOL session
+                self.close()
+        if self.myseq != 0 and ackseq == self.myseq:  # the bmc has something
+            # to say about last xmit
+            self.awaitingack = False
+            if nacked and not breakdetected:  # the BMC was in some way unhappy
+                if poweredoff:
+                    await self._print_info("Remote system is powered down")
+                if deactivated:
+                    self.activated = False
+                    await self._print_error("Remote IPMI console disconnected")
+                else:  # retry all or part of packet, but in a new form
+                    # also add pending output for efficiency and ease
+                    newtext = self.lastpayload[4 + ackcount:]
+                    with self.outputlock:
+                        if (self.pendingoutput
+                                and not isinstance(self.pendingoutput[0],
+                                                   dict)):
+                            self.pendingoutput[0] = \
+                                newtext + self.pendingoutput[0]
+                        else:
+                            self.pendingoutput = [newtext] + self.pendingoutput
+            # self._sendpendingoutput() checks len(self._sendpendingoutput)
+            await self._sendpendingoutput()
+        elif ackseq != 0 and self.awaitingack:
+            # if an ack packet came in, but did not match what we
+            # expected, retry our payload now.
+            # the situation that was triggered was a senseless retry
+            # when data came in while we xmitted.  In theory, a BMC
+            # should handle a retry correctly, but some do not, so
+            # try to mitigate by avoiding overeager retries
+            # occasional retry of a packet
+            # sooner than timeout suggests is evidently a big deal
+            await self.send_payload(payload=self.lastpayload, retry=False)
+
+    def main_loop(self):
+        """Process all events until no more sessions exist.
+
+        If a caller is a simple little utility, provide a function to
+        eternally run the event loop.  More complicated usage would be expected
+        to provide their own event loop behavior, though this could be used
+        within the greenthread implementation of caller's choice if desired.
+        """
+        # wait_for_rsp promises to return a false value when no sessions are
+        # alive anymore
+        # TODO(jbjohnso): wait_for_rsp is not returning a true value for our
+        # own session
+        while (1):
+            session.Session.wait_for_rsp(timeout=600)
+
+
+class ServerConsole(Console):
+    """IPMI SOL class.
+
+    This object represents an SOL channel, multiplexing SOL data with
+    commands issued by ipmi.command.
+
+    :param session: IPMI session
+    :param iohandler: I/O handler
+    """
+
+    def __init__(self, _session, iohandler, force=False):
+        self.outputlock = threading.RLock()
+        self.keepaliveid = None
+        self.connected = True
+        self.broken = False
+        self.out_handler = iohandler
+        self.remseq = 0
+        self.myseq = 0
+        self.lastsize = 0
+        self.retriedpayload = 0
+        self.pendingoutput = []
+        self.awaitingack = False
+        self.activated = True
+        self.force_session = force
+        self.ipmi_session = _session
+        self.ipmi_session.sol_handler = self._got_sol_payload
+        self.maxoutcount = 256
+        self.poweredon = True
+
+        session.Session.wait_for_rsp(0)
+
+    async def _got_sol_payload(self, payload):
+        """SOL payload callback"""
+
+        # TODO(jbjohnso) test cases to throw some likely scenarios at functions
+        # for example, retry with new data, retry with no new data
+        # retry with unexpected sequence number
+        if type(payload) == dict:  # we received an error condition
+            self.activated = False
+            await self._print_error(payload)
+            return
+        newseq = payload[0] & 0b1111
+        ackseq = payload[1] & 0b1111
+        ackcount = payload[2]
+        nacked = payload[3] & 0b1000000
+        breakdetected = payload[3] & 0b10000
+        # for now, ignore overrun.  I assume partial NACK for this reason or
+        # for no reason would be treated the same, new payload with partial
+        # data.
+        remdata = ""
+        remdatalen = 0
+        flag = 0
+        if not self.poweredon:
+            flag |= 0b1100000
+        if not self.activated:
+            flag |= 0b1010000
+        if newseq != 0:  # this packet at least has some data to send to us..
+            if len(payload) > 4:
+                remdatalen = len(payload[4:])  # store remote len before dupe
+                # retry logic, we must ack *this* many even if it is
+                # a retry packet with new partial data
+                remdata = bytes(payload[4:])
+            if newseq == self.remseq:  # it is a retry, but could have new data
+                if remdatalen > self.lastsize:
+                    remdata = bytes(remdata[4 + self.lastsize:])
+                else:  # no new data...
+                    remdata = ""
+            else:  # TODO(jbjohnso) what if remote sequence number is wrong??
+                self.remseq = newseq
+            self.lastsize = remdatalen
+            ackpayload = bytearray((0, self.remseq, remdatalen, flag))
+            # Why not put pending data into the ack? because it's rare
+            # and might be hard to decide what to do in the context of
+            # retry situation
+            try:
+                self.send_payload(ackpayload, retry=False)
+            except exc.IpmiException:
+                # if the session is broken, then close the SOL session
+                self.close()
+            if remdata:  # Do not subject callers to empty data
+                await self._print_data(remdata)
+        if self.myseq != 0 and ackseq == self.myseq:  # the bmc has something
+            # to say about last xmit
+            self.awaitingack = False
+            if nacked and not breakdetected:  # the BMC was in some way unhappy
+                newtext = self.lastpayload[4 + ackcount:]
+                with self.outputlock:
+                    if (self.pendingoutput
+                            and not isinstance(self.pendingoutput[0], dict)):
+                        self.pendingoutput[0] = newtext + self.pendingoutput[0]
+                    else:
+                        self.pendingoutput = [newtext] + self.pendingoutput
+            # self._sendpendingoutput() checks len(self._sendpendingoutput)
+            self._sendpendingoutput()
+        elif ackseq != 0 and self.awaitingack:
+            # if an ack packet came in, but did not match what we
+            # expected, retry our payload now.
+            # the situation that was triggered was a senseless retry
+            # when data came in while we xmitted.  In theory, a BMC
+            # should handle a retry correctly, but some do not, so
+            # try to mitigate by avoiding overeager retries
+            # occasional retry of a packet
+            # sooner than timeout suggests is evidently a big deal
+            self.send_payload(payload=self.lastpayload)
+
+    def send_payload(self, payload, payload_type=1, retry=True,
+                     needskeepalive=False):
+        while not (self.connected or self.broken):
+            session.Session.wait_for_rsp(timeout=10)
+        self.ipmi_session.send_payload(payload,
+                                       payload_type=payload_type,
+                                       retry=retry,
+                                       needskeepalive=needskeepalive)
+
+    def close(self):
+        """Shut down an SOL session"""
+
+        self.activated = False
diff --git a/confluent_server/aiohmi/ipmi/events.py b/confluent_server/aiohmi/ipmi/events.py
new file mode 100644
index 00000000..c2c4b1ca
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/events.py
@@ -0,0 +1,589 @@
+# Copyright 2016 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import struct
+import time
+
+import aiohmi.constants as pygconst
+import aiohmi.exceptions as pygexc
+
+try:
+    range = xrange
+except NameError:
+    pass
+try:
+    buffer
+except NameError:
+    buffer = memoryview
+
+
+psucfg_errors = {
+    0: 'Vendor mismatch',
+    1: 'Revision mismatch',
+    2: 'Processor missing',  # e.g. pluggable CPU VRMs...
+    3: 'Insufficient power',
+    4: 'Voltage mismatch',
+}
+
+firmware_progress = {
+    0: 'Unspecified',
+    1: 'Memory initialization',
+    2: 'Disk initialization',
+    3: 'Non-primary Processor initialization',
+    4: 'User authentication',
+    5: 'In setup',
+    6: 'USB initialization',
+    7: 'PCI initialization',
+    8: 'Option ROM initialization',
+    9: 'Video initialization',
+    0xa: 'Cache initialization',
+    0xb: 'SMBus initialization',
+    0xc: 'Keyboard initialization',
+    0xd: 'Embedded controller initialization',
+    0xe: 'Docking station attachment',
+    0xf: 'Docking station enabled',
+    0x10: 'Docking station ejection',
+    0x11: 'Docking station disabled',
+    0x12: 'Waking OS',
+    0x13: 'Starting OS boot',
+    0x14: 'Baseboard initialization',
+    0x16: 'Floppy initialization',
+    0x17: 'Keyboard test',
+    0x18: 'Pointing device test',
+    0x19: 'Primary processor initialization',
+}
+
+firmware_errors = {
+    0: 'Unspecified',
+    1: 'No memory installed',
+    2: 'All memory failed',
+    3: 'Unrecoverable disk failure',
+    4: 'Unrecoverable board failure',
+    5: 'Unrecoverable diskette failure',
+    6: 'Unrecoverable storage controller failure',
+    7: 'Unrecoverable keyboard failure',  # Keyboard error, press
+                                          # any key to continue..
+    8: 'Removable boot media not found',
+    9: 'Video adapter failure',
+    0xa: 'No video device',
+    0xb: 'Firmware corruption detected',
+    0xc: 'CPU voltage mismatch',
+    0xd: 'CPU speed mismatch',
+}
+
+auxlog_actions = {
+    0: 'entry added',
+    1: 'entry added (could not map to standard)',
+    2: 'entry added with corresponding standard events',
+    3: 'log cleared',
+    4: 'log disabled',
+    5: 'log enabled',
+}
+
+restart_causes = {
+    0: 'Unknown',
+    1: 'Remote request',
+    2: 'Reset button',
+    3: 'Power button',
+    4: 'Watchdog',
+    5: 'OEM',
+    6: 'Power restored',
+    7: 'Power restored',
+    8: 'Reset due to event',
+    9: 'Cycle due to event',
+    0xa: 'OS reset',
+    0xb: 'Timer wake',
+}
+
+slot_types = {
+    0: 'PCI',
+    1: 'Drive Array',
+    2: 'External connector',
+    3: 'Docking',
+    4: 'Other',
+    5: 'Entity ID',
+    6: 'AdvancedTCA',
+    7: 'Memory',
+    8: 'Fan',
+    9: 'PCIe',
+    10: 'SCSI',
+    11: 'SATA/SAS',
+    12: 'USB',
+}
+
+power_states = {
+    0: 'S0',
+    1: 'S1',
+    2: 'S2',
+    3: 'S3',
+    4: 'S4',
+    5: 'S5',
+    6: 'S4 or S5',
+    7: 'G3',
+    8: 'S1, S2, or S3',
+    9: 'G1',
+    0xa: 'S5',
+    0xb: 'on',
+    0xc: 'off',
+}
+
+watchdog_boot_phases = {
+    1: 'Firmware',
+    2: 'Firmware',
+    3: 'OS Load',
+    4: 'OS',
+    5: 'OEM',
+}
+
+version_changes = {
+    1: 'Device ID',
+    2: 'Management controller firmware',
+    3: 'Management controller revision',
+    4: 'Management conroller manufacturer',
+    5: 'IPMI version',
+    6: 'Management controller firmware',
+    7: 'Management controller boot block',
+    8: 'Management controller firmware',
+    9: 'System Firmware (UEFI/BIOS)',
+    0xa: 'SMBIOS',
+    0xb: 'OS',
+    0xc: 'OS Loader',
+    0xd: 'Diagnostics',
+    0xe: 'Management agent',
+    0xf: 'Management application',
+    0x10: 'Management middleware',
+    0x11: 'FPGA',
+    0x12: 'FRU',
+    0x13: 'FRU',
+    0x14: 'Equivalent FRU',
+    0x15: 'Updated FRU',
+    0x16: 'Older FRU',
+    0x17: 'Hardware (switch/jumper)',
+}
+
+fru_states = {
+    0: 'Normal',
+    1: 'Externally requested',
+    2: 'Latch',
+    3: 'Hot swap',
+    4: 'Internal action',
+    5: 'Lost communication',
+    6: 'Lost communication',
+    7: 'Unexpected removal',
+    8: 'Operator',
+    9: 'Unable to compute IPMB address',
+    0xa: 'Unexpected deactivation',
+}
+
+
+def decode_eventdata(sensor_type, offset, eventdata, event_consts, sdr):
+    """Decode extra event data from an alert or log
+
+    Provide a textual summary of eventdata per descriptions in
+    Table 42-3 of the specification.  This is for sensor specific
+    offset events only.
+
+    :param sensor_type: The sensor type number from the event
+    :param offset:  Sensor specific offset
+    :param eventdata: The three bytes from the log or alert
+    :param event_consts: event definition including severity.
+    :param sdr: The sdr locator entry to help clarify how to parse data
+    """
+    if sensor_type == 5 and offset == 4:  # link loss, indicates which port
+        return 'Port {0}'.format(eventdata[1])
+    elif sensor_type == 8 and offset == 6:  # PSU cfg error
+        errtype = eventdata[2] & 0b1111
+        return psucfg_errors.get(errtype, 'Unknown')
+    elif sensor_type == 0xC6:
+        return 'PSU Redundancy'
+    elif sensor_type == 0xc and offset == 8:  # Memory spare
+        return 'Module {0}'.format(eventdata[2])
+    elif sensor_type == 0xf:
+        if offset == 0:  # firmware error
+            return firmware_errors.get(eventdata[1], 'Unknown')
+        elif offset in (1, 2):
+            return firmware_progress.get(eventdata[1], 'Unknown')
+    elif sensor_type == 0x10:
+        if offset == 0:  # Correctable error logging on a specific memory part
+            return 'Module {0}'.format(eventdata[1])
+        elif offset == 1:
+            return 'Reading type {0:02X}h, offset {1:02X}h'.format(
+                eventdata[1], eventdata[2] & 0b1111)
+        elif offset == 5:
+            return '{0}%'.format(eventdata[2])
+        elif offset == 6:
+            return 'Processor {0}'.format(eventdata[1])
+    elif sensor_type == 0x12:
+        if offset == 3:
+            action = (eventdata[1] & 0b1111000) >> 4
+            return auxlog_actions.get(action, 'Unknown')
+        elif offset == 4:
+            sysactions = []
+            if eventdata[1] & 0b1 << 5:
+                sysactions.append('NMI')
+            if eventdata[1] & 0b1 << 4:
+                sysactions.append('OEM action')
+            if eventdata[1] & 0b1 << 3:
+                sysactions.append('Power Cycle')
+            if eventdata[1] & 0b1 << 2:
+                sysactions.append('Reset')
+            if eventdata[1] & 0b1 << 1:
+                sysactions.append('Power Down')
+            if eventdata[1] & 0b1:
+                sysactions.append('Alert')
+            return ','.join(sysactions)
+        elif offset == 5:  # Clock change event, either before or after
+            if eventdata[1] & 0b10000000:
+                return 'After'
+            else:
+                return 'Before'
+    elif sensor_type == 0x19 and offset == 0:
+        return 'Requested {0} while {1}'.format(eventdata[1], eventdata[2])
+    elif sensor_type == 0x1d and offset == 7:
+        return restart_causes.get(eventdata[1], 'Unknown')
+    elif sensor_type == 0x21:
+        return '{0} {1}'.format(slot_types.get(eventdata[1], 'Unknown'),
+                                eventdata[2])
+
+    elif sensor_type == 0x23:
+        phase = eventdata[1] & 0b1111
+        return watchdog_boot_phases.get(phase, 'Unknown')
+    elif sensor_type == 0x28:
+        if offset == 4:
+            return 'Sensor {0}'.format(eventdata[1])
+        elif offset == 5:
+            islogical = (eventdata[1] & 0b10000000)
+            if islogical:
+                if eventdata[2] in sdr.fru:
+                    return sdr.fru[eventdata[2]].fru_name
+                else:
+                    return 'FRU {0}'.format(eventdata[2])
+    elif sensor_type == 0x2a and offset == 3:
+        return 'User {0}'.format(eventdata[1])
+    elif sensor_type == 0x2b:
+        return version_changes.get(eventdata[1], 'Unknown')
+    elif sensor_type == 0x2c:
+        cause = (eventdata[1] & 0b11110000) >> 4
+        cause = fru_states.get(cause, 'Unknown')
+        oldstate = eventdata[1] & 0b1111
+        if oldstate != offset:
+            try:
+                cause += '(change from {0})'.format(
+                    event_consts.sensor_type_offsets[0x2c][oldstate]['desc'])
+            except KeyError:
+                pass
+
+
+async def _fix_sel_time(records, ipmicmd):
+    timefetched = False
+    rsp = None
+    while not timefetched:
+        try:
+            rsp = await ipmicmd.raw_command(netfn=0xa, command=0x48)
+            timefetched = True
+        except pygexc.IpmiException as pi:
+            if pi.ipmicode == 0x81:
+                continue
+            raise
+    # The specification declares an epoch and all that, but we really don't
+    # care.  We instead just focus on differences from the 'present'
+    nowtime = struct.unpack_from('<I', rsp['data'])[0]
+    correctednowtime = nowtime
+    if nowtime < 0x20000000:
+        correctearly = True
+        inpreinit = True
+    else:
+        correctearly = False
+        inpreinit = False
+    newtimestamp = 0
+    lasttimestamp = None
+    trimindexes = []
+    correctionenabled = True
+    for index in reversed(range(len(records))):
+        record = records[index]
+        if 'timecode' not in record or record['timecode'] == 0xffffffff:
+            continue
+        if ('event' in record and record['event'] == 'Clock time change'
+                and record['event_data'] == 'After'):
+            if (lasttimestamp is not None
+                    and record['timecode'] > lasttimestamp):
+                # if the timestamp did something impossible, declare the rest
+                # of history not meaningfully correctable
+                correctionenabled = False
+                newtimestamp = 0
+                continue
+            newtimestamp = record['timecode']
+            trimindexes.append(index)
+        elif ('event' in record and record['event'] == 'Clock time change'
+              and record['event_data'] == 'Before'):
+            if not correctionenabled:
+                continue
+            if newtimestamp:
+                if record['timecode'] < 0x20000000:
+                    correctearly = True
+                    nowtime = correctednowtime
+                # we want time that occurred before this point to get the delta
+                # added to it to catch up
+                correctednowtime += newtimestamp - record['timecode']
+                newtimestamp = 0
+            trimindexes.append(index)
+        else:
+            # clean up after potentially broken time sync pairs
+            newtimestamp = 0
+            if record['timecode'] < 0x20000000:  # uptime timestamp
+                if not correctearly or not correctionenabled:
+                    correctednowtime = nowtime
+                    continue
+                if (lasttimestamp is not None
+                        and record['timecode'] > lasttimestamp):
+                    # Time has gone backwards in pre-init, no hope for
+                    # accurate time
+                    correctearly = False
+                    correctionenabled = False
+                    correctednowtime = nowtime
+                    continue
+                inpreinit = True
+                lasttimestamp = record['timecode']
+                age = correctednowtime - record['timecode']
+                record['timestamp'] = time.strftime(
+                    '%Y-%m-%dT%H:%M:%S', time.localtime(time.time() - age))
+            else:
+                # We are in 'normal' time, assume we cannot go to
+                # pre-init time and do corrections unless time sync events
+                # guide us in safely
+                if (lasttimestamp is not None
+                        and record['timecode'] > lasttimestamp):
+                    # Time has gone backwards, without a clock sync
+                    # give up any attempt to correct from this point back...
+                    correctionenabled = False
+                if inpreinit:
+                    inpreinit = False
+                    # We were in pre-init, now in real time, reset the
+                    # time correction factor to the last stored
+                    # 'wall clock' correction
+                    correctednowtime = nowtime
+                correctearly = False
+                lasttimestamp = record['timecode']
+                if not correctionenabled or correctednowtime < 0x20000000:
+                    # We can't correct time when the correction factor is
+                    # rooted in a pre-init timestamp, just convert
+                    record['timestamp'] = time.strftime(
+                        '%Y-%m-%dT%H:%M:%S', time.localtime(
+                            record['timecode']))
+                else:
+                    age = correctednowtime - record['timecode']
+                    record['timestamp'] = time.strftime(
+                        '%Y-%m-%dT%H:%M:%S', time.localtime(
+                            time.time() - age))
+    for index in trimindexes:
+        del records[index]
+
+
+class EventHandler(object):
+    """IPMI Event Processor
+
+    This class provides facilities for processing alerts and event log
+    data.  This can be used to aid in pulling historical event data
+    from a BMC or as part of a trap handler to translate the traps into
+    manageable data.
+
+    :param sdr: An SDR object (per aiohmi.ipmi.sdr) matching the target BMC SDR
+    :param ipmicmd: An ipmi command object to fetch data live
+    """
+    @classmethod
+    async def create(cls, sdr, ipmicmd):
+        self = cls()
+        self._sdr = sdr
+        self._ipmicmd = ipmicmd
+        self.event_consts = await ipmicmd.get_event_constants()
+        return self
+
+    def _populate_event(self, deassertion, event, event_data, event_type,
+                        sensor_type, sensorid):
+        event['component_id'] = sensorid
+        try:
+            event['component'] = self._sdr.sensors[sensorid].name
+        except KeyError:
+            if sensorid == 0:
+                event['component'] = None
+            else:
+                event['component'] = 'Sensor {0}'.format(sensorid)
+        event['deassertion'] = deassertion
+        event['event_data_bytes'] = event_data
+        byte2type = (event_data[0] & 0b11000000) >> 6
+        byte3type = (event_data[0] & 0b110000) >> 4
+        if byte2type == 1:
+            event['triggered_value'] = event_data[1]
+        evtoffset = event_data[0] & 0b1111
+        event['event_type_byte'] = event_type
+        if event_type <= 0xc:
+            event['component_type_id'] = sensor_type
+            event['event_id'] = '{0}.{1}'.format(event_type, evtoffset)
+            # use generic offset decode for event description
+            event['component_type'] = self.event_consts.sensor_type_codes.get(
+                sensor_type, '')
+            evreading = self.event_consts.generic_type_offsets.get(
+                event_type, {}).get(evtoffset, {})
+            if event['deassertion']:
+                event['event'] = evreading.get('deassertion_desc', '')
+                event['severity'] = evreading.get(
+                    'deassertion_severity', pygconst.Health.Ok)
+            else:
+                event['event'] = evreading.get('desc', '')
+                event['severity'] = evreading.get(
+                    'severity', pygconst.Health.Ok)
+        elif event_type == 0x6f:
+            event['component_type_id'] = sensor_type
+            event['event_id'] = '{0}.{1}'.format(event_type, evtoffset)
+            event['component_type'] = self.event_consts.sensor_type_codes.get(
+                sensor_type, '')
+            evreading = self.event_consts.sensor_type_offsets.get(
+                sensor_type, {}).get(evtoffset, {})
+            if event['deassertion']:
+                event['event'] = evreading.get('deassertion_desc', '')
+                event['severity'] = evreading.get(
+                    'deassertion_severity', pygconst.Health.Ok)
+            else:
+                event['event'] = evreading.get('desc', '')
+                event['severity'] = evreading.get(
+                    'severity', pygconst.Health.Ok)
+        if event_type == 1:  # threshold
+            if byte3type == 1:
+                event['threshold_value'] = event_data[2]
+        if 3 in (byte2type, byte3type) or event_type == 0x6f:
+            # sensor specific decode, see sdr module...
+            # 2 - 0xc: generic discrete, 0x6f, sensor specific
+            additionaldata = decode_eventdata(
+                sensor_type, evtoffset, event_data, self.event_consts,
+                self._sdr)
+            if additionaldata:
+                event['event_data'] = additionaldata
+
+    async def decode_pet(self, specifictrap, petdata):
+        if isinstance(specifictrap, int):
+            specifictrap = struct.unpack('4B', struct.pack('>I', specifictrap))
+        if len(specifictrap) != 4:
+            raise pygexc.InvalidParameterValue(
+                'specifictrap should be integer number or 4 byte array')
+        specifictrap = bytearray(specifictrap)
+        sensor_type = specifictrap[1]
+        event_type = specifictrap[2]
+        # Event Offset is in first event data byte, so no need to fetch it here
+        # evtoffset = specifictrap[3] & 0b1111
+        deassertion = (specifictrap[3] & 0b10000000) == 0b10000000
+        # alertseverity = petdata[26]
+        sensorid = '{0}.0'.format(petdata[28])
+        event_data = petdata[31:34]
+        event = {}
+        seqnum = struct.unpack_from('>H', buffer(petdata[16:18]))[0]
+        ltimestamp = struct.unpack_from('>I', buffer(petdata[18:22]))[0]
+        petack = bytearray(struct.pack('<HIBBBBBB', seqnum, ltimestamp,
+                                       petdata[25], petdata[27], petdata[28],
+                                       *event_data))
+        try:
+            await self._ipmicmd.raw_command(netfn=4, command=0x17, data=petack)
+        except pygexc.IpmiException:  # Ignore failure to ack for now
+            pass
+        self._populate_event(deassertion, event, event_data, event_type,
+                             sensor_type, sensorid)
+        event['timecode'] = ltimestamp
+        await _fix_sel_time((event,), self._ipmicmd)
+        return event
+
+    def _decode_standard_event(self, eventdata, event):
+        # Ignore the generator id for now..
+        if eventdata[2] not in (3, 4):
+            raise pygexc.PyghmiException(
+                'Unrecognized Event message version {0}'.format(eventdata[2]))
+        sensor_type = eventdata[3]
+        sensorid = '{0}.{1}.{2}'.format(
+            eventdata[0], eventdata[4], eventdata[1] & 0b11)
+        event_data = eventdata[6:]
+        deassertion = (eventdata[5] & 0b10000000 == 0b10000000)
+        event_type = eventdata[5] & 0b1111111
+        self._populate_event(deassertion, event, event_data, event_type,
+                             sensor_type, sensorid)
+
+    async def _sel_decode(self, origselentry):
+        selentry = bytearray(origselentry)
+        event = {}
+        event['record_id'] = struct.unpack_from('<H', origselentry[:2])[0]
+        if selentry[2] == 2 or (0xc0 <= selentry[2] <= 0xdf):
+            # Either standard, or at least the timestamp is standard
+            event['timecode'] = struct.unpack_from('<I', buffer(selentry[3:7])
+                                                   )[0]
+        if selentry[2] == 2:  # ipmi defined standard format
+            self._decode_standard_event(selentry[7:], event)
+        elif 0xc0 <= selentry[2] <= 0xdf:
+            event['oemid'] = selentry[7:10]
+            event['oemdata'] = selentry[10:]
+        elif selentry[2] >= 0xe0:
+            # In this class of OEM message, all bytes are OEM, interpretation
+            # is wholly left up to the OEM layer, using the OEM ID of the BMC
+            event['oemdata'] = selentry[3:]
+        await self._ipmicmd._oem.process_event(event, self._ipmicmd, selentry)
+        if 'event_type_byte' in event:
+            del event['event_type_byte']
+        if 'event_data_bytes' in event:
+            del event['event_data_bytes']
+        return event
+
+    async def _fetch_entries(self, ipmicmd, startat, targetlist, rsvid=0):
+        curr = startat
+        endat = curr
+        while curr != 0xffff:
+            endat = curr
+            reqdata = bytearray(struct.pack('<HHH', rsvid, curr, 0xff00))
+            try:
+                rsp = await ipmicmd.raw_command(
+                    netfn=0xa, command=0x43, data=reqdata)
+            except pygexc.IpmiException as pi:
+                if pi.ipmicode == 203:
+                    break
+                else:
+                    raise
+            curr = struct.unpack_from('<H', buffer(rsp['data'][:2]))[0]
+            targetlist.append(await self._sel_decode(rsp['data'][2:]))
+        return endat
+
+    async def fetch_sel(self, ipmicmd, clear=False):
+        """Fetch SEL entries
+
+        Return an iterable of SEL entries.  If clearing is requested,
+    the fetch and clear will be done as an atomic operation, assuring
+    no entries are dropped.
+
+    :param ipmicmd: The Command object to use to interrogate
+    :param clear: Whether to clear the entries upon retrieval.
+    """
+        records = []
+        # First we do a fetch all without reservation, reducing the risk
+        # of having a long lived reservation that gets canceled in the middle
+        endat = await self._fetch_entries(ipmicmd, 0, records)
+        if clear and records:  # don't bother clearing if there were no records
+            # To do clear, we make a reservation first...
+            rsp = await ipmicmd.raw_command(netfn=0xa, command=0x42)
+            rsvid = struct.unpack_from('<H', rsp['data'])[0]
+            # Then we refetch the tail with reservation (check for change)
+            del records[-1]  # remove the record that's about to be duplicated
+            await self._fetch_entries(ipmicmd, endat, records, rsvid)
+            # finally clear the SEL
+            # 0XAA means start initiate, 0x524c43 is 'RCL' or 'CLR' backwards
+            clrdata = bytearray(struct.pack('<HI', rsvid, 0xAA524C43))
+            await ipmicmd.raw_command(netfn=0xa, command=0x47, data=clrdata)
+        # Now to fixup the record timestamps... first we need to get the BMC
+        # opinion of current time
+        await _fix_sel_time(records, ipmicmd)
+        for rec in records:
+            yield rec
diff --git a/confluent_server/aiohmi/ipmi/fru.py b/confluent_server/aiohmi/ipmi/fru.py
new file mode 100644
index 00000000..50fa90c9
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/fru.py
@@ -0,0 +1,352 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This module provides access to SDR offered by a BMC
+
+This data is common between 'sensors' and 'inventory' modules since SDR
+is both used to enumerate sensors for sensor commands and FRU ids for FRU
+commands
+
+For now, we will not offer persistent SDR caching as we do in xCAT's IPMI
+code.  Will see if it is adequate to advocate for high object reuse in a
+persistent process for the moment.
+
+Focus is at least initially on the aspects that make the most sense for a
+remote client to care about.  For example, smbus information is being
+skipped for now
+
+This file handles parsing of fru format records as presented by IPMI
+devices.  This format is documented in the 'Platform Management FRU
+Information Storage Definition (Document Revision 1.2)
+"""
+
+import struct
+import time
+import weakref
+
+import aiohmi.exceptions as iexc
+import aiohmi.ipmi.private.spd as spd
+
+
+fruepoch = 820454400  # 1/1/1996, 0:00
+
+# This is from SMBIOS specification Table 16
+enclosure_types = {
+    0: 'Unspecified',
+    1: 'Other',
+    2: 'Unknown',
+    3: 'Desktop',
+    4: 'Low Profile Desktop',
+    5: 'Pizza Box',
+    6: 'Mini Tower',
+    7: 'Tower',
+    8: 'Portable',
+    9: 'Laptop',
+    0xa: 'Notebook',
+    0xb: 'Hand Held',
+    0xc: 'Docking Station',
+    0xd: 'All in One',
+    0xe: 'Sub Notebook',
+    0xf: 'Space-saving',
+    0x10: 'Lunch Box',
+    0x11: 'Main Server Chassis',
+    0x12: 'Expansion Chassis',
+    0x13: 'SubChassis',
+    0x14: 'Bus Expansion Chassis',
+    0x15: 'Peripheral Chassis',
+    0x16: 'RAID Chassis',
+    0x17: 'Rack Mount Chassis',
+    0x18: 'Sealed-case PC',
+    0x19: 'Multi-system Chassis',
+    0x1a: 'Compact PCI',
+    0x1b: 'Advanced TCA',
+    0x1c: 'Blade',
+    0x1d: 'Blade Enclosure',
+}
+
+
+def unpack6bitascii(inputdata):
+    # This is a text encoding scheme that seems unique
+    # to IPMI FRU.  It seems to be relatively rare in practice
+    result = ''
+    while len(inputdata) > 0:
+        currchunk = inputdata[:3]
+        del inputdata[:3]
+        currchar = currchunk[0] & 0b111111
+        result += chr(0x20 + currchar)
+        currchar = (currchunk[0] & 0b11000000) >> 6
+        currchar |= (currchunk[1] & 0b1111) << 2
+        result += chr(0x20 + currchar)
+        currchar = (currchunk[1] & 0b11110000) >> 4
+        currchar |= (currchunk[2] & 0b11) << 4
+        result += chr(0x20 + currchar)
+        currchar = (currchunk[2] & 0b11111100) >> 2
+        result += chr(0x20 + currchar)
+    return result
+
+
+def decode_fru_date(datebytes):
+    # Returns ISO
+    datebytes.append(0)
+    minutesfromepoch = struct.unpack('<I', struct.pack('4B', *datebytes))[0]
+    # Some data in the field has had some data less than 800
+    # At this juncture, it's far more likely for this noise
+    # to be incorrect than anything in particular
+    if minutesfromepoch < 800:
+        return None
+    return time.strftime('%Y-%m-%dT%H:%M',
+                         time.gmtime((minutesfromepoch * 60) + fruepoch))
+
+
+class FRU(object):
+    """An object representing structure
+
+    FRU (Field Replaceable Unit) is the usual format for inventory in IPMI
+    devices.  This covers most standards compliant inventory data
+    as well as presenting less well defined fields in a structured way.
+
+    :param rawdata: A binary string/bytearray of raw data from BMC or dump
+    :param ipmicmd: An ipmi command object to fetch data live
+    :param fruid: The identifier number of the FRU
+    :param sdr: The sdr locator entry to help clarify how to parse data
+    """
+
+    def __init__(self, rawdata=None, ipmicmd=None, fruid=0, sdr=None):
+        self.rawfru = rawdata
+        self.databytes = None
+        self.info = None
+        self.sdr = sdr
+        self.ipmicmd = None
+        self.fruid = fruid
+        if self.rawfru is not None:
+            self.parsedata()
+        elif ipmicmd is not None:
+            self.ipmicmd = weakref.proxy(ipmicmd)
+        else:
+            raise TypeError('Either rawdata or ipmicmd must be specified')
+        
+    async def initialize(self):
+        if self.ipmicmd is not None:
+            try:
+                await self.fetch_fru(self.fruid)
+            except iexc.IpmiException as ie:
+                if ie.ipmicode in (195, 201, 203, 129):
+                    return
+                raise
+            self.parsedata()
+
+
+    async def fetch_fru(self, fruid):
+        response = await self.ipmicmd.raw_command(
+            netfn=0xa, command=0x10, data=[fruid])
+        if 'error' in response:
+            raise iexc.IpmiException(response['error'], code=response['code'])
+        frusize = response['data'][0] | (response['data'][1] << 8)
+        # In our case, we don't need to think too hard about whether
+        # the FRU is word or byte, we just process what we get back in the
+        # payload
+        chunksize = 224
+        # Selected as it is accomodated by most tested things
+        # and many tested things broke after going much
+        # bigger
+        if chunksize > frusize:
+            chunksize = frusize
+        offset = 0
+        self.rawfru = bytearray([])
+        while chunksize:
+            response = await self.ipmicmd.raw_command(
+                netfn=0xa, command=0x11, data=[fruid, offset & 0xff,
+                                               offset >> 8, chunksize])
+            if response['code'] in (201, 202):
+                # if it was too big, back off and try smaller
+                # Try just over half to mitigate the chance of
+                # one request becoming three rather than just two
+                if chunksize == 3:
+                    raise iexc.IpmiException(response['error'])
+                chunksize //= 2
+                chunksize += 2
+                continue
+            elif 'error' in response:
+                raise iexc.IpmiException(response['error'], response['code'])
+            offset += response['data'][0]
+            if response['data'][0] == 0:
+                break
+            # move down to avoid exception when data[0] is zero
+            self.rawfru.extend(response['data'][1:])
+            if offset + chunksize > frusize:
+                chunksize = frusize - offset
+
+    def parsedata(self):
+        self.info = {}
+        rawdata = self.rawfru
+        self.databytes = bytearray(rawdata)
+        if self.sdr is not None:
+            frutype = self.sdr.fru_type_and_modifier >> 8
+            frusubtype = self.sdr.fru_type_and_modifier & 0xff
+            if frutype > 0x10 or frutype < 0x8 or frusubtype not in (0, 1, 2):
+                return
+                # TODO(jjohnson2): strict mode to detect aiohmi and BMC
+                # gaps
+                # raise iexc.PyghmiException(
+                #     'Unsupported FRU device: {0:x}h, {1:x}h'.format(frutype,
+                #                                                    frusubtype
+                #                                                    ))
+            elif frusubtype == 1:
+                self.myspd = spd.SPD(self.databytes)
+                self.info = self.myspd.info
+                return
+        if self.databytes[0] != 1:
+            return
+            # TODO(jjohnson2): strict mode to flag potential BMC errors
+            # raise iexc.BmcErrorException("Invalid/Unsupported FRU format")
+        # Ignore the internal use even if present.
+        self._parse_chassis()
+        self._parse_board()
+        self._parse_prod()
+        # TODO(jjohnson2): Multi Record area
+
+    def _decode_tlv(self, offset, lang=0):
+        currtlv = self.databytes[offset]
+        currlen = currtlv & 0b111111
+        currtype = (currtlv & 0b11000000) >> 6
+        retinfo = self.databytes[offset + 1:offset + currlen + 1]
+        newoffset = offset + currlen + 1
+        if currlen == 0:
+            return None, newoffset
+        if currtype == 0:
+            # return it as a bytearray, not much to be done for it
+            return retinfo, newoffset
+        elif currtype == 3:  # text string
+            # Sometimes BMCs have FRU data with 0xff termination
+            # contrary to spec, but can be tolerated
+            # also in case something null terminates, handle that too
+            # strictly speaking, \xff should be a y with diaeresis, but
+            # erring on the side of that not being very relevant in practice
+            # to fru info, particularly the last values
+            # Additionally 0xfe has been observed, which should be a thorn, but
+            # again assuming termination of string is more likely than thorn.
+            retinfo = retinfo.rstrip(b'\xfe\xff\x10\x03\x00 ')
+            retinfo = retinfo.replace(b'\x00', b'')
+            if lang in (0, 25):
+                try:
+                    retinfo = retinfo.decode('iso-8859-1')
+                except (UnicodeError, LookupError):
+                    pass
+            else:
+                try:
+                    retinfo = retinfo.decode('utf-16le')
+                except (UnicodeDecodeError, LookupError):
+                    pass
+            # Some things lie about being text.  Do the best we can by
+            # removing trailing spaces and nulls like makes sense for text
+            # and rely on vendors to workaround deviations in their OEM
+            # module
+            # retinfo = retinfo.rstrip(b'\x00 ')
+            return retinfo, newoffset
+        elif currtype == 1:  # BCD 'plus'
+            retdata = ''
+            for byte in retinfo:
+                byte = hex(byte).replace('0x', '').replace('a', ' ').replace(
+                    'b', '-').replace('c', '.')
+                retdata += byte
+            retdata = retdata.strip()
+            return retdata, newoffset
+        elif currtype == 2:  # 6-bit ascii
+            retinfo = unpack6bitascii(retinfo).strip()
+            return retinfo, newoffset
+
+    def _parse_chassis(self):
+        offset = 8 * self.databytes[2]
+        if offset == 0:
+            return
+        if self.databytes[offset] & 0b1111 != 1:
+            raise iexc.BmcErrorException("Invalid/Unsupported chassis area")
+        inf = self.info
+        # ignore length field, just process the data
+        # add check to avoid exception
+        if self.databytes[offset + 2] in enclosure_types.keys():
+            inf['Chassis type'] = enclosure_types[self.databytes[offset + 2]]
+        inf['Chassis part number'], offset = self._decode_tlv(offset + 3)
+        inf['Chassis serial number'], offset = self._decode_tlv(offset)
+        inf['chassis_extra'] = []
+        self.extract_extra(inf['chassis_extra'], offset)
+
+    def extract_extra(self, target, offset, language=0):
+        try:
+            while self.databytes[offset] != 0xc1:
+                fielddata, offset = self._decode_tlv(offset, language)
+                target.append(fielddata)
+        except IndexError:
+            # If we overrun the end due to malformed FRU,
+            # return at least what decoded right
+            return
+
+    def _parse_board(self):
+        offset = 8 * self.databytes[3]
+        if offset == 0:
+            return
+        if self.databytes[offset] & 0b1111 != 1:
+            raise iexc.BmcErrorException("Invalid/Unsupported board info area")
+        inf = self.info
+        language = self.databytes[offset + 2]
+        inf['Board manufacture date'] = decode_fru_date(
+            self.databytes[offset + 3:offset + 6])
+        inf['Board manufacturer'], offset = self._decode_tlv(offset + 6)
+        inf['Board product name'], offset = self._decode_tlv(offset, language)
+        inf['Board serial number'], offset = self._decode_tlv(offset, language)
+        inf['Board model'], offset = self._decode_tlv(offset, language)
+        inf['Board FRU Id'], offset = self._decode_tlv(offset, language)
+        inf['board_extra'] = []
+        self.extract_extra(inf['board_extra'], offset, language)
+
+    def _parse_prod(self):
+        offset = 8 * self.databytes[4]
+        if offset == 0:
+            return
+        inf = self.info
+        language = self.databytes[offset + 2]
+        inf['Manufacturer'], offset = self._decode_tlv(offset + 3,
+                                                       language)
+        inf['Product name'], offset = self._decode_tlv(offset, language)
+        inf['Model'], offset = self._decode_tlv(offset, language)
+        inf['Hardware Version'], offset = self._decode_tlv(offset, language)
+        inf['Serial Number'], offset = self._decode_tlv(offset, language)
+        inf['Asset Number'], offset = self._decode_tlv(offset, language)
+        inf['FRU ID'], offset = self._decode_tlv(offset, language)
+        inf['product_extra'] = []
+        self.extract_extra(inf['product_extra'], offset, language)
+
+    def __repr__(self):
+        return repr(self.info)
+        # retdata = 'Chassis data\n'
+        # retdata += '   Type: ' + repr(self.chassis_type) + '\n'
+        # retdata += '   Part Number: ' + repr(self.chassis_part_number) + '\n'
+        # retdata += '   Serial Number: ' + repr(self.chassis_serial) + '\n'
+        # retdata += '   Extra: ' + repr(self.chassis_extra) + '\n'
+        # retdata += 'Board data\n'
+        # retdata += '  Manufacturer: ' + repr(self.board_manufacturer) + '\n'
+        # retdata += '   Date: ' + repr(self.board_mfg_date) + '\n'
+        # retdata += '   Product' + repr(self.board_product) + '\n'
+        # retdata += '   Serial: ' + repr(self.board_serial) + '\n'
+        # retdata += '   Model: ' + repr(self.board_model) + '\n'
+        # retdata += '   Extra: ' + repr(self.board_extra) + '\n'
+        # retdata += 'Product data\n'
+        # retdata += '  Manufacturer: ' + repr(self.product_manufacturer)+'\n'
+        # retdata += '  Name: ' + repr(self.product_name) + '\n'
+        # retdata += '  Model: ' + repr(self.product_model) + '\n'
+        # retdata += '  Version: ' + repr(self.product_version) + '\n'
+        # retdata += '  Serial: ' + repr(self.product_serial) + '\n'
+        # retdata += '  Asset: ' + repr(self.product_asset) + '\n'
+        # retdata += '  Extra: ' + repr(self.product_extra) + '\n'
+        # return retdata
diff --git a/confluent_server/aiohmi/ipmi/oem/__init__.py b/confluent_server/aiohmi/ipmi/oem/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/ipmi/oem/generic.py b/confluent_server/aiohmi/ipmi/oem/generic.py
new file mode 100644
index 00000000..34ca2b79
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/generic.py
@@ -0,0 +1,550 @@
+# Copyright 2015 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.exceptions as exc
+import aiohmi.ipmi.private.constants as event_const
+import aiohmi.ipmi.sdr as ipmisdr
+import struct
+
+class OEMHandler(object):
+    """Handler class for OEM capabilities.
+
+    Any vendor wishing to implement OEM extensions should look at this
+    base class for an appropriate interface.  If one does not exist, this
+    base class should be extended.  At initialization an OEM is given
+    a dictionary with product_id, device_id, manufacturer_id, and
+    device_revision as keys in a dictionary, along with an ipmi Command object
+    """
+
+    @classmethod
+    async def create(cls, oemid, ipmicmd):
+        self = cls()
+        return self
+
+    async def get_video_launchdata(self):
+        return {}
+
+    async def get_description(self):
+        """Get a description of descriptive attributes of a node.
+
+        Height describes, in U how tall the system is, and slot is 0 if
+        not a blade type server, and slot if it is.
+
+        :return: dictionary with 'height' and 'slot' members
+        """
+        return {}
+    
+    async def get_screenshot(self, outfile):
+        return {}    
+
+    async def get_system_power_watts(self, ipmicmd):
+        # Use DCMI getpower reading command
+        rsp = await ipmicmd.raw_command(netfn=0x2c, command=2, data=(0xdc, 1, 0, 0))
+        wattage = struct.unpack('<H', rsp['data'][1:3])[0]
+        return wattage   
+
+    async def get_ikvm_methods(self):
+        return []
+
+    async def get_ikvm_launchdata(self):
+        # no standard ikvm behavior, must be oem defined
+        return {}
+
+    async def get_average_processor_temperature(self, ipmicmd):
+        # DCMI suggests preferrence for 0x37 ('Air inlet')
+        # If not that, then 0x40 ('Air inlet')
+        # in practice, some implementations use 0x27 ('External environment')
+        if not hasattr(self, '_processor_names'):
+            self._processor_names = []
+        readings = []
+        if not self._processor_names:
+            sdr = await ipmicmd.init_sdr()
+            for sensename in sdr.sensors:
+                sensor = sdr.sensors[sensename]
+                if sensor.reading_type != 1:
+                    continue
+                if not sensor.baseunit:
+                    continue
+                if sensor.sensor_type != 'Temperature':
+                    continue
+                if sensor.entity == 'Processor':
+                    self._processor_names.append(sensor.sensor_name)
+        readingvalues = []
+        for procsensor in self._processor_names:
+            try:
+                reading = await ipmicmd.get_sensor_reading(procsensor)
+            except exc.IpmiException:
+                continue
+            if reading.value is not None:
+                readingvalues.append(float(reading.value))
+        tmplreading = ipmisdr.SensorReading({'name': 'Average Processor Temperature', 'type': 'Temperature'}, '°C')
+        if readingvalues:
+            tmplreading.value = sum(readingvalues) / len(readingvalues)
+        else:
+            tmplreading.value = None
+            tmplreading.unavailable = 1
+        return tmplreading
+
+
+    async def get_inlet_temperature(self, ipmicmd):
+        # DCMI suggests preferrence for 0x37 ('Air inlet')
+        # If not that, then 0x40 ('Air inlet')
+        # in practice, some implementations use 0x27 ('External environment')
+        if not hasattr(self, '_inlet_name'):
+            self._inlet_name = None
+        if self._inlet_name:
+            return await ipmicmd.get_sensor_reading(self._inlet_name)
+        sdr = await ipmicmd.init_sdr()
+        extenv = []
+        airinlets = []
+        for sensename in sdr.sensors:
+            sensor = sdr.sensors[sensename]
+            if sensor.reading_type != 1:
+                continue
+            if not sensor.baseunit:
+                continue
+            if sensor.sensor_type != 'Temperature':
+                continue
+            if sensor.entity == 'External environment':
+                if 'exhaust' in sensor.sensor_name.lower():
+                    continue
+                extenv.append(sensor.sensor_name)
+            if sensor.entity == 'Air inlet':
+                airinlets.append(sensor.sensor_name)
+        if airinlets:
+            if len(airinlets) > 1:
+                raise Exception('TODO: how to deal with multiple inlets')
+            self._inlet_name = airinlets[0]
+        elif extenv:
+            if len(extenv) > 1:
+                raise Exception('TODO: how to deal with multiple external environments')
+            self._inlet_name = extenv[0]
+        if not self._inlet_name:
+            raise exc.UnsupportedFunctionality(
+                'Unable to detect inlet sensor name for this platform')
+        return await ipmicmd.get_sensor_reading(self._inlet_name)
+
+    async def process_event(self, event, ipmicmd, seldata):
+        """Modify an event according with OEM understanding.
+
+        Given an event, allow an OEM module to augment it.  For example,
+        event data fields can have OEM bytes.  Other times an OEM may wish
+        to apply some transform to some field to suit their conventions.
+        """
+        event['oem_handler'] = None
+        evdata = event['event_data_bytes']
+        if evdata[0] & 0b11000000 == 0b10000000:
+            event['oem_byte2'] = evdata[1]
+        if evdata[0] & 0b110000 == 0b100000:
+            event['oem_byte3'] = evdata[2]
+
+    async def clear_system_configuration(self):
+        raise exc.UnsupportedFunctionality(
+            'Clearing system configuration not implemented for this platform')
+
+    async def clear_bmc_configuration(self):
+        raise exc.UnsupportedFunctionality(
+            'Clearing BMC configuration not implemented for this platform')
+
+    async def get_oem_inventory_descriptions(self):
+        """Get descriptions of available additional inventory items
+
+        OEM implementation may provide additional records not indicated
+        by FRU locator SDR records.  An implementation is expected to
+        implement this function to list component names that would map to
+        OEM behavior beyond the specification.  It should return an iterable
+        of names
+        """
+        if False:
+            yield None
+
+    async def get_sensor_reading(self, sensorname):
+        """Get an OEM sensor
+
+        If software wants to model some OEM behavior as a 'sensor' without
+        doing SDR, this hook provides that ability.  It should mimic
+        the behavior of 'get_sensor_reading' in command.py.
+        """
+        raise Exception('Sensor not found: ' + sensorname)
+
+    async def get_sensor_descriptions(self):
+        """Get list of OEM sensor names and types
+
+        Iterate over dicts describing a label and type for OEM 'sensors'.  This
+        should mimic the behavior of the get_sensor_descriptions function
+        in command.py.
+        """
+        if False:
+            yield None
+
+    async def get_diagnostic_data(self, savefile, progress=None):
+        """Download diagnostic data about target to a file
+
+        This should be a payload that the vendor's support team can use
+        to do diagnostics.
+        :param savefile: File object or filename to save to
+        :param progress: Callback to be informed about progress
+        :return:
+        """
+        raise exc.UnsupportedFunctionality(
+            'Do not know how to get diagnostic data for this platform')
+
+    async def get_sensor_data(self):
+        """Get OEM sensor data
+
+        Iterate through all OEM 'sensors' and return data as if they were
+        normal sensors.  This should mimic the behavior of the get_sensor_data
+        function in command.py.
+        """
+        if False:
+            yield None
+
+    async def get_oem_inventory(self):
+        """Get tuples of component names and inventory data.
+
+        This returns an iterable of tuples.  The first member of each tuple
+        is a string description of the inventory item.  The second member
+        is a dict of inventory information about the component.
+        """
+        async for desc in self.get_oem_inventory_descriptions():
+            yield (desc, await self.get_inventory_of_component(desc))
+
+    async def get_inventory_of_component(self, component):
+        """Get inventory detail of an OEM defined component
+
+        Given a string that may be an OEM component, return the detail of that
+        component.  If the component does not exist, returns None
+        """
+        return None
+
+    async def get_leds(self):
+        """Get tuples of LED categories.
+
+        Each category contains a category name and a dicionary of LED names
+        with their status as values.
+        """
+        if False:
+            yield None
+
+    async def get_ntp_enabled(self):
+        """Get whether ntp is enabled or not
+
+        :returns: True if enabled, False if disabled, None if unsupported
+        """
+        return None
+
+    async def set_ntp_enabled(self, enabled):
+        """Set whether NTP should be enabled
+
+        :returns: True on success
+        """
+        return None
+
+    async def get_ntp_servers(self):
+        """Get current set of configured NTP servers
+
+        :returns iterable of configured NTP servers:
+        """
+        return ()
+
+    async def set_ntp_server(self, server, index=0):
+        """Set an ntp server
+
+        :param server:  Destination address of server to reach
+        :param index: Index of server to configure, primary assumed if not
+        specified
+        :returns: True if success
+        """
+        return None
+
+    async def process_fru(self, fru, name=None):
+        """Modify a fru entry with OEM understanding.
+
+        Given a fru, clarify 'extra' fields according to OEM rules and
+        return the transformed data structure.  If OEM processes, it is
+        expected that it sets 'oem_parser' to the name of the module.  For
+        clients passing through data, it is suggested to pass through
+        board/product/chassis_extra_data arrays if 'oem_parser' is None,
+        and mask those fields if not None.  It is expected that OEMs leave
+        the fields intact so that if client code hard codes around the
+        ordered lists that their expectations are not broken by an update.
+        """
+        # In the generic case, just pass through
+        if fru is None:
+            return fru
+        fru['oem_parser'] = None
+        return fru
+
+    async def get_oem_firmware(self, bmcver, components, category):
+        """Get Firmware information."""
+
+        # Here the bmc version is passed into the OEM handler, to allow
+        # the handler to enrich the data. For the generic case, just
+        # provide the generic BMC version, which is all that is possible
+        # Additionally, components may be provided for an advisory guide
+        # on interesting firmware.  The OEM library is permitted to return
+        # more than requested, and it is the responsibility of the calling
+        # code to know whether it cares or not.  The main purpose of the
+        # components argument is to indicate when certain performance
+        # optimizations can be performed.
+        yield 'BMC Version', {'version': bmcver}
+
+    async def get_oem_capping_enabled(self):
+        """Get PSU based power capping status
+
+        :return: True if enabled and False if disabled
+        """
+        return ()
+
+    async def set_oem_capping_enabled(self, enable):
+        """Set PSU based power capping
+
+        :param enable: True for enable and False for disable
+        """
+        return ()
+
+    async def get_oem_remote_kvm_available(self):
+        """Get remote KVM availability"""
+        return False
+
+    async def get_oem_domain_name(self):
+        """Get Domain name"""
+        return ()
+
+    async def set_oem_domain_name(self, name):
+        """Set Domain name
+
+        :param name: domain name to be set
+        """
+        return ()
+
+    async def clear_storage_arrays(self):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    async def remove_storage_configuration(self, cfgspec):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    async def apply_storage_configuration(self, cfgspec):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    async def check_storage_configuration(self, cfgspec):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    async def get_storage_configuration(self):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    async def get_update_status(self):
+        raise exc.UnsupportedFunctionality(
+            'Firmware update not supported on this platform')
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        raise exc.UnsupportedFunctionality(
+            'Firmware update not supported on this platform')
+
+    async def reseat_bay(self, bay):
+        raise exc.UnsupportedFunctionality(
+            'Reseat not supported on this platform')
+
+    async def get_graphical_console(self):
+        """Get graphical console launcher"""
+        return ()
+
+    async def add_extra_net_configuration(self, netdata, channel=None):
+        """Add additional network configuration data
+
+        Given a standard netdata struct, add details as relevant from
+        OEM commands, modifying the passed dictionary
+        :param netdata: Dictionary to store additional network data
+        """
+        return
+
+    async def get_oem_identifier(self):
+        """Get host name
+
+        """
+        return None
+
+    async def set_oem_identifier(self, name):
+        """Set host name
+
+        :param name: host name to be set
+        """
+        return False
+
+    async def detach_remote_media(self):
+        raise exc.UnsupportedFunctionality()
+
+    async def attach_remote_media(self, imagename, username, password):
+        raise exc.UnsupportedFunctionality()
+
+    async def upload_media(self, filename, progress, data):
+        raise exc.UnsupportedFunctionality(
+            'Remote media upload not supported on this system')
+
+    async def list_media(self):
+        if False:
+            yield None
+        raise exc.UnsupportedFunctionality()
+
+    async def set_identify(self, on, duration, blink):
+        """Provide an OEM override for set_identify
+
+        Some systems may require an override for set identify.
+
+        """
+        raise exc.UnsupportedFunctionality()
+
+    async def get_health(self, summary):
+        """Provide an alternative or augmented health assessment
+
+        An OEM handler can preprocess the summary and extend it with OEM
+        specific data, and then return to let generic processing occur.
+        It can also raise the aiohmi exception BypassGenericBehavior to
+        suppress the standards based routine, for enhanced performance.
+
+        :param summary: The health summary as prepared by the generic function
+        :return: Nothing, modifies the summary object
+        """
+        return []
+
+    async def set_hostname(self, hostname):
+        """OEM specific hook to specify name information"""
+        raise exc.UnsupportedFunctionality()
+
+    async def get_hostname(self):
+        """OEM specific hook to specify name information"""
+        raise exc.UnsupportedFunctionality()
+
+    async def set_user_access(self, uid, channel, callback, link_auth, ipmi_msg,
+                        privilege_level):
+        if privilege_level.startswith('custom.'):
+            raise exc.UnsupportedFunctionality()
+        return  # Nothing to do
+
+    async def set_alert_ipv6_destination(self, ip, destination, channel):
+        """Set an IPv6 alert destination
+
+        If and only if an implementation does not support standard
+        IPv6 but has an OEM implementation, override this to process
+        the data.
+
+        :param ip: IPv6 address to set
+        :param destination: Destination number
+        :param channel: Channel number to apply
+
+        :returns True if standard parameter set should be suppressed
+        """
+        return False
+
+    async def get_extended_bmc_configuration(self):
+        """Get extended bmc configuration
+
+        In the case of potentially redundant/slow
+        attributes, retrieve unpopular options that may be
+        redundant or confusing and slow.
+        """
+        return {}
+
+    async def get_bmc_configuration(self):
+        """Get additional BMC parameters
+
+        This allows a bmc to return arbitrary key-value pairs.
+        """
+        return {}
+
+    async def set_bmc_configuration(self, changeset):
+        raise exc.UnsupportedFunctionality(
+            'Platform does not support setting bmc attributes')
+
+    async def get_system_configuration(self, hideadvanced):
+        """Retrieve system configuration
+
+        This returns a dictionary of settings names to dictionaries including
+        'current', 'default' and 'possible' values as well as 'help'
+
+        :param hideadvanced: Whether to hide 'advanced' settings that most
+                             users should not need.  Defaults to True.
+        """
+        return {}
+
+    async def set_system_configuration(self, changeset):
+        """Apply a changeset to system configuration
+
+        Takes a key value pair and applies it against the system configuration
+        """
+        raise exc.UnsupportedFunctionality()
+
+    async def get_licenses(self):
+        raise exc.UnsupportedFunctionality()
+        yield None
+
+    async def delete_license(self, name):
+        raise exc.UnsupportedFunctionality()
+
+    async def save_licenses(self, directory):
+        raise exc.UnsupportedFunctionality()
+        yield None
+
+    async def apply_license(self, filename, progress=None, data=None):
+        raise exc.UnsupportedFunctionality()
+        yield None
+
+    async def get_user_expiration(self, uid):
+        return None
+    
+    async def get_user_privilege_level(self, uid):
+        return None
+
+    async def set_oem_extended_privilleges(self, uid):
+        """Set user extended privillege as 'KVM & VMedia Allowed'
+
+        |KVM & VMedia Not Allowed	0x00 0x00 0x00 0x00
+        |KVM Only Allowed	0x01 0x00 0x00 0x00
+        |VMedia Only Allowed	0x02  0x00 0x00 0x00
+        |KVM & VMedia Allowed	0x03 0x00 0x00 0x00
+
+        :param uid: User ID.
+        """
+        return False
+
+    async def process_zero_fru(self, zerofru):
+        return await self.process_fru(zerofru)
+
+    async def is_valid(self, name):
+        return name is not None
+
+    async def process_password(self, password, data):
+        return data
+
+    async def set_server_capping(self, value):
+        """Set power capping for server
+
+        :param value: power capping value to set.
+        """
+        pass
+
+    async def get_server_capping(self):
+        """Get power capping for server
+
+        :return: power capping value.
+        """
+        return None
+
+    async def get_oem_event_const(self):
+        return event_const
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/__init__.py b/confluent_server/aiohmi/ipmi/oem/lenovo/__init__.py
new file mode 100755
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/config.py b/confluent_server/aiohmi/ipmi/oem/lenovo/config.py
new file mode 100644
index 00000000..1e5a54a9
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/config.py
@@ -0,0 +1,637 @@
+# Copyright 2017-2019 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""from Matthew Garret's 'firmware_config' project.
+
+This contains functions to manage the firmware configuration of Lenovo servers
+"""
+
+import ast
+import asyncio
+import base64
+import random
+import struct
+
+import time
+
+import aiohmi.exceptions as pygexc
+
+try:
+    import EfiCompressor
+    from lxml import etree
+except ImportError:
+    etree = None
+    EfiCompressor = None
+
+IMM_NETFN = 0x2e
+IMM_COMMAND = 0x90
+LENOVO_ENTERPRISE = [0x4d, 0x4f, 0x00]
+
+OPEN_RO_COMMAND = [0x01, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40]
+OPEN_WO_COMMAND = [0x01, 0x03, 0x01]
+READ_COMMAND = [0x02]
+WRITE_COMMAND = [0x03]
+CLOSE_COMMAND = [0x05]
+SIZE_COMMAND = [0x06]
+
+class Unsupported(Exception):
+    pass
+
+def fromstring(inputdata):
+    if b'!entity' in inputdata.lower():
+        raise Exception('Unsupported XML')
+    try:
+        return etree.fromstring(inputdata)
+    except etree.XMLSyntaxError:
+        inputdata = bytearray(inputdata.decode('utf8', errors='backslashreplace').encode())
+        for i in range(len(inputdata)):
+            if inputdata[i] < 0x20 and inputdata[i] not in (9, 0xa, 0xd):
+                inputdata[i] = 63
+        inputdata = bytes(inputdata)
+        return etree.fromstring(inputdata)
+
+
+
+async def run_command_with_retry(connection, data):
+    tries = 240
+    while tries:
+        tries -= 1
+        try:
+            return await connection.raw_command(
+                netfn=IMM_NETFN, command=IMM_COMMAND, data=data)
+        except pygexc.IpmiException as e:
+            if e.ipmicode != 0xa or not tries:
+                raise
+            connection.ipmi_session.pause(1)
+
+
+def _convert_syntax(raw):
+    return raw.replace('!', 'not').replace('||', 'or').replace(
+        '&&', 'and').replace('-', '_')
+
+
+class _ExpEngine(object):
+    def __init__(self, cfg, setting):
+        self.cfg = cfg
+        self.setting = setting
+        self.relatedsettings = set([])
+
+    def lookup(self, category, setting):
+        for optkey in self.cfg:
+            opt = self.cfg[optkey]
+            lid = opt['lenovo_id'].replace('-', '_')
+            if (lid == category
+                    and opt['lenovo_setting'] == setting):
+                self.relatedsettings.add(optkey)
+                return opt['lenovo_value']
+        return None
+
+    def process(self, parsed):
+        if isinstance(parsed, ast.UnaryOp) and isinstance(parsed.op, ast.Not):
+            return not self.process(parsed.operand)
+        if isinstance(parsed, ast.Compare):
+            if isinstance(parsed.ops[0], ast.NotEq):
+                return self.process(parsed.left) != self.process(
+                    parsed.comparators[0])
+            elif isinstance(parsed.ops[0], ast.Eq):
+                return self.process(parsed.left) == self.process(
+                    parsed.comparators[0])
+        if isinstance(parsed, ast.Num):
+            return parsed.n
+        if isinstance(parsed, ast.Attribute):
+            category = parsed.value.id
+            setting = parsed.attr
+            return self.lookup(category, setting)
+        if isinstance(parsed, ast.Name):
+            if parsed.id == 'true':
+                return True
+            elif parsed.id == 'false':
+                return False
+            else:
+                category = self.setting['lenovo_id']
+                setting = parsed.id
+                return self.lookup(category, setting)
+        if isinstance(parsed, ast.BoolOp):
+            if isinstance(parsed.op, ast.Or):
+                return self.process(parsed.values[0]) or self.process(
+                    parsed.values[1])
+            elif isinstance(parsed.op, ast.And):
+                return self.process(parsed.values[0]) and self.process(
+                    parsed.values[1])
+
+
+def _eval_conditional(expression, cfg, setting):
+    if not expression:
+        return False, ()
+    try:
+        parsed = ast.parse(expression)
+        parsed = parsed.body[0].value
+        evaluator = _ExpEngine(cfg, setting)
+        result = evaluator.process(parsed)
+        return result, evaluator.relatedsettings
+    except SyntaxError:
+        return False, ()
+
+
+class LenovoFirmwareConfig(object):
+    def __init__(self, xc, useipmi=True):
+        if not etree:
+            raise Exception("python-lxml and python-eficompressor required "
+                            "for this function")
+        if useipmi:
+            self.connection = xc.ipmicmd
+        else:
+            self.connection = None
+        self.xc = xc
+
+    async def imm_size(self, filename):
+        data = bytearray()
+        data.extend(LENOVO_ENTERPRISE)
+        data.extend(SIZE_COMMAND)
+        if not isinstance(filename, bytes):
+            filename = filename.encode('utf-8')
+        data.extend(filename)
+
+        response = await run_command_with_retry(self.connection, data=data)
+
+        size = response['data'][3:7]
+
+        size = struct.unpack("i", size)
+        return size[0]
+
+    async def imm_open(self, filename, write=False, size=None):
+        response = None
+        retries = 12
+        data = bytearray()
+        data.extend(LENOVO_ENTERPRISE)
+        if write is False:
+            data.extend(OPEN_RO_COMMAND)
+        else:
+            assert size is not None
+            data.extend(OPEN_WO_COMMAND)
+            hex_size = struct.pack("<I", size)
+            data.extend(bytearray(hex_size[:4]))
+            data.extend([0x01, 0x40])
+        if not isinstance(filename, bytes):
+            filename = filename.encode('utf-8')
+        data.extend(filename)
+        while len(data) < 38:
+            data.append(0)
+
+        while retries:
+            retries = retries - 1
+            response = await run_command_with_retry(self.connection, data=data)
+            try:
+                if response['code'] == 0 or retries == 0:
+                    break
+            except KeyError:
+                pass
+            self.connection.ipmi_session.pause(5)
+        filehandle = response['data'][3:7]
+        filehandle = struct.unpack("<I", filehandle)[0]
+        return filehandle
+
+    async def imm_close(self, filehandle):
+        data = []
+        data += LENOVO_ENTERPRISE
+        data += CLOSE_COMMAND
+
+        hex_filehandle = struct.pack("<I", filehandle)
+        data.extend(bytearray(hex_filehandle[:4]))
+        try:
+            await run_command_with_retry(self.connection, data=data)
+        except pygexc.IpmiException as e:
+            if e.ipmicode != 203:
+                raise
+
+    async def imm_write(self, filehandle, size, inputdata):
+        blocksize = 0xc8
+        offset = 0
+        remaining = size
+
+        hex_filehandle = struct.pack("<I", filehandle)
+
+        while remaining > 0:
+            data = bytearray()
+            data.extend(LENOVO_ENTERPRISE)
+            data.extend(WRITE_COMMAND)
+            data.extend(hex_filehandle[:4])
+            hex_offset = struct.pack("<I", offset)
+            data.extend(hex_offset[:4])
+            if remaining < blocksize:
+                amount = remaining
+            else:
+                amount = blocksize
+            data.extend(inputdata[offset:offset + amount])
+            remaining -= blocksize
+            offset += blocksize
+            await run_command_with_retry(self.connection, data=data)
+            await self.connection.ipmi_session.pause(0)
+
+    async def imm_read(self, filehandle, size):
+        blocksize = 0xc8
+        offset = 0
+        output = b''
+        remaining = size
+
+        hex_filehandle = struct.pack("<I", filehandle)
+        hex_blocksize = struct.pack("<H", blocksize)
+
+        while remaining > 0:
+            data = []
+            data += LENOVO_ENTERPRISE
+            data += READ_COMMAND
+            data.extend(bytearray(hex_filehandle[:4]))
+            hex_offset = struct.pack("<I", offset)
+            data.extend(bytearray(hex_offset[:4]))
+            if remaining < blocksize:
+                hex_blocksize = struct.pack("<H", remaining)
+            data.extend(hex_blocksize[:2])
+            remaining -= blocksize
+            offset += blocksize
+            response = await run_command_with_retry(self.connection, data=data)
+            output += response['data'][5:]
+            await self.connection.ipmi_session.pause(0)
+        return output
+
+    async def factory_reset(self):
+        options = await self.get_fw_options()
+        for option in options:
+            if options[option]['is_list']:
+                options[option]['new_value'] = [options[option]['default']]
+            else:
+                options[option]['new_value'] = options[option]['default']
+        await self.set_fw_options(options)
+
+    async def get_fw_options(self, fetchimm=True):
+        if fetchimm:
+            cfgfilename = "config.efi"
+        else:
+            cfgfilename = "config"
+        options = {}
+        data = None
+        if self.connection:
+            rsp = ({}, 200)
+        else:
+            rsp = await self.xc.grab_redfish_response_with_status(
+                    '/redfish/v1/Managers/1')
+        if rsp[1] == 200:
+            if 'purley' not in rsp[0].get('Oem', {}).get('Lenovo', {}).get(
+                                    'release_name', 'unknown'):
+                rsp = await self.xc.grab_redfish_response_with_status(
+                    '/redfish/v1/Systems/1/Actions/Oem/LenovoComputerSystem.DSReadFile',
+                    {'Action': 'DSReadFile', 'FileName': cfgfilename})
+            else:
+                rsp = (None, 500)
+        if rsp[1] == 200:
+            for _ in range(0, 30):
+                data = rsp[0]['Content']
+                data = base64.b64decode(data)
+                data = EfiCompressor.FrameworkDecompress(data, len(data))
+                if len(data) != 0:
+                    break
+                if self.connection:
+                    await self.connection.ipmi_session.pause(2)
+                else:
+                    await asyncio.sleep(2)
+                rsp = await self.xc.grab_redfish_response_with_status(
+                    '/redfish/v1/Systems/1/Actions/Oem/LenovoComputerSystem.DSReadFile',
+                    {'Action': 'DSReadFile', 'FileName': cfgfilename})
+        else:
+            if self.connection is None:
+                raise Unsupported('Not Supported')
+            for _ in range(0, 30):
+                filehandle = await self.imm_open(cfgfilename)
+                size = await self.imm_size(cfgfilename)
+                data = await self.imm_read(filehandle, size)
+                await self.imm_close(filehandle)
+                data = EfiCompressor.FrameworkDecompress(data, len(data))
+                if len(data) != 0:
+                    break
+                await self.connection.ipmi_session.pause(2)
+        if not data:
+            raise Exception("BMC failed to return configuration information")
+        xml = fromstring(data)
+        sortid = 0
+        for config in xml.iter("config"):
+            lenovo_id = config.get("ID")
+            if lenovo_id == 'iSCSI':
+                # Do not support iSCSI at this time
+                continue
+            cfglabel = config.find('mriName')
+            cfglabel = lenovo_id if cfglabel is None else cfglabel.text
+            if lenovo_id == 'SYSTEM_PROD_DATA':
+                theiter = [config]
+            else:
+                theiter = config.iter('group')
+            for group in theiter:
+                if lenovo_id == 'SYSTEM_PROD_DATA':
+                    lenovo_group = None
+                else:
+                    lenovo_group = group.get("ID")
+                for setting in group.iter("setting"):
+                    forceinstance = False
+                    is_list = False
+                    lenovo_setting = setting.get("ID")
+                    protect = True if setting.get("protected") == 'true' \
+                        else False
+                    hide = setting.get('suppress-if')
+                    if hide:
+                        hide = _convert_syntax(hide)
+                    readonly = setting.get('gray-if')
+                    if readonly:
+                        readonly = _convert_syntax(readonly)
+                    else:
+                        access = setting.get('access')
+                        if access == 'readonly':
+                            readonly = 'true'
+                    possible = []
+                    current = None
+                    currentidxes = []
+                    default = None
+                    reset = False
+                    name = setting.find("mriName").text
+                    help = setting.find("desc").text
+                    validexpression = None
+                    onedata = setting.find('text_data')
+                    if onedata is not None:
+                        if onedata.get('password') == 'true':
+                            protect = True
+                    enumdata = setting.find('enumerate_data')
+                    if enumdata is not None:
+                        if enumdata.get('maxinstance') is not None:
+                            forceinstance = True
+                    if onedata is None:
+                        onedata = setting.find('numeric_data')
+                    if onedata is not None:
+                        if onedata.get('maxinstance') is not None:
+                            forceinstance = True
+                        validexpression = onedata.get('pattern', None)
+                        instances = list(onedata.iter('instance'))
+                        if not instances:
+                            protect = True  # not supported yet
+                        else:
+                            instbynum = {}
+                            defidx = 1
+                            for x in instances:
+                                xid = int(x.get('ID', defidx))
+                                instbynum[xid] = x
+                                defidx += 1
+                            current = [instbynum[idx].text for idx in sorted(instbynum)]
+                            currentidxes = list(sorted(instbynum))
+                        default = onedata.get('default', None)
+                        if default == '':
+                            default = None
+                    if (setting.find('cmd_data') is not None
+                            or setting.find('boolean_data') is not None):
+                        protect = True  # Hide currently unsupported settings
+                    ldata = setting.find("list_data")
+                    extraorder = False
+                    currentdict = {}
+                    currentdef = {}
+                    if ldata is not None:
+                        is_list = True
+                        current = []
+                        extraorder = ldata.get('ordered') == 'true'
+                    lenovo_value = None
+                    instancetochoicemap = {}
+                    for choice in setting.iter("choice"):
+                        label = choice.find("label").text
+                        possible.append(label)
+                        for instance in choice.iter("instance"):
+                            if is_list:
+                                if not extraorder:
+                                    current.append(label)
+                                else:
+                                    currentdict[
+                                        int(instance.get("order"))] = label
+                            else:
+                                currid = instance.get('ID')
+                                if currid:
+                                    instancetochoicemap[currid] = label
+                                else:
+                                    current = label
+                                try:
+                                    lenovo_value = int(
+                                        choice.find('value').text)
+                                except ValueError:
+                                    lenovo_value = choice.find('value').text
+                        hasdefault = choice.get('default')
+                        if hasdefault == "true":
+                            default = label
+                        elif hasdefault is not None:
+                            try:
+                                a = int(hasdefault)
+                                currentdef[a] = label
+                            except ValueError:
+                                pass
+                        if choice.get("reset-required") == "true":
+                            reset = True
+                    if len(currentdict) > 0:
+                        for order in sorted(currentdict):
+                            current.append(currentdict[order])
+                    if len(currentdef) > 0:
+                        default = []
+                        for order in sorted(currentdef):
+                            default.append(currentdef[order])
+                    optionname = "%s.%s" % (cfglabel, name)
+                    alias = "%s.%s" % (lenovo_id, name)
+                    if onedata is not None:
+                        if current and len(current) > 1:
+                            instidx = 1
+                            for inst in current:
+                                if currentidxes:
+                                    instidx = currentidxes.pop(0)
+                                optname = '{0}.{1}'.format(optionname, instidx)
+                                options[optname] = dict(
+                                    current=inst,
+                                    default=default,
+                                    possible=possible,
+                                    pending=None,
+                                    new_value=None,
+                                    help=help,
+                                    is_list=is_list,
+                                    lenovo_value=lenovo_value,
+                                    lenovo_id=lenovo_id,
+                                    lenovo_group=lenovo_group,
+                                    lenovo_setting=lenovo_setting,
+                                    lenovo_reboot=reset,
+                                    lenovo_protect=protect,
+                                    lenovo_instance=instidx,
+                                    readonly_expression=readonly,
+                                    hide_expression=hide,
+                                    sortid=sortid,
+                                    validexpression=validexpression,
+                                    alias=alias)
+                                sortid += 1
+                                instidx += 1
+                            continue
+                        if current:
+                            current = current[0]
+                    if instancetochoicemap:
+                        for currid in sorted(instancetochoicemap):
+                            optname = '{0}.{1}'.format(optionname, currid)
+                            current = instancetochoicemap[currid]
+                            options[optname] = dict(
+                                current=current,
+                                default=default,
+                                possible=possible,
+                                pending=None,
+                                new_value=None,
+                                help=help,
+                                is_list=is_list,
+                                lenovo_value=lenovo_value,
+                                lenovo_id=lenovo_id,
+                                lenovo_group=lenovo_group,
+                                lenovo_setting=lenovo_setting,
+                                lenovo_reboot=reset,
+                                lenovo_protect=protect,
+                                lenovo_instance=currid,
+                                readonly_expression=readonly,
+                                hide_expression=hide,
+                                sortid=sortid,
+                                validexpression=validexpression,
+                                alias=alias)
+                            sortid += 1
+                        continue
+                    lenovoinstance = ""
+                    if forceinstance:
+                        optionname = '{0}.{1}'.format(optionname, 1)
+                        lenovoinstance = 1
+                    options[optionname] = dict(current=current,
+                                               default=default,
+                                               possible=possible,
+                                               pending=None,
+                                               new_value=None,
+                                               help=help,
+                                               is_list=is_list,
+                                               lenovo_value=lenovo_value,
+                                               lenovo_id=lenovo_id,
+                                               lenovo_group=lenovo_group,
+                                               lenovo_setting=lenovo_setting,
+                                               lenovo_reboot=reset,
+                                               lenovo_protect=protect,
+                                               lenovo_instance=lenovoinstance,
+                                               readonly_expression=readonly,
+                                               hide_expression=hide,
+                                               sortid=sortid,
+                                               validexpression=validexpression,
+                                               alias=alias)
+                    sortid = sortid + 1
+        for opt in options:
+            opt = options[opt]
+            opt['hidden'], opt['hidden_why'] = _eval_conditional(
+                opt['hide_expression'], options, opt)
+            opt['readonly'], opt['readonly_why'] = _eval_conditional(
+                opt['readonly_expression'], options, opt)
+
+        return options
+
+    async def set_fw_options(self, options, checkonly=False):
+        changes = False
+        random.seed()
+        ident = 'ASU-%x-%x-%x-0' % (random.getrandbits(48),
+                                    random.getrandbits(32),
+                                    random.getrandbits(64))
+
+        configurations = etree.Element('configurations', ID=ident,
+                                       type='update', update='ASU Client')
+
+        for option in options.keys():
+            if options[option]['new_value'] is None:
+                continue
+            if options[option]['readonly']:
+                errstr = '{0} is read only'.format(option)
+                if options[option]['readonly_why']:
+                    ea = ' due to one of the following settings: {0}'.format(
+                        ','.join(sorted(options[option]['readonly_why'])))
+                    errstr += ea
+                raise pygexc.InvalidParameterValue(errstr)
+            if options[option]['current'] == options[option]['new_value']:
+                continue
+            if options[option]['pending'] == options[option]['new_value']:
+                continue
+            if isinstance(options[option]['new_value'], str):
+                # Coerce a simple string parameter to the expected list format
+                options[option]['new_value'] = [options[option]['new_value']]
+            options[option]['pending'] = options[option]['new_value']
+
+            is_list = options[option]['is_list']
+            count = 0
+            changes = True
+            config = etree.Element('config', ID=options[option]['lenovo_id'])
+            configurations.append(config)
+            setting = etree.Element('setting',
+                                    ID=options[option]['lenovo_setting'])
+            if options[option]['lenovo_group'] is not None:
+                group = etree.Element('group',
+                                      ID=options[option]['lenovo_group'])
+                config.append(group)
+                group.append(setting)
+            else:
+                config.append(setting)
+            if is_list:
+                container = etree.Element('list_data')
+                setting.append(container)
+            else:
+                container = etree.Element('enumerate_data')
+                setting.append(container)
+
+            for value in options[option]['new_value']:
+                choice = etree.Element('choice')
+                container.append(choice)
+                label = etree.Element('label')
+                label.text = value
+                choice.append(label)
+                if is_list:
+                    count += 1
+                    instance = etree.Element(
+                        'instance', ID=str(options[option]['lenovo_instance']),
+                        order=str(count))
+                else:
+                    instance = etree.Element(
+                        'instance', ID=str(options[option]['lenovo_instance']))
+                choice.append(instance)
+
+        if not changes:
+            return False
+        if checkonly:
+            return True
+
+        xml = etree.tostring(configurations)
+        data = EfiCompressor.FrameworkCompress(xml, len(xml))
+        bdata = base64.b64encode(data).decode('utf8')
+        rsp = await self.xc.grab_redfish_response_with_status(
+                '/redfish/v1/Managers/1')
+        if rsp[1] == 200:
+            if 'purley' not in rsp[0].get('Oem', {}).get('Lenovo', {}).get(
+                    'release_name', 'purley'):
+                rsp = await self.xc.grab_redfish_response_with_status(
+                    '/redfish/v1/Systems/1/Actions/Oem/'
+                    'LenovoComputerSystem.DSWriteFile',
+                    {'Action': 'DSWriteFile', 'Resize': len(data),
+                     'FileName': 'asu_update.efi', 'Content': bdata})
+                if rsp[1] == 204:
+                    return True
+        if self.connection is None:
+            raise Unsupported('Not Supported')
+        filehandle = await self.imm_open("asu_update.efi", write=True,
+                                size=len(data))
+        await self.imm_write(filehandle, len(data), data)
+        stubread = len(data)
+        if stubread > 8:
+            stubread = 8
+        await self.imm_read(filehandle, stubread)
+        await self.imm_close(filehandle)
+        return True
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/cpu.py b/confluent_server/aiohmi/ipmi/oem/lenovo/cpu.py
new file mode 100755
index 00000000..e3e98910
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/cpu.py
@@ -0,0 +1,53 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+cpu_fields = (
+    inventory.EntryField("index", "B"),
+    inventory.EntryField("Cores", "B"),
+    inventory.EntryField("Threads", "B"),
+    inventory.EntryField("Manufacturer", "13s"),
+    inventory.EntryField("Family", "30s"),
+    inventory.EntryField("Model", "30s"),
+    inventory.EntryField("Stepping", "3s"),
+    inventory.EntryField("Maximum Frequency", "<I",
+                         valuefunc=lambda v: str(v) + " MHz"),
+    inventory.EntryField("Reserved", "h", include=False))
+
+cpu_cmd = {
+    "lenovo": {
+        "netfn": 0x06,
+        "command": 0x59,
+        "data": (0x00, 0xc1, 0x01, 0x00)},
+    "asrock": {
+        "netfn": 0x3a,
+        "command": 0x50,
+        "data": (0x01, 0x01, 0x00)},
+}
+
+
+def parse_cpu_info(raw):
+    return inventory.parse_inventory_category_entry(raw, cpu_fields)
+
+
+def get_categories():
+    return {
+        "cpu": {
+            "idstr": "CPU {0}",
+            "parser": parse_cpu_info,
+            "command": cpu_cmd,
+            "workaround_bmc_bug": lambda t: t == "ami"
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/dimm.py b/confluent_server/aiohmi/ipmi/oem/lenovo/dimm.py
new file mode 100755
index 00000000..a94a9f1f
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/dimm.py
@@ -0,0 +1,59 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+
+dimm_fields = (
+    inventory.EntryField("index", "B"),
+    inventory.EntryField("manufacture_location", "B"),
+    inventory.EntryField("channel_number", "B"),
+    inventory.EntryField("module_type", "10s"),
+    inventory.EntryField("ddr_voltage", "10s"),
+    inventory.EntryField("speed", "<h",
+                         valuefunc=lambda v: str(v) + " MHz"),
+    inventory.EntryField("capacity_mb", "<h",
+                         valuefunc=lambda v: v * 1024),
+    inventory.EntryField("manufacturer", "30s"),
+    inventory.EntryField("serial", ">I",
+                         valuefunc=lambda v: hex(v)[2:]),
+    inventory.EntryField("model", "21s"),
+    inventory.EntryField("reserved", "h", include=False)
+)
+
+dimm_cmd = {
+    "lenovo": {
+        "netfn": 0x06,
+        "command": 0x59,
+        "data": (0x00, 0xc1, 0x02, 0x00)},
+    "asrock": {
+        "netfn": 0x3a,
+        "command": 0x50,
+        "data": (0x01, 0x02, 0x01)},
+}
+
+
+def parse_dimm_info(raw):
+    return inventory.parse_inventory_category_entry(raw, dimm_fields)
+
+
+def get_categories():
+    return {
+        "dimm": {
+            "idstr": "DIMM {0}",
+            "parser": parse_dimm_info,
+            "command": dimm_cmd,
+            "workaround_bmc_bug": lambda t: True
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/drive.py b/confluent_server/aiohmi/ipmi/oem/lenovo/drive.py
new file mode 100755
index 00000000..7f57119e
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/drive.py
@@ -0,0 +1,69 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+drive_fields = (
+    inventory.EntryField("index", "B"),
+    inventory.EntryField("VendorID", "64s"),
+    inventory.EntryField("Size", "I",
+                         valuefunc=lambda v: str(v) + " MB"),
+    inventory.EntryField("MediaType", "B", mapper={
+        0x00: "HDD",
+        0x01: "SSD"
+    }),
+    inventory.EntryField("InterfaceType", "B", mapper={
+        0x00: "Unknown",
+        0x01: "ParallelSCSI",
+        0x02: "SAS",
+        0x03: "SATA",
+        0x04: "FC"
+    }),
+    inventory.EntryField("FormFactor", "B", mapper={
+        0x00: "Unknown",
+        0x01: "2.5in",
+        0x02: "3.5in"
+    }),
+    inventory.EntryField("LinkSpeed", "B", mapper={
+        0x00: "Unknown",
+        0x01: "1.5 Gb/s",
+        0x02: "3.0 Gb/s",
+        0x03: "6.0 Gb/s",
+        0x04: "12.0 Gb/s"
+    }),
+    inventory.EntryField("SlotNumber", "B"),
+    inventory.EntryField("ControllerIndex", "B"),
+    inventory.EntryField("DeviceState", "B", mapper={
+        0x00: "active",
+        0x01: "stopped",
+        0xff: "transitioning"
+    }))
+
+
+def parse_drive_info(raw):
+    return inventory.parse_inventory_category_entry(raw, drive_fields)
+
+
+def get_categories():
+    return {
+        "drive": {
+            "idstr": "Drive {0}",
+            "parser": parse_drive_info,
+            "command": {
+                "netfn": 0x06,
+                "command": 0x59,
+                "data": (0x00, 0xc1, 0x04, 0x00)
+            }
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/energy.py b/confluent_server/aiohmi/ipmi/oem/lenovo/energy.py
new file mode 100644
index 00000000..f2469308
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/energy.py
@@ -0,0 +1,166 @@
+# Copyright 2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import struct
+
+import aiohmi.constants as const
+import aiohmi.exceptions as pygexc
+import aiohmi.ipmi.sdr as sdr
+
+
+class EnergyManager(object):
+
+    @classmethod
+    async def create(cls, ipmicmd):
+        # there are two IANA possible for the command set, start with
+        # the Lenovo, then fallback to IBM
+        # We start with a 'find firmware instance' to test the water and
+        # get the handle (which has always been the same, but just in case
+        self = cls()
+        self.iana = bytearray(b'\x66\x4a\x00')
+        self._usefapm = False
+        self._mypowermeters = ()
+        try:
+            rsp = await ipmicmd.raw_command(netfn=0x3a, command=0x32, data=[4, 2, 0, 0, 0])
+            if len(rsp['data']) >= 8:
+                self.supportedmeters = ('DC Energy', 'GPU Power',
+                                        'Node Power', 'Total Power')
+                self._mypowermeters = ('node power', 'total power', 'gpu power', 'riser 1 power', 'riser 2 power')
+                self._usefapm = True
+                return
+        except pygexc.IpmiException:
+            pass
+
+        try:
+            rsp = await ipmicmd.raw_command(netfn=0x2e, command=0x82,
+                                       data=self.iana + b'\x00\x00\x01')
+        except pygexc.IpmiException as ie:
+            if ie.ipmicode == 193:  # try again with IBM IANA
+                self.iana = bytearray(b'\x4d\x4f\x00')
+                rsp = await ipmicmd.raw_command(netfn=0x2e, command=0x82,
+                                           data=self.iana + b'\x00\x00\x01')
+            else:
+                raise
+        if rsp['data'][4:6] not in (b'\x02\x01', b'\x02\x06', b'\x02\x09'):
+            raise pygexc.UnsupportedFunctionality(
+                "Energy Control {0}.{1} not recognized".format(rsp['data'][4],
+                                                               rsp['data'][5]))
+        self.modhandle = bytearray(rsp['data'][6:7])
+        if await self.get_ac_energy(ipmicmd):
+            self.supportedmeters = ('AC Energy', 'DC Energy')
+        else:
+            self.supportedmeters = ('DC Energy',)
+        return self
+
+    def supports(self, name):
+        if name.lower() in self._mypowermeters:
+            return True
+        return False
+
+    async def get_sensor(self, name, ipmicmd):
+        if name.lower() not in self._mypowermeters:
+            raise pygexc.UnsupportedFunctionality('Unrecogcized sensor')
+        tries = 3
+        rsp = None
+        while tries:
+            tries -= 1
+            try:
+                rsp = await ipmicmd.raw_command(netfn=0x3a, command=0x32, data=[4, 8, 0, 0, 0])
+                break
+            except pygexc.IpmiException as ie:
+                if tries and ie.ipmicode == 0xc3:
+                    ipmicmd.ipmi_session.pause(0.1)
+                    continue
+                raise
+        if rsp is None:
+            raise pygexc.UnsupportedFunctionality('Unrecogcized sensor')
+        npow, gpupow, r1pow, r2pow = struct.unpack('<HHHH', rsp['data'][6:14])
+        if name.lower().startswith('node'):
+            return npow, 'W'
+        elif name.lower().startswith('gpu'):
+            return gpupow, 'W'
+        elif name.lower().startswith('total'):
+            return npow + gpupow, 'W'
+
+    async def get_fapm_energy(self, ipmicmd):
+        rsp = await ipmicmd.raw_command(netfn=0x3a, command=0x32, data=[4, 2, 0, 0, 0])
+        j, mj = struct.unpack('<IH', rsp['data'][2:8])
+        mj = mj + (j * 1000)
+        return float(mj / 1000000 / 3600)
+
+    async def get_energy_precision(self, ipmicmd):
+        rsp = await ipmicmd.raw_command(
+            netfn=0x2e, command=0x81,
+            data=self.iana + self.modhandle + b'\x01\x80')
+        print(repr(rsp['data'][:]))
+
+    async def get_ac_energy(self, ipmicmd):
+        try:
+            rsp = await ipmicmd.raw_command(
+                netfn=0x2e, command=0x81,
+                data=self.iana + self.modhandle + b'\x01\x82\x01\x08')
+            # data is in millijoules, convert to the more recognizable kWh
+            return float(
+                struct.unpack('!Q', rsp['data'][3:])[0]) / 1000000 / 3600
+        except pygexc.IpmiException as ie:
+            if ie.ipmicode == 0xcb:
+                return 0.0
+            raise
+
+    async def get_dc_energy(self, ipmicmd):
+        if self._usefapm:
+            return await self.get_fapm_energy(ipmicmd)
+        rsp = await ipmicmd.raw_command(
+            netfn=0x2e, command=0x81,
+            data=self.iana + self.modhandle + b'\x01\x82\x00\x08')
+        # data is in millijoules, convert to the more recognizable kWh
+        return float(struct.unpack('!Q', rsp['data'][3:])[0]) / 1000000 / 3600
+
+
+class Energy(object):
+
+    def __init__(self, ipmicmd):
+        self.ipmicmd = ipmicmd
+
+    async def get_energy_sensor(self):
+        # read the cpu usage
+
+        try:
+            rsp = await self.ipmicmd.raw_command(netfn=0x04,
+                                            command=0x2d,
+                                            bridge_request={"addr": 0x2c,
+                                                            "channel": 0x06},
+                                            data=[0xbe])
+        except pygexc.IpmiException:
+            return
+        rdata = bytearray(rsp["data"])
+        cpu_usage = rdata[0] * 100 / 0xff
+        # mimic the power sensor
+        temp = {'name': "CPU_Usage",
+                'health': const.Health.Ok,
+                'states': [],
+                'state_ids': [],
+                'type': "Processor",
+                'units': "%",
+                'value': cpu_usage,
+                'imprecision': None}
+        yield (sdr.SensorReading(temp, temp['units']))
+
+
+if __name__ == '__main__':
+    import os
+    import aiohmi.ipmi.command as cmd
+    import sys
+    c = cmd.Command(sys.argv[1], os.environ['BMCUSER'], os.environ['BMCPASS'])
+    EnergyManager(c).get_dc_energy(c)
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/firmware.py b/confluent_server/aiohmi/ipmi/oem/lenovo/firmware.py
new file mode 100644
index 00000000..b35fd557
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/firmware.py
@@ -0,0 +1,117 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+
+firmware_fields = (
+    inventory.EntryField("Revision", "B"),
+    inventory.EntryField("Bios", "16s"),
+    inventory.EntryField("Operational ME", "10s"),
+    inventory.EntryField("Recovery ME", "10s"),
+    inventory.EntryField("RAID 1", "16s"),
+    inventory.EntryField("RAID 2", "16s"),
+    inventory.EntryField("Mezz 1", "16s"),
+    inventory.EntryField("Mezz 2", "16s"),
+    inventory.EntryField("BMC", "16s"),
+    inventory.EntryField("LEPT", "16s"),
+    inventory.EntryField("PSU 1", "16s"),
+    inventory.EntryField("PSU 2", "16s"),
+    inventory.EntryField("CPLD", "16s"),
+    inventory.EntryField("LIND", "16s"),
+    inventory.EntryField("WIND", "16s"),
+    inventory.EntryField("DIAG", "16s"))
+
+asrock_firmware_fields = (
+    inventory.EntryField("Major Firmware Revision", "B"),
+    inventory.EntryField("Minor Firmware Revision", "B"),
+    inventory.EntryField("Auxiliary Firmware Revision", "4s"))
+
+firmware_cmd = {
+    "lenovo": {
+        "netfn": 0x06,
+        "command": 0x59,
+        "data": (0x00, 0xc7, 0x00, 0x00)},
+    "asrock": {
+        "netfn": 0x3a,
+        "command": 0x50,
+        "data": (0x02, 0x00, 0x01)},
+}
+
+bios_cmd = {
+    "lenovo": {
+        "netfn": 0x32,
+        "command": 0xE8,
+        "data": (0x01, 0x01, 0x02)},
+    "asrock": {
+        "netfn": 0x3a,
+        "command": 0x50,
+        "data": (0x02, 0x01, 0x01)},
+}
+
+
+def parse_firmware_info(raw, bios_versions=None, asrock=False):
+    fields = firmware_fields
+
+    if asrock:
+        fields = asrock_firmware_fields
+
+    bytes_read, data = inventory.parse_inventory_category_entry(raw, fields)
+    if asrock:
+        major_version = data['Major Firmware Revision']
+        minor_version = data['Minor Firmware Revision']
+        # Asrock RS160 the minor version is Binary Coded Decimal,
+        # convert it to Decimal
+        minor_version = (0xff & (minor_version >> 4)) * 10 + \
+                        (0xf & minor_version)
+        aux_reversion = 0
+        if str(data['Auxiliary Firmware Revision']) != '':
+            aux_reversion = ord(data['Auxiliary Firmware Revision'])
+
+        bmc_version = "%s.%s.%s" % (
+            str(major_version),
+            str(minor_version),
+            str(aux_reversion))
+
+        yield ("BMC", {'version': bmc_version})
+        if bios_versions is not None:
+            yield ("Bios", {'version': bios_versions[0:]})
+    else:
+        del data["Revision"]
+        for key in data:
+            yield (key, {'version': data[key]})
+        if bios_versions is not None:
+            yield ("Bios_bundle_ver",
+                   {'version': bios_versions['new_img_version']})
+            yield ("Bios_current_ver",
+                   {'version': bios_versions['cur_img_version']})
+
+
+def parse_bios_number(raw):
+    return inventory.parse_bios_number_entry(raw)
+
+
+def get_categories():
+    return {
+        "firmware": {
+            "idstr": "FW Version",
+            "parser": parse_firmware_info,
+            "command": firmware_cmd
+        },
+        "bios_version": {
+            "idstr": "Bios Version",
+            "parser": parse_bios_number,
+            "command": bios_cmd
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/handler.py b/confluent_server/aiohmi/ipmi/oem/lenovo/handler.py
new file mode 100755
index 00000000..6d632419
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/handler.py
@@ -0,0 +1,1440 @@
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import base64
+import binascii
+import socket
+import struct
+import traceback
+import weakref
+
+import aiohmi.constants as pygconst
+import aiohmi.exceptions as pygexc
+import aiohmi.ipmi.oem.generic as generic
+from aiohmi.ipmi.oem.lenovo import cpu
+from aiohmi.ipmi.oem.lenovo import dimm
+from aiohmi.ipmi.oem.lenovo import drive
+from aiohmi.ipmi.oem.lenovo import energy
+from aiohmi.ipmi.oem.lenovo import firmware
+from aiohmi.ipmi.oem.lenovo import imm
+from aiohmi.ipmi.oem.lenovo import inventory
+from aiohmi.ipmi.oem.lenovo import nextscale
+from aiohmi.ipmi.oem.lenovo import pci
+from aiohmi.ipmi.oem.lenovo import psu
+from aiohmi.ipmi.oem.lenovo import raid_controller
+from aiohmi.ipmi.oem.lenovo import raid_drive
+import aiohmi.ipmi.private.constants as ipmiconst
+import aiohmi.ipmi.private.util as util
+import aiohmi.redfish.command as redfishcmd
+from aiohmi.redfish.oem.lenovo import tsma
+import aiohmi.util.webclient as wc
+
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+try:
+    range = xrange
+except NameError:
+    pass
+try:
+    buffer
+except NameError:
+    buffer = memoryview
+
+inventory.register_inventory_category(cpu)
+inventory.register_inventory_category(dimm)
+inventory.register_inventory_category(pci)
+inventory.register_inventory_category(drive)
+inventory.register_inventory_category(psu)
+inventory.register_inventory_category(raid_drive)
+inventory.register_inventory_category(raid_controller)
+
+
+firmware_types = {
+    1: 'Management Controller',
+    2: 'UEFI/BIOS',
+    3: 'CPLD',
+    4: 'Power Supply',
+    5: 'Storage Adapter',
+    6: 'Add-in Adapter',
+}
+
+firmware_event = {
+    0: ('Update failed', pygconst.Health.Failed),
+    1: ('Update succeeded', pygconst.Health.Ok),
+    2: ('Update aborted', pygconst.Health.Ok),
+    3: ('Unknown', pygconst.Health.Warning),
+}
+
+me_status = {
+    0: ('Recovery GPIO forced', pygconst.Health.Warning),
+    1: ('ME Image corrupt', pygconst.Health.Critical),
+    2: ('Flash erase error', pygconst.Health.Critical),
+    3: ('Unspecified flash state', pygconst.Health.Warning),
+    4: ('ME watchdog timeout', pygconst.Health.Critical),
+    5: ('ME platform reboot', pygconst.Health.Critical),
+    6: ('ME update', pygconst.Health.Ok),
+    7: ('Manufacturing error', pygconst.Health.Critical),
+    8: ('ME Flash storage integrity error', pygconst.Health.Critical),
+    9: ('ME firmware exception', pygconst.Health.Critical),  # event data 3..
+    0xa: ('ME firmware worn', pygconst.Health.Warning),
+    0xc: ('Invalid SCMP state', pygconst.Health.Warning),
+    0xd: ('PECI over DMI failure', pygconst.Health.Warning),
+    0xe: ('MCTP interface failure', pygconst.Health.Warning),
+    0xf: ('Auto configuration completed', pygconst.Health.Ok),
+}
+
+me_flash_status = {
+    0: ('ME flash corrupted', pygconst.Health.Critical),
+    1: ('ME flash erase limit reached', pygconst.Health.Critical),
+    2: ('ME flash write limit reached', pygconst.Health.Critical),
+    3: ('ME flash write enabled', pygconst.Health.Ok),
+}
+
+leds = {
+    "BMC_UID": 0x00,
+    "BMC_HEARTBEAT": 0x01,
+    "SYSTEM_FAULT": 0x02,
+    "PSU1_FAULT": 0x03,
+    "PSU2_FAULT": 0x04,
+    "LED_FAN_FAULT_1": 0x10,
+    "LED_FAN_FAULT_2": 0x11,
+    "LED_FAN_FAULT_3": 0x12,
+    "LED_FAN_FAULT_4": 0x13,
+    "LED_FAN_FAULT_5": 0x14,
+    "LED_FAN_FAULT_6": 0x15,
+    "LED_FAN_FAULT_7": 0x16,
+    "LED_FAN_FAULT_8": 0x17
+}
+
+led_status = {
+    0x00: "Off",
+    0xFF: "On"
+}
+
+ami_leds = {
+    "BMC_HEARTBEAT": 0x00,
+    "BMC_UID": 0x01,
+    "SYSTEM_FAULT": 0x02,
+    "HDD_FAULT": 0x03
+}
+
+asrock_leds = {
+    "SYSTEM_EVENT": 0x00,
+    "BMC_UID": 0x01,
+    "LED_FAN_FAULT_1": 0x02,
+    "LED_FAN_FAULT_2": 0x03,
+    "LED_FAN_FAULT_3": 0x04
+}
+
+ts460_leds = {
+    "SYSTEM_EVENT": 0x00,
+    "BMC_UID": 0x01,
+    "LED_FAN_FAULT_1": 0x02,
+    "LED_FAN_FAULT_2": 0x03,
+    "LED_FAN_CPU": 0x04,
+    "LED_FAN_REAR": 0x05
+}
+
+asrock_led_status = {
+    0x00: "Off",
+    0x01: "On"
+}
+
+ami_led_status = {
+    0x00: "Off",
+    0x01: "On"
+}
+
+led_status_default = "Blink"
+mac_format = '{0:02x}:{1:02x}:{2:02x}:{3:02x}:{4:02x}:{5:02x}'
+categorie_items = ["cpu", "dimm", "firmware", "bios_version"]
+
+
+def _megarac_abbrev_image(name):
+    # MegaRAC platform in some places needs an abbreviated filename
+    # Their scheme in such a scenario is a max of 20.  Truncation is
+    # acheived by taking the first sixteen, then skipping ahead to the last
+    # 4 (presumably to try to keep '.iso' or '.img' in the name).
+    if len(name) <= 20:
+        return name
+    return name[:16] + name[-4:]
+
+
+class OEMHandler(generic.OEMHandler):
+    # noinspection PyUnusedLocal
+    @classmethod
+    async def create(cls, oemid, ipmicmd):
+        self = cls()
+        # will need to retain data to differentiate
+        # variations.  For example System X versus Thinkserver
+        self.oemid = oemid
+        self._fpc_variant = None
+        self.ipmicmd = weakref.proxy(ipmicmd)
+        self._has_megarac = None
+        self.oem_inventory_info = None
+        self._mrethidx = None
+        self._hasimm = None
+        self._hasxcc = None
+        if await self.has_xcc():
+            self.immhandler = imm.XCCClient(ipmicmd)
+        elif await self.has_imm():
+            self.immhandler = imm.IMMClient(ipmicmd)
+        elif await self.is_fpc():
+            self.smmhandler = nextscale.SMMClient(ipmicmd, await self.is_fpc())
+        elif self.has_tsma:
+            conn = wc.WebConnection(
+                ipmicmd.bmc, 443,
+                verifycallback=self.ipmicmd.certverify)
+            self.tsmahandler = await tsma.TsmHandler.create(None, None, conn,
+                                                            fish=redfishcmd)
+            self.tsmahandler.set_credentials(
+                ipmicmd.ipmi_session.userid.decode('utf-8'),
+                ipmicmd.ipmi_session.password.decode('utf-8'))
+        return self
+
+    
+    async def _megarac_eth_index(self):
+        if self._mrethidx is None:
+            chan = await self.ipmicmd.get_network_channel()
+            rsp = await self.ipmicmd.raw_command(0x32, command=0x62, data=(chan,))
+            self._mrethidx = rsp['data'][0]
+        return self._mrethidx
+ 
+    async def get_screenshot(self, outfile):
+        if await self.has_xcc():
+            return await self.immhandler.get_screenshot(outfile)
+        return {}
+
+    async def remove_storage_configuration(self, cfgspec):
+        if await self.has_xcc():
+            return await self.immhandler.remove_storage_configuration(cfgspec)
+        return await super(OEMHandler, self).remove_storage_configuration()
+
+    async def get_ikvm_methods(self):
+        if await self.has_xcc():
+            return ['url']
+
+    async def get_ikvm_launchdata(self):
+        if await self.has_xcc():
+            return await self.immhandler.get_ikvm_launchdata()
+        return {}
+
+    async def clear_storage_arrays(self):
+        if await self.has_xcc():
+            return await self.immhandler.clear_storage_arrays()
+        return await super(OEMHandler, self).clear_storage_arrays()
+
+    async def apply_storage_configuration(self, cfgspec):
+        if await self.has_xcc():
+            return await self.immhandler.apply_storage_configuration(cfgspec)
+        return await super(OEMHandler, self).apply_storage_configuration()
+
+    async def check_storage_configuration(self, cfgspec):
+        if await self.has_xcc():
+            return await self.immhandler.check_storage_configuration(cfgspec)
+        return await super(OEMHandler, self).get_storage_configuration()
+
+    async def get_storage_configuration(self):
+        if await self.has_xcc():
+            return await self.immhandler.get_storage_configuration()
+        return await super(OEMHandler, self).get_storage_configuration()
+
+    async def get_video_launchdata(self):
+        if await self.has_tsm():
+            return await self.get_tsm_launchdata()
+
+    async def get_tsm_launchdata(self):
+        pass
+
+    async def process_event(self, event, ipmicmd, seldata):
+        if 'oemdata' in event:
+            oemtype = seldata[2]
+            oemdata = event['oemdata']
+            if oemtype == 0xd0:  # firmware update
+                event['component'] = firmware_types.get(oemdata[0], None)
+                event['component_type'] = ipmiconst.sensor_type_codes[0x2b]
+                slotnumber = (oemdata[1] & 0b11111000) >> 3
+                if slotnumber:
+                    event['component'] += ' {0}'.format(slotnumber)
+                event['event'], event['severity'] = \
+                    firmware_event[oemdata[1] & 0b111]
+                event['event_data'] = '{0}.{1}'.format(oemdata[2], oemdata[3])
+            elif oemtype == 0xd1:  # BIOS recovery
+                event['severity'] = pygconst.Health.Warning
+                event['component'] = 'BIOS/UEFI'
+                event['component_type'] = ipmiconst.sensor_type_codes[0xf]
+                status = oemdata[0]
+                method = (status & 0b11110000) >> 4
+                status = (status & 0b1111)
+                if method == 1:
+                    event['event'] = 'Automatic recovery'
+                elif method == 2:
+                    event['event'] = 'Manual recovery'
+                if status == 0:
+                    event['event'] += '- Failed'
+                    event['severity'] = pygconst.Health.Failed
+                if oemdata[1] == 0x1:
+                    event['event'] += '- BIOS recovery image not found'
+                event['event_data'] = '{0}.{1}'.format(oemdata[2], oemdata[3])
+            elif oemtype == 0xd2:  # eMMC status
+                if oemdata[0] == 1:
+                    event['component'] = 'eMMC'
+                    event['component_type'] = ipmiconst.sensor_type_codes[0xc]
+                    if oemdata[0] == 1:
+                        event['event'] = 'eMMC Format error'
+                        event['severity'] = pygconst.Health.Failed
+            elif oemtype == 0xd3:
+                if oemdata[0] == 1:
+                    event['event'] = 'User privilege modification'
+                    event['severity'] = pygconst.Health.Ok
+                    event['component'] = 'User Privilege'
+                    event['component_type'] = ipmiconst.sensor_type_codes[6]
+                    event['event_data'] = (
+                        'User {0} on channel {1} had privilege changed '
+                        'from {2} to {3}'.format(
+                            oemdata[2], oemdata[1], oemdata[3] & 0b1111,
+                            (oemdata[3] & 0b11110000) >> 4)
+                    )
+            else:
+                event['event'] = 'OEM event: {0}'.format(
+                    ' '.join(format(x, '02x') for x in event['oemdata']))
+            del event['oemdata']
+            return
+        evdata = event['event_data_bytes']
+        if event['event_type_byte'] == 0x75:  # ME event
+            event['component'] = 'ME Firmware'
+            event['component_type'] = ipmiconst.sensor_type_codes[0xf]
+            event['event'], event['severity'] = me_status.get(
+                evdata[1], ('Unknown', pygconst.Health.Warning))
+            if evdata[1] == 3:
+                event['event'], event['severity'] = me_flash_status.get(
+                    evdata[2], ('Unknown state', pygconst.Health.Warning))
+            elif evdata[1] == 9:
+                event['event'] += ' (0x{0:2x})'.format(evdata[2])
+            elif evdata[1] == 0xf and evdata[2] & 0b10000000:
+                event['event'] = 'Auto configuration failed'
+                event['severity'] = pygconst.Health.Critical
+        # For HDD bay events, the event data 2 is the bay, modify
+        # the description to be more specific
+        if (event['event_type_byte'] == 0x6f
+                and (evdata[0] & 0b11000000) == 0b10000000
+                and event['component_type_id'] == 13):
+            event['component'] += ' {0}'.format(evdata[1] & 0b11111)
+
+    async def reseat_bay(self, bay):
+        if self.is_fpc:
+            return await self.smmhandler.reseat_bay(bay)
+        elif self.has_xcc and bay == -1:
+            return await self.immhandler.reseat()
+        return await super(OEMHandler, self).reseat_bay(bay)
+
+    async def get_ntp_enabled(self):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            ntpres = await self.ipmicmd.raw_command(netfn=0x32, command=0xa7)
+            return ntpres['data'][0] == '\x01'
+        elif await self.is_fpc():
+            return await self.smmhandler.get_ntp_enabled(self._fpc_variant)
+        elif self.has_tsma:
+            return self.tsmahandler.get_ntp_enabled()
+        return None
+
+    async def get_ntp_servers(self):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            srvs = []
+            ntpres = await self.ipmicmd.raw_command(netfn=0x32, command=0xa7)
+            srvs.append(ntpres['data'][1:129].rstrip('\x00'))
+            srvs.append(ntpres['data'][129:257].rstrip('\x00'))
+            return srvs
+        if await self.is_fpc():
+            return await self.smmhandler.get_ntp_servers()
+        if self.has_tsma:
+            return self.tsmahandler.get_ntp_servers()
+        return ()
+
+    async def set_ntp_enabled(self, enabled):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            if enabled:
+                await self.ipmicmd.raw_command(
+                    netfn=0x32, command=0xa8, data=(3, 1), timeout=15)
+            else:
+                await self.ipmicmd.raw_command(
+                    netfn=0x32, command=0xa8, data=(3, 0), timeout=15)
+            return True
+        if await self.is_fpc():
+            await self.smmhandler.set_ntp_enabled(enabled)
+            return True
+        if self.has_tsma:
+            await self.tsmahandler.set_ntp_enabled(enabled)
+        return None
+
+    async def set_ntp_server(self, server, index=0):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            if not (0 <= index <= 1):
+                raise pygexc.InvalidParameterValue("Index must be 0 or 1")
+            cmddata = bytearray((1 + index, ))
+            cmddata += server.ljust(128, '\x00')
+            await self.ipmicmd.raw_command(netfn=0x32, command=0xa8, data=cmddata)
+            return True
+        elif await self.is_fpc():
+            if not 0 <= index <= 2:
+                raise pygexc.InvalidParameterValue(
+                    'SMM supports indexes 0 through 2')
+            await self.smmhandler.set_ntp_server(server, index)
+            return True
+        elif self.has_tsma:
+            if not (0 <= index <= 1):
+                raise pygexc.InvalidParameterValue("Index must be 0 or 1")
+            return await self.tsmahandler.set_ntp_server(server, index)
+        return None
+    
+    async def user_delete(self, uid, channel):
+        if await self.has_xcc():
+            return await self.immhandler.user_delete(uid)
+
+    async def set_user_access(self, uid, channel, callback, link_auth, ipmi_msg,
+                        privilege_level):
+        if await self.is_fpc() and self._fpc_variant != 6:
+            await self.smmhandler.set_user_priv(uid, privilege_level)
+
+    async def is_fpc(self):
+        """True if the target is a Lenovo nextscale fan power controller"""
+
+        if self._fpc_variant is not None:
+            return self._fpc_variant
+        has_imm = await self.has_imm()
+        has_xcc = await self.has_xcc()
+        if has_imm or has_xcc:
+            return None
+        fpc_ids = ((19046, 32, 1063), (20301, 32, 462))
+        smm_id = (19046, 32, 1180)
+        smmv2_2u = (19046, 32, 1360)
+        smmv2_6u = (19046, 32, 1387)
+        currid = (self.oemid['manufacturer_id'], self.oemid['device_id'],
+                  self.oemid['product_id'])
+        if currid in fpc_ids:
+            self._fpc_variant = 6
+        elif currid == smm_id:
+            self._fpc_variant = 2
+        elif currid == smmv2_2u:
+            self._fpc_variant = 0x22
+        elif currid == smmv2_6u:
+            self._fpc_variant = 0x26
+        return self._fpc_variant
+
+    @property
+    def is_sd350(self):
+        return (19046, 32, 13616) == (self.oemid['manufacturer_id'],
+                                      self.oemid['device_id'],
+                                      self.oemid['product_id'])
+
+    tsma_ids = ((19046, 32, 1287),)
+
+    @property
+    def has_tsma(self):
+        currid = (self.oemid['manufacturer_id'], self.oemid['device_id'],
+                  self.oemid['product_id'])
+        return currid in self.tsma_ids
+
+    async def has_tsm(self):
+        """True if this particular server have a TSM based service processor"""
+
+        if (self.oemid['manufacturer_id'] == 19046
+                and self.oemid['device_id'] == 32):
+            try:
+                await self.ipmicmd.raw_command(netfn=0x3a, command=0xf)
+            except pygexc.IpmiException as ie:
+                if ie.ipmicode == 193:
+                    return False
+                raise
+            return True
+        return False
+
+    async def has_asrock(self):
+        # True if this particular server have a ASROCKRACK
+        # based service processor (RS160 or TS460)
+        # RS160 (Riddler) product id is 1182 (049Eh)
+        # TS460 (WildThing) product id is 1184 (04A0h)
+
+        if (self.oemid['manufacturer_id'] == 19046
+                and (self.oemid['product_id'] == 1182
+                     or self.oemid['product_id'] == 1184)):
+            try:
+                await self.ipmicmd.raw_command(netfn=0x3a,
+                                          command=0x50,
+                                          data=(0x00, 0x00, 0x00))
+            except pygexc.IpmiException as ie:
+                if ie.ipmicode == 193:
+                    return False
+                raise
+            return True
+        return False
+
+    @property
+    def isTS460(self):
+        if self.oemid['product_id'] == 1184:
+            return True
+        return False
+
+    async def get_oem_inventory_descriptions(self):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            # Thinkserver with TSM
+            if not self.oem_inventory_info:
+                async for desc in self._collect_tsm_inventory():
+                    yield desc
+            for compname in self.oem_inventory_info:
+                yield compname
+        elif await self.has_imm():
+            async for desc in self.immhandler.get_hw_descriptions():
+                yield desc
+        elif await self.is_fpc():
+            async for desc in self.smmhandler.get_inventory_descriptions(self.ipmicmd,
+                                                                         await self.is_fpc()):
+                yield desc
+
+    async def get_oem_inventory(self):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            await self._collect_tsm_inventory()
+            for compname in self.oem_inventory_info:
+                yield (compname, self.oem_inventory_info[compname])
+        elif await self.has_imm():
+            async for inv in self.immhandler.get_hw_inventory():
+                yield inv
+        elif await self.is_fpc():
+            async for compname in self.smmhandler.get_inventory_descriptions(
+                    self.ipmicmd, await self.is_fpc()):
+                yield (compname, self.smmhandler.get_inventory_of_component(
+                    self.ipmicmd, compname))
+
+    async def get_sensor_data(self):
+        if await self.has_imm():
+            async for name in self.immhandler.get_oem_sensor_names(self.ipmicmd):
+                yield self.immhandler.get_oem_sensor_reading(name,
+                                                             self.ipmicmd)
+        elif await self.is_fpc():
+            for name in nextscale.get_sensor_names(self.ipmicmd,
+                                                   self._fpc_variant):
+                yield nextscale.get_sensor_reading(name, self.ipmicmd,
+                                                   self._fpc_variant)
+        elif await self.has_ami():
+            self.get_ami_sensor_data()
+
+    async def get_sensor_descriptions(self):
+        if await self.has_imm():
+            async for desc in self.immhandler.get_oem_sensor_descriptions(self.ipmicmd):
+                yield desc
+        elif await self.is_fpc():
+            async for desc in nextscale.get_sensor_descriptions(
+                self.ipmicmd, self._fpc_variant):
+                yield desc
+        elif await self.has_ami():
+            async for desc in self.get_ami_sensor_descriptions():
+                yield desc
+        if False:
+            yield None
+
+    async def get_sensor_reading(self, sensorname):
+        if await self.has_imm():
+            return self.immhandler.get_oem_sensor_reading(sensorname,
+                                                          self.ipmicmd)
+        elif await self.is_fpc():
+            return nextscale.get_sensor_reading(sensorname, self.ipmicmd,
+                                                self._fpc_variant)
+        elif await self.has_ami():
+            self.get_ami_sensor_reading(sensorname)
+        return ()
+
+    async def get_inventory_of_component(self, component):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            await self._collect_tsm_inventory()
+            return await self.oem_inventory_info.get(component, None)
+        if await self.has_imm():
+            return await self.immhandler.get_component_inventory(component)
+        if await self.is_fpc():
+            return await self.smmhandler.get_inventory_of_component(component)
+
+    def get_cmd_type(self, categorie_item, catspec):
+        if self.has_asrock:
+            cmd_type = catspec["command"]["asrock"]
+        elif categorie_item in categorie_items:
+            cmd_type = catspec["command"]["lenovo"]
+        else:
+            cmd_type = catspec["command"]
+
+        return cmd_type
+
+    async def _collect_tsm_inventory(self):
+        self.oem_inventory_info = {}
+        asrock = False
+        if self.has_asrock:
+            asrock = True
+        for catid, catspec in inventory.categories.items():
+            # skip the inventory fields if the system is RS160
+            if asrock and catid not in categorie_items:
+                continue
+            if (catspec.get("workaround_bmc_bug", False)
+                    and catspec["workaround_bmc_bug"](
+                        "ami" if await self.has_ami() else "lenovo")):
+                rsp = None
+                cmd = self.get_cmd_type(catid, catspec)
+                tmp_command = dict(cmd)
+                tmp_command["data"] = list(tmp_command["data"])
+                count = 0
+                for i in range(0x01, 0xff):
+                    tmp_command["data"][-1] = i
+                    try:
+                        partrsp = await self.ipmicmd.raw_command(**tmp_command)
+                        count += 1
+                        if asrock and partrsp["data"][1] == "\xff":
+                            continue
+
+                        if rsp is None:
+                            rsp = partrsp
+                            rsp["data"] = list(rsp["data"])
+                        else:
+                            rsp["data"].extend(partrsp["data"][1:])
+                    except Exception:
+                        break
+                # If we didn't get any response, assume we don't have
+                # this category and go on to the next one
+                if rsp is None:
+                    continue
+                rsp["data"].insert(1, count)
+                rsp["data"] = buffer(bytearray(rsp["data"]))
+            else:
+                try:
+                    cmd = self.get_cmd_type(catid, catspec)
+                    rsp = await self.ipmicmd.raw_command(**cmd)
+                except pygexc.IpmiException:
+                    continue
+            # Parse the response we got
+            try:
+                items = inventory.parse_inventory_category(
+                    catid, rsp, asrock,
+                    countable=catspec.get("countable", True)
+                )
+            except Exception:
+                # If we can't parse an inventory category, ignore it
+                print(traceback.print_exc())
+                continue
+
+            for item in items:
+                try:
+                    # Originally on ThinkServer and SD350 (Kent),
+                    # the DIMM is distinguished by slot,
+                    # the key is the value of slot number (item["index"])
+                    # While on RS160/TS460 the DIMMs is distinguished
+                    # by slot number and channel number,
+                    # the key is the value of the sum of slot number
+                    # and channel number
+                    if asrock and catid == "dimm":
+                        if item["channel_number"] == 1:
+                            key = catspec["idstr"].format(item["index"])
+                        else:
+                            key = catspec["idstr"].format(
+                                item["index"] + item["channel_number"])
+                    else:
+                        key = catspec["idstr"].format(item["index"])
+
+                    del item["index"]
+                    self.oem_inventory_info[key] = item
+                except Exception:
+                    # If we can't parse an inventory item, ignore it
+                    print(traceback.print_exc())
+                    continue
+
+    async def get_leds(self):
+        cmd = 0x02
+        led_set = leds
+        led_set_status = led_status
+
+        asrock = await self.has_asrock()
+        if await self.has_ami():
+            cmd = 0x05
+            led_set = ami_leds
+            led_set_status = ami_led_status
+        elif asrock:
+            cmd = 0x50
+            # because rs160 has different led info with ts460
+            if self.isTS460:
+                led_set = ts460_leds
+            else:
+                led_set = asrock_leds
+            led_set_status = asrock_led_status
+
+        for (name, id_) in led_set.items():
+            try:
+                if asrock:
+                    rsp = await self.ipmicmd.raw_command(netfn=0x3A, command=cmd,
+                                                    data=(0x03, id_, 0x00))
+                    rdata = bytearray(rsp['data'][:])
+                    status = rdata[1]
+                else:
+                    rsp = await self.ipmicmd.raw_command(netfn=0x3A, command=cmd,
+                                                    data=(id_,))
+                    rdata = bytearray(rsp['data'][:])
+                    status = rdata[0]
+
+            except pygexc.IpmiException:
+                continue  # Ignore LEDs we can't retrieve
+            status = led_set_status.get(status,
+                                        led_status_default)
+            yield (name, {'status': status})
+
+    async def set_identify(self, on, duration, blink):
+        if on and not duration and self.is_sd350:
+            await self.ipmicmd.raw_command(netfn=0x3a, command=6, data=(1, 1))
+        elif await self.has_xcc():
+            await self.immhandler.set_identify(on, duration, blink)
+        else:
+            raise pygexc.UnsupportedFunctionality()
+
+    async def process_fru(self, fru, name=None):
+        if fru is None:
+            return fru
+        if await self.has_tsm():
+            fru['oem_parser'] = 'lenovo'
+            # Thinkserver lays out specific interpretation of the
+            # board extra fields
+            try:
+                _, _, wwn1, wwn2, mac1, mac2 = fru['board_extra']
+                if wwn1 not in ('0000000000000000', ''):
+                    fru['WWN 1'] = wwn1.encode('utf-8')
+                if wwn2 not in ('0000000000000000', ''):
+                    fru['WWN 2'] = wwn2.encode('utf-8')
+                if mac1 not in ('00:00:00:00:00:00', ''):
+                    fru['MAC Address 1'] = mac1.encode('utf-8')
+                if mac2 not in ('00:00:00:00:00:00', ''):
+                    fru['MAC Address 2'] = mac2.encode('utf-8')
+            except (AttributeError, KeyError):
+                pass
+            try:
+                # The product_extra field is UUID as the system would present
+                # in DMI.  This is different than the two UUIDs that
+                # it returns for get device and get system uuid...
+                byteguid = fru['product_extra'][0]
+                # It can present itself as claiming to be ASCII when it
+                # is actually raw hex.  As a result it triggers the mechanism
+                # to strip \x00 from the end of text strings.  Work around this
+                # by padding with \x00 to the right if less than 16 long
+                byteguid.extend('\x00' * (16 - len(byteguid)))
+                if byteguid not in ('\x20' * 16, '\x00' * 16, '\xff' * 16):
+                    fru['UUID'] = util.decode_wireformat_uuid(byteguid)
+            except (AttributeError, KeyError, IndexError):
+                pass
+            return fru
+        elif await self.has_imm():
+            fru['oem_parser'] = 'lenovo'
+            try:
+                bextra = fru['board_extra']
+                fru['FRU Number'] = bextra[0]
+                fru['Revision'] = bextra[4]
+                macs = bextra[6]
+                if macs:
+                    macprefix = None
+                    idx = 0
+                    endidx = len(macs) - 5
+                    macprefix = None
+                    while idx < endidx:
+                        currmac = macs[idx:idx + 6]
+                        if not isinstance(currmac, bytearray):
+                            # invalid vpd format, abort attempts to extract
+                            # mac in this way
+                            break
+                        if currmac == b'\x00\x00\x00\x00\x00\x00':
+                            break
+                        # VPD may veer off, detect and break off
+                        if macprefix is None:
+                            macprefix = currmac[:3]
+                        elif currmac[:3] != macprefix:
+                            break
+                        ms = mac_format.format(*currmac)
+                        ifidx = idx / 6 + 1
+                        fru['MAC Address {0}'.format(ifidx)] = ms
+                        idx = idx + 6
+            except (AttributeError, KeyError, IndexError):
+                pass
+            if await self.has_xcc() and name and name.startswith('PSU '):
+                self.immhandler.augment_psu_info(fru, name)
+            if (await self.has_xcc() and 'memory_type' in fru
+                    and fru['memory_type'] == 'Unknown'):
+                await self.immhandler.fetch_dimm(name, fru)
+            return fru
+        elif await self.is_fpc() and await self.is_fpc() != 6:  # SMM variant
+            fru['oem_parser'] = 'lenovo'
+            return await self.smmhandler.process_fru(fru)
+        elif await self.has_asrock():
+            fru['oem_parser'] = 'lenovo'
+            # ASRock RS160 TS460 lays out specific interpretation of the
+            # board extra fields
+            try:
+                mac1 = fru['board_extra']
+                if mac1 not in ('00:00:00:00:00:00', ''):
+                    fru['MAC Address 1'] = mac1.encode('utf-8')
+            except (AttributeError, KeyError):
+                pass
+            return fru
+        else:
+            fru['oem_parser'] = None
+            return fru
+
+    async def has_xcc(self):
+        if self._hasxcc is not None:
+            return self._hasxcc
+        try:
+            bdata = await self.ipmicmd.raw_command(netfn=0x3a, command=0xc1)
+        except pygexc.IpmiException:
+            self._hasxcc = False
+            self._hasimm = False
+            return False
+        if len(bdata['data'][:]) != 3:
+            self._hasimm = False
+            self._hasxcc = False
+            return False
+        rdata = bytearray(bdata['data'][:])
+        self._hasxcc = rdata[1] & 16 == 16
+        if self._hasxcc:
+            # For now, have imm calls go to xcc, since they are providing same
+            # interface.  Longer term the hope is that all the Lenovo
+            # stuff will branch at init, and not have conditionals
+            # in all the functions
+            self._hasimm = self._hasxcc
+        return self._hasxcc
+
+    async def has_imm(self):
+        if self._hasimm is not None:
+            return self._hasimm
+        try:
+            bdata = await self.ipmicmd.raw_command(netfn=0x3a, command=0xc1)
+        except pygexc.IpmiException:
+            self._hasimm = False
+            return False
+        if len(bdata['data'][:]) != 3:
+            self._hasimm = False
+            return False
+        rdata = bytearray(bdata['data'][:])
+        self._hasimm = (rdata[1] & 1 == 1) or (rdata[1] & 16 == 16)
+        return self._hasimm
+
+    async def has_ami(self):
+        """True if this particular server is AMI based lenovo server
+
+        """
+        if(self.oemid['manufacturer_id'] == 19046
+                and self.oemid['product_id'] == 13616):
+            try:
+                rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0x80)
+            except pygexc.IpmiException as ie:
+                if ie.ipmicode == 193:
+                    return False
+                raise
+            rdata = bytearray(rsp['data'][:])
+            if rdata[0] in range(5):
+                return True
+            else:
+                return False
+        return False
+
+    async def get_oem_firmware(self, bmcver, components, category):
+        if await self.has_tsm() or await self.has_ami() or await self.has_asrock():
+            command = firmware.get_categories()["firmware"]
+            fw_cmd = self.get_cmd_type("firmware", command)
+            rsp = await self.ipmicmd.raw_command(**fw_cmd)
+
+            # the newest Lenovo ThinkServer versions are returning Bios version
+            # numbers through another command
+            bios_versions = None
+            if await self.has_tsm() or await self.has_asrock():
+                bios_command = firmware.get_categories()["bios_version"]
+                bios_cmd = self.get_cmd_type("bios_version", bios_command)
+                bios_rsp = await self.ipmicmd.raw_command(**bios_cmd)
+                if await self.has_asrock():
+                    bios_versions = bios_rsp['data']
+                else:
+                    bios_versions = bios_command["parser"](bios_rsp['data'])
+            # pass bios versions to firmware parser
+            for x in command["parser"](rsp["data"],
+                                     bios_versions,
+                                     await self.has_asrock()):
+                yield x
+        elif await self.has_imm():
+            async for x in self.immhandler.get_firmware_inventory(bmcver, components, category):
+                yield x
+        elif await self.is_fpc():
+            async for x in nextscale.get_fpc_firmware(bmcver, self.ipmicmd,
+                                                     self._fpc_variant):
+                yield x
+        elif self.has_tsma:
+            async for x in self.tsmahandler.get_firmware_inventory(
+                components, raisebypass=False, ipmicmd=self.ipmicmd):
+                yield x
+        async for x in super(OEMHandler, self).get_oem_firmware(bmcver, components, category):
+            yield x
+
+    async def get_diagnostic_data(self, savefile, progress, autosuffix=False):
+        if await self.has_xcc():
+            return await self.immhandler.get_diagnostic_data(savefile, progress,
+                                                       autosuffix)
+        if await self.is_fpc():
+            return await self.smmhandler.get_diagnostic_data(savefile, progress,
+                                                       autosuffix,
+                                                       self._fpc_variant)
+        if self.has_tsma:
+            return await self.tsmahandler.get_diagnostic_data(savefile, progress,
+                                                        autosuffix)
+
+    async def get_oem_capping_enabled(self):
+        if await self.has_tsm():
+            rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0x1b,
+                                            data=(3,))
+            # disabled
+            if rsp['data'][0] == '\x00':
+                return False
+            # enabled
+            else:
+                return True
+
+    async def set_oem_capping_enabled(self, enable):
+        """Set PSU based power capping
+
+        :param enable: True for enable and False for disable
+        """
+        # 1 - Enable power capping(default)
+        if enable:
+            statecode = 1
+        # 0 - Disable power capping
+        else:
+            statecode = 0
+        if await self.has_tsm():
+            await self.ipmicmd.raw_command(netfn=0x3a, command=0x1a,
+                                      data=(3, statecode))
+            return True
+
+    async def get_oem_remote_kvm_available(self):
+        if await self.has_tsm():
+            rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0x13)
+            return rsp['data'][0] == 0
+        return False
+
+    async def _restart_dns(self):
+        if await self.has_tsm():
+            await self.ipmicmd.raw_command(netfn=0x32, command=0x6c, data=(7, 0))
+
+    async def get_oem_domain_name(self):
+        if await self.has_tsm():
+            name = ''
+            for i in range(1, 5):
+                rsp = await self.ipmicmd.raw_command(netfn=0x32, command=0x6b,
+                                                data=(4, i))
+                name += rsp['data'][:]
+            return name.rstrip('\x00')
+        elif await self.is_fpc():
+            return await self.smmhandler.get_domain()
+
+    async def set_oem_domain_name(self, name):
+        if await self.has_tsm():
+            # set the domain name length
+            data = [3, 0, 0, 0, 0, len(name)]
+            await self.ipmicmd.raw_command(netfn=0x32, command=0x6c, data=data)
+
+            # set the domain name content
+            name = name.ljust(256, "\x00")
+            for i in range(0, 4):
+                data = [4, i + 1]
+                offset = i * 64
+                data.extend([ord(x) for x in name[offset:offset + 64]])
+                await self.ipmicmd.raw_command(netfn=0x32, command=0x6c, data=data)
+
+            await self._restart_dns()
+            return
+        elif await self.is_fpc():
+            await self.smmhandler.set_domain(name)
+
+    async def set_hostname(self, hostname):
+        if await self.has_xcc():
+            return await self.immhandler.set_hostname(hostname)
+        elif await self.is_fpc():
+            return await self.smmhandler.set_hostname(hostname)
+        return await super(OEMHandler, self).set_hostname(hostname)
+
+    async def get_hostname(self):
+        if await self.has_xcc():
+            return await self.immhandler.get_hostname()
+        elif await self.is_fpc():
+            return await self.smmhandler.get_hostname()
+        return await super(OEMHandler, self).get_hostname()
+
+    """ Gets a remote console launcher for a Lenovo ThinkServer.
+
+    Returns a tuple: (content type, launcher) or None if the launcher could
+    not be retrieved."""
+    async def _get_ts_remote_console(self, bmc, username, password):
+        # We don't establish non-secure connections without checking
+        # certificates
+        if not self.ipmicmd.certverify:
+            return
+        conn = wc.WebConnection(bmc, 443,
+                                       verifycallback=self.ipmicmd.certverify)
+        conn.connect()
+        params = urlencode({
+            'WEBVAR_USERNAME': username,
+            'WEBVAR_PASSWORD': password
+        })
+        headers = {
+            'Connection': 'keep-alive'
+        }
+        rsp = await conn.grab_response_with_status('/rpc/WEBSES/create.asp', params, headers=headers)
+
+        if rsp[1] == 200:
+            conn.cookies = {}
+            body = rsp[0].decode().split('\n')
+            session_line = None
+            for line in body:
+                if 'SESSION_COOKIE' in line:
+                    session_line = line
+            if session_line is None:
+                return
+
+            session_id = session_line.split('\'')[3]
+            # Usually happens when maximum number of sessions is reached
+            if session_id == 'Failure_Session_Creation':
+                return
+
+            headers = {
+                'Connection': 'keep-alive',
+                'Cookie': 'SessionCookie=' + session_id,
+            }
+            rsp = await conn.grab_response_with_status('/Java/jviewer.jnlp?EXTRNIP=' + bmc + '&JNLPSTR=JViewer', headers=headers)
+            if rsp[1] == 200:
+                return rsp[2]['Content-Type'], base64.b64encode(
+                    rsp[0])
+
+    async def get_graphical_console(self):
+        return await self._get_ts_remote_console(self.ipmicmd.bmc,
+                                                 self.ipmicmd.ipmi_session.userid,
+                                                 self.ipmicmd.ipmi_session.password)
+
+    async def add_extra_net_configuration(self, netdata, channel=None):
+        if await self.has_tsm():
+            ipv6_addr = await self.ipmicmd.raw_command(
+                netfn=0x0c, command=0x02,
+                data=(0x01, 0xc5, 0x00, 0x00))["data"][1:]
+            if not ipv6_addr:
+                return
+            rspdata = await self.ipmicmd.raw_command(
+                netfn=0xc, command=0x02,
+                data=(0x1, 0xc6, 0, 0))['data']
+            ipv6_prefix_ba = bytearray(rspdata)
+            ipv6_prefix = ipv6_prefix_ba[1]
+
+            if hasattr(socket, 'inet_ntop'):
+                ipv6str = socket.inet_ntop(socket.AF_INET6, ipv6_addr)
+            else:
+                # fall back to a dumber, but more universal formatter
+                ipv6str = binascii.b2a_hex(ipv6_addr)
+                ipv6str = ':'.join([ipv6str[x:x + 4] for x in range(0, 32, 4)])
+            netdata['ipv6_addresses'] = [
+                '{0}/{1}'.format(ipv6str, ipv6_prefix)]
+
+    async def has_megarac(self):
+        # if there is functionality that is the same for tsm or generic
+        # megarac, then this is appropriate.  If there's a TSM specific
+        # preferred, use has_tsm first
+        if self._has_megarac is not None:
+            return self._has_megarac
+        self._has_megarac = False
+        try:
+            rsp = await self.ipmicmd.raw_command(netfn=0x32, command=0x7e)
+            # We don't have a handy classify-only, so use get sel policy
+            # rsp should have a length of one, and be either '\x00' or '\x01'
+            if len(rsp['data'][:]) == 1 and rsp['data'][0] in ('\x00', '\x01'):
+                self._has_megarac = True
+        except pygexc.IpmiException as ie:
+            if ie.ipmicode == 0:
+                # if it's a generic IpmiException rather than an error code
+                # from the BMC, then this is a deeper problem than just an
+                # invalid command or command length or similar
+                raise
+        return self._has_megarac
+
+    async def set_alert_ipv6_destination(self, ip, destination, channel):
+        if await self.has_megarac():
+            ethidx = await self._megarac_eth_index()
+            reqdata = bytearray([channel, 193, destination, ethidx, 0])
+            parsedip = socket.inet_pton(socket.AF_INET6, ip)
+            reqdata.extend(parsedip)
+            reqdata.extend('\x00\x00\x00\x00\x00\x00')
+            await self.ipmicmd.raw_command(netfn=0xc, command=1, data=reqdata)
+            return True
+        return False
+
+    async def _set_short_ris_string(self, selector, value):
+        data = (1, selector, 0) + struct.unpack('{0}B'.format(len(value)),
+                                                value)
+        await self.ipmicmd.raw_command(netfn=0x32, command=0x9f, data=data)
+
+    async def _set_ris_string(self, selector, value):
+        if len(value) > 256:
+            raise pygexc.UnsupportedFunctionality(
+                'Value exceeds 256 characters: {0}'.format(value))
+        padded = value + (256 - len(value)) * '\x00'
+        padded = list(struct.unpack('256B', padded))
+        # 8 = RIS, 4 = hd, 2 = fd, 1 = cd
+        try:  # try and clear in-progress if left incomplete
+            await self.ipmicmd.raw_command(netfn=0x32, command=0x9f,
+                                      data=(1, selector, 0, 0))
+        except pygexc.IpmiException:
+            pass
+        # set in-progress
+        await self.ipmicmd.raw_command(netfn=0x32, command=0x9f,
+                                  data=(1, selector, 0, 1))
+        # now do the set
+        for x in range(0, 256, 64):
+            currdata = padded[x:x + 64]
+            currchunk = x // 64 + 1
+            cmddata = [1, selector, currchunk] + currdata
+            await self.ipmicmd.raw_command(netfn=0x32, command=0x9f, data=cmddata)
+        # unset in-progress
+        await self.ipmicmd.raw_command(netfn=0x32, command=0x9f,
+                                  data=(1, selector, 0, 0))
+
+    async def _megarac_fetch_image_shortnames(self):
+        rsp = await self.ipmicmd.raw_command(netfn=0x32, command=0xd8,
+                                        data=(7, 1, 0))
+        imgnames = rsp['data'][1:]
+        shortnames = []
+        for idx in range(0, len(imgnames), 22):
+            shortnames.append(imgnames[idx + 2:idx + 22].rstrip('\0'))
+        return shortnames
+
+    async def _megarac_media_waitforready(self, imagename):
+        # first, we have, sadly, a 10 second grace period for some invisible
+        # async activity to get far enough long to monitor
+        await self.ipmicmd.ipmi_session.pause(10)
+        risenabled = '\x00'
+        mountok = '\xff'
+        while risenabled != '\x01':
+            risenabled = (await self.ipmicmd.raw_command(
+                netfn=0x32, command=0x9e, data=(8, 10)))['data'][2]
+        while mountok == '\xff':
+            mountok = (await self.ipmicmd.raw_command(
+                netfn=0x32, command=0x9e, data=(1, 8)))['data'][2]
+        targshortname = _megarac_abbrev_image(imagename)
+        shortnames = await self._megarac_fetch_image_shortnames()
+        while targshortname not in shortnames:
+            self.ipmicmd.wait_for_rsp(1)
+            shortnames = await self._megarac_fetch_image_shortnames()
+        self.ipmicmd.ipmi_session.pause(10)
+        try:
+            await self.ipmicmd.raw_command(netfn=0x32, command=0xa0, data=(1, 0))
+            await self.ipmicmd.ipmi_session.pause(5)
+        except pygexc.IpmiException:
+            pass
+
+    async def _megarac_attach_media(self, proto, username, password, imagename,
+                              domain, path, host):
+        # First we must ensure that the RIS is actually enabled
+        await self.ipmicmd.raw_command(netfn=0x32, command=0x9f, data=(8, 10, 0, 1))
+        if username is not None:
+            await self._set_ris_string(3, username)
+        if password is not None:
+            await self._set_short_ris_string(4, password)
+        if domain is not None:
+            await self._set_ris_string(6, domain)
+        await self._set_ris_string(1, path)
+        ip = util.get_ipv4(host)[0]
+        await self._set_short_ris_string(2, ip)
+        await self._set_short_ris_string(5, proto)
+        # now to restart RIS to have changes take effect...
+        await self.ipmicmd.raw_command(netfn=0x32, command=0x9f, data=(8, 11))
+        # now to kick off the requested mount
+        await self._megarac_media_waitforready(imagename)
+        await self._set_ris_string(0, imagename)
+        await self.ipmicmd.raw_command(netfn=0x32, command=0xa0,
+                                  data=(1, 1))
+
+    async def attach_remote_media(self, url, username, password):
+        if await self.has_imm():
+            await self.immhandler.attach_remote_media(url, username, password)
+        elif self.has_tsma:
+            return await self.tsmahandler.attach_remote_media(
+                url, username, password, None)
+        elif await self.has_megarac():
+            proto, host, path = util.urlsplit(url)
+            if proto == 'smb':
+                proto = 'cifs'
+            domain = None
+            path, imagename = path.rsplit('/', 1)
+            if username is not None and '@' in username:
+                username, domain = username.split('@', 1)
+            elif username is not None and '\\' in username:
+                domain, username = username.split('\\', 1)
+            try:
+                await self._megarac_attach_media(proto, username, password,
+                                           imagename, domain, path, host)
+            except pygexc.IpmiException as ie:
+                if ie.ipmicode in (0x92, 0x99):
+                    # if starting from scratch, this can happen...
+                    await self._megarac_attach_media(proto, username, password,
+                                               imagename, domain, path, host)
+                else:
+                    raise
+
+    async def get_update_status(self):
+        if await self.is_fpc() or self.has_tsma:
+            return "ready"
+        if await self.has_xcc():
+            return await self.immhandler.get_update_status()
+        return await super(OEMHandler, self).get_update_status()
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        if await self.has_xcc():
+            return await self.immhandler.update_firmware(
+                filename, data=data, progress=progress, bank=bank)
+        if await self.is_fpc():
+            return await self.smmhandler.update_firmware(
+                filename, data=data, progress=progress, bank=bank)
+        if self.has_tsma:
+            return await self.tsmahandler.update_firmware(
+                filename, data=data, progress=progress, bank=bank)
+        return await super(OEMHandler, self).update_firmware(filename, data=data,
+                                                       progress=progress,
+                                                       bank=bank)
+
+    async def get_description(self):
+        if await self.has_xcc():
+            return await self.immhandler.get_description()
+        if await self.is_fpc():
+            return {'height': self._fpc_variant & 0xf, 'slot': 0}
+        return await super(OEMHandler, self).get_description()
+
+    async def get_extended_bmc_configuration(self):
+        if await self.has_xcc():
+            return await self.immhandler.get_extended_bmc_configuration()
+        return await super(OEMHandler, self).get_extended_bmc_configuration()
+
+    async def get_bmc_configuration(self):
+        if await self.has_xcc():
+            return await self.immhandler.get_bmc_configuration()
+        if await self.is_fpc():
+            return await self.smmhandler.get_bmc_configuration(self._fpc_variant)
+        if self.has_tsma:
+            return await self.tsmahandler.get_bmc_configuration()
+        return await super(OEMHandler, self).get_bmc_configuration()
+
+    async def set_bmc_configuration(self, changeset):
+        if await self.has_xcc():
+            return await self.immhandler.set_bmc_configuration(changeset)
+        if await self.is_fpc():
+            return await self.smmhandler.set_bmc_configuration(
+                changeset, self._fpc_variant)
+        if self.has_tsma:
+            return await self.tsmahandler.set_bmc_configuration(
+                changeset)
+        return await super(OEMHandler, self).set_bmc_configuration(changeset)
+
+    async def get_system_configuration(self, hideadvanced):
+        if await self.has_imm() or await self.has_xcc():
+            return await self.immhandler.get_system_configuration(hideadvanced)
+        if self.has_tsma:
+            return await self.tsmahandler.get_uefi_configuration(hideadvanced)
+        return await super(OEMHandler, self).get_system_configuration(hideadvanced)
+
+    async def set_system_configuration(self, changeset):
+        if await self.has_imm() or await self.has_xcc():
+            return await self.immhandler.set_system_configuration(changeset)
+        if self.has_tsma:
+            return await self.tsmahandler.set_uefi_configuration(changeset)
+        return await super(OEMHandler, self).set_system_configuration(changeset)
+
+    async def clear_bmc_configuration(self):
+        if await self.has_xcc():
+            return await self.immhandler.clear_bmc_configuration()
+        elif await self.is_fpc():
+            return await self.smmhandler.clear_bmc_configuration()
+        elif self.has_tsma:
+            return await self.tsmahandler.clear_bmc_configuration()
+        return await super(OEMHandler, self).clear_system_configuration()
+
+    async def clear_system_configuration(self):
+        if await self.has_xcc():
+            return await self.immhandler.clear_system_configuration()
+        if self.has_tsma:
+            return await self.tsmahandler.clear_uefi_configuration()
+        return await super(OEMHandler, self).clear_system_configuration()
+
+    async def detach_remote_media(self):
+        if await self.has_imm():
+            await self.immhandler.detach_remote_media()
+        elif self.has_tsma:
+            await self.tsmahandler.detach_remote_media()
+        elif await self.has_megarac():
+            await self.ipmicmd.raw_command(
+                netfn=0x32, command=0x9f, data=(8, 10, 0, 0))
+            await self.ipmicmd.raw_command(netfn=0x32, command=0x9f, data=(8, 11))
+
+    async def upload_media(self, filename, progress, data):
+        if await self.has_xcc() or await self.has_imm():
+            return await self.immhandler.upload_media(filename, progress, data)
+        return await super(OEMHandler, self).upload_media(filename, progress, data)
+
+    async def list_media(self):
+        if await self.has_xcc() or await self.has_imm():
+            async for x in self.immhandler.list_media():
+                yield x
+            return
+        if self.has_tsma:
+            async for x in self.tsmahandler.list_media():
+                yield x
+            return
+        async for x in super(OEMHandler, self).list_media():
+            yield x
+
+    async def get_health(self, summary):
+        if await self.has_xcc():
+            return await self.immhandler.get_health(summary)
+        return await super(OEMHandler, self).get_health(summary)
+
+    async def get_licenses(self):
+        if await self.has_xcc():
+            async for x in self.immhandler.get_licenses():
+                yield x
+            return
+        async for x in super(OEMHandler, self).get_licenses():
+            yield x
+
+    async def get_user_expiration(self, uid):
+        if await self.has_xcc():
+            return await self.immhandler.get_user_expiration(uid)
+        return None
+
+    async def delete_license(self, name):
+        if await self.has_xcc():
+            return await self.immhandler.delete_license(name)
+        return await super(OEMHandler, self).delete_license(name)
+
+    async def save_licenses(self, directory):
+        if await self.has_xcc():
+            async for x in self.immhandler.save_licenses(directory):
+                yield x
+            return
+        async for x in super(OEMHandler, self).save_licenses(directory):
+            yield x
+
+    async def apply_license(self, filename, progress=None, data=None):
+        if await self.has_xcc():
+            async for x in self.immhandler.apply_license(filename, progress, data):
+                yield x
+            return
+        async for x in super(OEMHandler, self).apply_license(filename, progress, data):
+            yield x
+
+    async def set_oem_extended_privilleges(self, uid):
+        """Set user extended privillege as 'KVM & VMedia Allowed'
+
+        |KVM & VMedia Not Allowed	0x00 0x00 0x00 0x00
+        |KVM Only Allowed	0x01 0x00 0x00 0x00
+        |VMedia Only Allowed	0x02  0x00 0x00 0x00
+        |KVM & VMedia Allowed	0x03 0x00 0x00 0x00
+
+        :param uid: User ID.
+        """
+        if await self.has_tsm():
+            await self.ipmicmd.raw_command(netfn=0x32, command=0xa3, data=(
+                uid, 0x03, 0x00, 0x00, 0x00))
+            return True
+        return False
+
+    async def get_user_privilege_level(self, uid):
+        if await self.has_xcc():
+            return await self.immhandler.get_user_privilege_level(uid)
+        return None
+
+    async def set_user_access(self, uid, channel, callback, link_auth, ipmi_msg, privilege_level):
+        if await self.has_xcc():
+            await self.immhandler.set_user_access(uid, privilege_level)
+
+    async def process_zero_fru(self, zerofru):
+        if (self.oemid['manufacturer_id'] == 19046
+                and self.oemid['product_id'] == 13616):
+            # Currently SD350 FRU UUID is synchronized with the Device UUID.
+            # Need to change to System UUID in future.
+            # Since the IPMI get device uuid matches SMBIOS,
+            # no need to decode it.
+            guiddata = await self.ipmicmd.raw_command(netfn=6, command=0x8)
+            if 'error' not in guiddata:
+                zerofru['UUID'] = util.decode_wireformat_uuid(
+                    guiddata['data'], True)
+        else:
+            # It is expected that a manufacturer matches SMBIOS to IPMI
+            # get system uuid return data.  If a manufacturer does not
+            # do so, they should handle either deletion or fixup in the
+            # OEM processing pass.  Code optimistically assumes that if
+            # data is returned, than the vendor is properly using it.
+
+            guiddata = await self.ipmicmd.raw_command(netfn=6, command=0x37)
+            if 'error' not in guiddata:
+                if (self.oemid['manufacturer_id'] == 19046
+                        and (self.oemid['product_id'] == 1182
+                             or self.oemid['product_id'] == 1184)):
+                    # The manufacturer (Asrockrack) of RS160/TS460
+                    # matches SMBIOS
+                    # to IPMI get system uuid return data,
+                    # no need to decode it.
+                    zerofru['UUID'] = util.decode_wireformat_uuid(
+                        guiddata['data'], True)
+                else:
+                    zerofru['UUID'] = util.decode_wireformat_uuid(
+                        guiddata['data'])
+        if await self.is_fpc():
+            await self.smmhandler.augment_zerofru(zerofru, self._fpc_variant)
+        return await self.process_fru(zerofru)
+
+    async def get_ami_sensor_reading(self, sensorname):
+        """Get an OEM sensor
+
+        If software wants to model some OEM behavior as a 'sensor' without
+        doing SDR, this hook provides that ability.  It should mimic
+        the behavior of 'get_sensor_reading' in command.py.
+        """
+        async for sensor in self.get_sensor_data():
+            if sensor.name == sensorname:
+                return sensor
+
+    async def get_ami_sensor_descriptions(self):
+        """Get list of OEM sensor names and types
+
+        Iterate over dicts describing a label and type for OEM 'sensors'.  This
+        should mimic the behavior of the get_sensor_descriptions function
+        in command.py.
+        """
+        if await self.has_ami():
+            energy_sensor = energy.Energy(self.ipmicmd)
+            async for sensor in energy_sensor.get_energy_sensor():
+                yield {'name': sensor.name,
+                       'type': sensor.type}
+
+    async def get_ami_sensor_data(self):
+        """Get OEM sensor data
+
+        Iterate through all OEM 'sensors' and return data as if they were
+        normal sensors.  This should mimic the behavior of the get_sensor_data
+        function in command.py.
+        """
+        if await self.has_ami():
+            energy_sensor = energy.Energy(self.ipmicmd)
+            async for sensor in energy_sensor.get_energy_sensor():
+                yield sensor
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/imm.py b/confluent_server/aiohmi/ipmi/oem/lenovo/imm.py
new file mode 100644
index 00000000..02b58260
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/imm.py
@@ -0,0 +1,2648 @@
+# coding=utf8
+# Copyright 2016-2023 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import base64
+import binascii
+from datetime import datetime
+import errno
+import fnmatch
+import json
+import math
+import os.path
+import random
+import re
+import socket
+import struct
+import weakref
+
+import six
+import zipfile
+
+import aiohmi.constants as pygconst
+import aiohmi.exceptions as pygexc
+import aiohmi.ipmi.oem.lenovo.config as config
+import aiohmi.ipmi.oem.lenovo.energy as energy
+import aiohmi.ipmi.private.session as ipmisession
+import aiohmi.ipmi.private.util as util
+from aiohmi.ipmi import sdr
+import aiohmi.media as media
+import aiohmi.storage as storage
+from aiohmi.util.parse import parse_time
+import aiohmi.util.webclient as webclient
+
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+    def set_identify(self, on, duration, blink):
+        if blink:
+            self.grab_redfish_response_with_status(
+                '/redfish/v1/Systems/1',
+                {'IndicatorLED': 'Blinking'},
+                method='PATCH')
+            raise pygexc.BypassGenericBehavior()
+
+
+
+numregex = re.compile('([0-9]+)')
+funtypes = {
+    0: 'RAID Controller',
+    1: 'Ethernet',
+    2: 'Fibre Channel',
+    3: 'Infiniband',
+    4: 'GPU',
+    10: 'NVMe Controller',
+    12: 'Fabric Controller',
+}
+
+
+def naturalize_string(key):
+    """Analyzes string in a human way to enable natural sort
+
+    :param key: string for the split
+    :returns: A structure that can be consumed by 'sorted'
+    """
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(numregex, key)]
+
+
+def natural_sort(iterable):
+    """Return a sort using natural sort if possible
+
+    :param iterable:
+    :return:
+    """
+    try:
+        return sorted(iterable, key=naturalize_string)
+    except TypeError:
+        # The natural sort attempt failed, fallback to ascii sort
+        return sorted(iterable)
+
+
+def fixup_uuid(uuidprop):
+    baduuid = ''.join(uuidprop.split())
+    uuidprefix = (baduuid[:8], baduuid[8:12], baduuid[12:16])
+    a = struct.pack('<IHH', *[int(x, 16) for x in uuidprefix])
+    a = binascii.hexlify(a)
+    if not isinstance(a, str):
+        a = a.decode('utf-8')
+    uuid = (a[:8], a[8:12], a[12:16], baduuid[16:20], baduuid[20:])
+    return '-'.join(uuid).upper()
+
+
+def fixup_str(propstr):
+    if propstr is None:
+        return ''
+    return ''.join([chr(int(c, 16)) for c in propstr.split()]).strip(
+        ' \xff\x00')
+
+
+def str_to_size(sizestr):
+    if 'GB' in sizestr:
+        sizestr = sizestr.replace('GB', '')
+        sizestr = int(float(sizestr) * 1000)
+    elif 'GiB' in sizestr:
+        sizestr = sizestr.replace('GiB', '')
+        sizestr = int(float(sizestr) * 1024)
+    elif 'TB' in sizestr:
+        sizestr = sizestr.replace('TB', '')
+        sizestr = int(float(sizestr) * 1000 * 1000)
+    elif 'TiB' in sizestr:
+        sizestr = sizestr.replace('TiB', '')
+        sizestr = int(float(sizestr) * 1024 * 1024)
+    return sizestr
+
+
+class IMMClient(object):
+    logouturl = '/data/logout'
+    bmcname = 'IMM'
+    ADP_URL = '/designs/imm/dataproviders/imm_adapters.php'
+    ADP_NAME = 'adapter.adapterName'
+    ADP_FUN = 'adapter.functions'
+    ADP_FU_URL = None
+    ADP_LABEL = 'adapter.connectorLabel'
+    ADP_SLOTNO = 'adapter.slotNo'
+    ADP_OOB = 'adapter.oobSupported'
+    ADP_PARTNUM = 'vpd.partNo'
+    ADP_SERIALNO = 'vpd.serialNo'
+    ADP_VENID = 'generic.vendorId'
+    ADP_SUBVENID = 'generic.subVendor'
+    ADP_DEVID = 'generic.devId'
+    ADP_SUBDEVID = 'generic.subDevId'
+    ADP_FRU = 'vpd.cardSKU'
+    BUSNO = 'generic.busNo'
+    PORTS = 'network.pPorts'
+    DEVNO = 'generic.devNo'
+
+    def __init__(self, ipmicmd):
+        self.weblogging = False
+        self.ipmicmd = weakref.proxy(ipmicmd)
+        self.updating = False
+        self.imm = ipmicmd.bmc
+        srv = self.imm
+        if ':' in srv:
+            srv = '[{0}]'.format(srv)
+        self.adp_referer = 'https://imm/designs/imm/index-console.php'
+        if ipmicmd.ipmi_session.password:
+            self.username = ipmicmd.ipmi_session.userid.decode('utf-8')
+            self.password = ipmicmd.ipmi_session.password.decode('utf-8')
+        self._wc = None  # The webclient shall be initiated on demand
+        self._energymanager = None
+        self.datacache = {}
+        self._keepalivesession = None
+        self.fwc = None
+        self.fwo = None
+        self.fwovintage = None
+
+    @staticmethod
+    def _parse_builddate(strval):
+        if not isinstance(strval, str) and isinstance(strval, bytes):
+            strval = strval.decode('utf-8')
+        try:
+            return datetime.strptime(strval, '%Y/%m/%d %H:%M:%S')
+        except ValueError:
+            pass
+        try:
+            return datetime.strptime(strval, '%Y-%m-%d %H:%M:%S')
+        except ValueError:
+            pass
+        try:
+            return datetime.strptime(strval, '%Y/%m/%d')
+        except ValueError:
+            pass
+        try:
+            return datetime.strptime(strval, '%m/%d/%Y')
+        except ValueError:
+            pass
+        try:
+            return datetime.strptime(strval, '%Y-%m-%d')
+        except ValueError:
+            pass
+        try:
+            return datetime.strptime(strval, '%m %d %Y')
+        except ValueError:
+            pass
+        return None
+
+    @classmethod
+    def parse_imm_buildinfo(cls, buildinfo):
+        buildid = bytes(buildinfo[:9]).rstrip(b' \x00')
+        if not isinstance(buildid, str):
+            buildid = buildid.decode('utf-8')
+        bdt = b' '.join(bytes(buildinfo[9:]).replace(b'\x00', b' ').split())
+        bdate = cls._parse_builddate(bdt)
+        return buildid, bdate
+
+    @classmethod
+    def datefromprop(cls, propstr):
+        if propstr is None:
+            return None
+        return cls._parse_builddate(propstr)
+
+    async def get_system_configuration(self, hideadvanced=True, fetchimm=False):
+        if not self.fwc:
+            self.fwc = config.LenovoFirmwareConfig(self)
+        try:
+            self.fwo = await self.fwc.get_fw_options(fetchimm=fetchimm)
+        except Exception:
+            raise Exception('%s failed to retrieve UEFI configuration'
+                            % self.bmcname)
+        self.fwovintage = util._monotonic_time()
+        retcfg = {}
+        for opt in self.fwo:
+            if 'MegaRAIDConfigurationTool' in opt:
+                # Suppress the Avago configuration to be consistent with
+                # other tools.
+                continue
+            if (hideadvanced and self.fwo[opt]['lenovo_protect']
+                    or self.fwo[opt]['hidden']):
+                # Do not enumerate hidden settings
+                continue
+            retcfg[opt] = {}
+            retcfg[opt]['value'] = self.fwo[opt]['current']
+            retcfg[opt]['default'] = self.fwo[opt]['default']
+            retcfg[opt]['help'] = self.fwo[opt]['help']
+            retcfg[opt]['possible'] = self.fwo[opt]['possible']
+            retcfg[opt]['sortid'] = self.fwo[opt]['sortid']
+        return retcfg
+
+    async def set_system_configuration(self, changeset):
+        if not self.fwc:
+            self.fwc = config.LenovoFirmwareConfig(self)
+        fetchimm = False
+        if not self.fwo or util._monotonic_time() - self.fwovintage > 30:
+            self.fwo = await self.fwc.get_fw_options(fetchimm=fetchimm)
+            self.fwovintage = util._monotonic_time()
+        for key in list(changeset):
+            if key not in self.fwo:
+                found = False
+                for rkey in self.fwo:
+                    if fnmatch.fnmatch(rkey.lower(), key.lower()):
+                        changeset[rkey] = changeset[key]
+                        found = True
+                    elif self.fwo[rkey].get('alias', None) != rkey:
+                        calias = self.fwo[rkey]['alias']
+                        if fnmatch.fnmatch(calias.lower(), key.lower()):
+                            changeset[rkey] = changeset[key]
+                            found = True
+                if not found and not fetchimm:
+                    fetchimm = True
+                    self.fwo = await self.fwc.get_fw_options(fetchimm=fetchimm)
+                    if key in self.fwo:
+                        continue
+                    else:
+                        found = False
+                        for rkey in self.fwo:
+                            if fnmatch.fnmatch(rkey.lower(), key.lower()):
+                                changeset[rkey] = changeset[key]
+                                found = True
+                            elif self.fwo[rkey].get('alias', None) != rkey:
+                                calias = self.fwo[rkey]['alias']
+                                if fnmatch.fnmatch(
+                                        calias.lower(), key.lower()):
+                                    changeset[rkey] = changeset[key]
+                                    found = True
+                if found:
+                    del changeset[key]
+                else:
+                    raise pygexc.InvalidParameterValue(
+                        '{0} not a known setting'.format(key))
+        self.merge_changeset(changeset)
+        if changeset:
+            try:
+                await self.fwc.set_fw_options(self.fwo)
+            finally:
+                self.fwo = None
+                self.fwovintage = 0
+
+    def merge_changeset(self, changeset):
+        for key in changeset:
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            newvalue = changeset[key]['value']
+            if self.fwo[key]['is_list'] and not isinstance(newvalue, list):
+                if '=' in newvalue:
+                    # ASU set a precedent of = delimited settings
+                    # for now, honor that delimiter as well
+                    newvalues = newvalue.split('=')
+                else:
+                    newvalues = newvalue.split(',')
+            else:
+                newvalues = [newvalue]
+            newnewvalues = []
+            for newvalue in newvalues:
+                newv = re.sub(r'\s+', ' ', newvalue)
+                if (self.fwo[key]['possible']
+                        and newvalue not in self.fwo[key]['possible']):
+                    candlist = []
+                    for candidate in self.fwo[key]['possible']:
+                        candid = re.sub(r'\s+', ' ', candidate)
+                        if newv.lower().startswith(candid.lower()):
+                            newvalue = candidate
+                            break
+                        if candid.lower().startswith(newv.lower()):
+                            candlist.append(candidate)
+                    else:
+                        if len(candlist) == 1:
+                            newvalue = candlist[0]
+                        else:
+                            raise pygexc.InvalidParameterValue(
+                                '{0} is not a valid value for {1} '
+                                '({2})'.format(
+                                    newvalue, key,
+                                    ','.join(self.fwo[key]['possible'])))
+                elif self.fwo[key]['validexpression']:
+                    if not re.match(self.fwo[key]['validexpression'], newvalue):
+                        raise pygexc.InvalidParameterValue(
+                            '"{0}" does not match expression "{1}"'.format(
+                                newvalue, self.fwo[key]['validexpression']))
+                newnewvalues.append(newvalue)
+            if len(newnewvalues) == 1:
+                self.fwo[key]['new_value'] = newnewvalues[0]
+            else:
+                self.fwo[key]['new_value'] = newnewvalues
+
+    async def clear_bmc_configuration(self):
+        await self.ipmicmd.raw_command(0x2e, 0xcc,
+                                  data=(0x5e, 0x2b, 0, 0xa, 1, 0xff, 0, 0, 0))
+
+    async def set_property(self, propname, value):
+        if not isinstance(value, int) or value > 255:
+            raise Exception('Unsupported property value')
+        propname = propname.encode('utf-8')
+        proplen = len(propname) | 0b10000000
+        valuelen = 0x11  # The value is always one byte, for now
+        cmdlen = len(propname) + 4  # the flags byte, two tlv bytes, and value
+        cdata = bytearray([3, 0, cmdlen, 1, proplen]) + propname
+        cdata += bytearray([valuelen, value])
+        rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0xc4, data=cdata)
+        rsp['data'] = bytearray(rsp['data'])
+        if rsp['data'][0] != 0:
+            raise Exception('Unknown response setting property: {0}'.format(
+                rsp['data'][0]))
+
+    async def get_property(self, propname):
+        propname = propname.encode('utf-8')
+        proplen = len(propname) | 0b10000000
+        cmdlen = len(propname) + 1
+        cdata = bytearray([0, 0, cmdlen, proplen]) + propname
+        rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0xc4, data=cdata)
+        rsp['data'] = bytearray(rsp['data'])
+        if rsp['data'][0] != 0:
+            return None
+        propdata = rsp['data'][3:]  # second two bytes are size, don't need it
+        if propdata[0] & 0b10000000:  # string, for now assume length valid
+            ret = bytes(propdata[1:]).rstrip(b' \x00')
+            if not isinstance(ret, str):
+                ret = ret.decode('utf-8')
+            return ret
+        if propdata[0] == 0x44:  # dword
+            return propdata[1:5]
+        else:
+            raise Exception('Unknown format for property: ' + repr(propdata))
+
+    async def get_webclient(self):
+        cv = self.ipmicmd.certverify
+        wc = webclient.WebConnection(self.imm, 443, verifycallback=cv)
+        wc.vintage = None
+        adata = urlencode({'user': self.username,
+                           'password': self.password,
+                           'SessionTimeout': 60})
+        headers = {'Connection': 'keep-alive',
+                   'Origin': 'https://imm/',
+                   'Host': 'imm',
+                   'Referer': 'https://imm/designs/imm/index.php',
+                   'Content-Type': 'application/x-www-form-urlencoded'}
+        rsp = await wc.grab_json_response_with_status('/data/login', adata, headers)
+        if rsp[0] == 200:
+            rspdata = rsp[0]
+            if rspdata['authResult'] == '0' and rspdata['status'] == 'ok':
+                if 'token2_name' in rspdata and 'token2_value' in rspdata:
+                    wc.set_header(rspdata['token2_name'],
+                                  rspdata['token2_value'])
+                if 'token3_name' in rspdata and 'token3_value' in rspdata:
+                    self.uploadtoken = {rspdata['token3_name']:
+                                        rspdata['token3_value']}
+                else:
+                    self.uploadtoken = {}
+                wc.set_header('Referer', self.adp_referer)
+                wc.set_header('Host', 'imm')
+                wc.set_header('Origin', 'https://imm/')
+                return wc
+
+    async def wc(self):
+        while self.weblogging:
+            await ipmisession.Session.pause(0.25)
+        self.weblogging = True
+        try:
+            if (not self._wc or (self._wc.vintage
+                                and self._wc.vintage < util._monotonic_time()
+                                - 30)):
+                if not self.updating and self._wc:
+                    # in case the existing session is still valid
+                    # dispose of the session
+                    await self.weblogout()
+                self._wc = await self.get_webclient()
+        finally:
+            self.weblogging = False
+        return self._wc
+
+    async def fetch_grouped_properties(self, groupinfo):
+        retdata = {}
+        for keyval in groupinfo:
+            retdata[keyval] = await self.get_property(groupinfo[keyval])
+            if keyval == 'date':
+                retdata[keyval] = self.datefromprop(retdata[keyval])
+        returnit = False
+        for keyval in list(retdata):
+            if retdata[keyval] in (None, ''):
+                del retdata[keyval]
+            else:
+                returnit = True
+        if returnit:
+            return retdata
+
+    async def grab_cacheable_json(self, url, age=30):
+        data = self.get_cached_data(url, age)
+        wc = await self.wc()
+        if not data:
+            data, status = await wc.grab_json_response_with_status(url)
+            if status == 401:
+                self._wc = None
+                data, status = await wc.grab_json_response_with_status(url)
+            if status != 200:
+                data = {}
+            self.datacache[url] = (data, util._monotonic_time())
+        return data
+
+    def get_cached_data(self, attribute, age=30):
+        try:
+            kv = self.datacache[attribute]
+            if kv[1] > util._monotonic_time() - age:
+                return kv[0]
+        except KeyError:
+            return None
+
+    async def upload_media(self, filename, progress=None, data=None):
+        xid = random.randint(0, 1000000000)
+        wc = await self.wc()
+        alloc = await wc.grab_json_response(
+            '/data/set',
+            'RP_VmAllocateLoc({0},{1},1)'.format(self.username, filename))
+        if alloc['return'] != 'Success':
+            raise Exception('Unexpected reply to allocation: ' + repr(alloc))
+        slotid = alloc['slotId']
+        uploadfields = self.uploadtoken
+        uploadfields['filePath'] = alloc['filePath']
+        uploadfields['uploadType'] = 'iframe'
+        uploadfields['available'] = alloc['available']
+        uploadfields['checksum'] = xid
+        ut = await webclient.make_uploader(
+            wc, '/designs/imm/upload/rp_image_upload.esp', filename, data,
+            otherfields=uploadfields)
+        while not ut.completed():
+            try:
+                await ut.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({'phase': 'upload',
+                          'progress': 100 * await ut.get_progress()})
+        status = await wc.grab_json_response(
+            '/designs/imm/upload/rp_image_upload_status.esp',
+            'filePath={0}'.format(alloc['filePath']))
+        if not status['rpImgUploadResult'].endswith('Success'):
+            raise Exception(
+                'Upload status returned unexpected data: ' + repr(alloc))
+        ups = await wc.grab_json_response(
+            '/data/set',
+            'RP_VmUpdateSize({1}, {0})'.format(status['originalFileSize'],
+                                               slotid))
+        if ups['return'] != 'Success':
+            raise Exception('Unexpected return to update size: ' + repr(ups))
+        ups = await wc.grab_json_response('/data/set',
+                                         'RP_VmMount({0})'.format(slotid))
+        if ups['return'] != 'Success':
+            raise Exception('Unexpected return to mount: ' + repr(ups))
+        if progress:
+            progress({'phase': 'complete'})
+
+    async def attach_remote_media(self, url, user, password):
+        url = url.replace(':', '\\:')
+        wc = await self.wc()
+        params = urlencode({
+            'RP_VmAllocateMountUrl({0},{1},1,,)'.format(
+                self.username, url): ''
+        })
+        result = await wc.grab_json_response('/data?set', params,
+                                            referer=self.adp_referer)
+        if not result:
+            result = await wc.grab_json_response('/data/set', params,
+                                                referer=self.adp_referer)
+        if result['return'] != 'Success':
+            raise Exception(result['reason'])
+        await self.weblogout()
+
+    async def list_media(self):
+        wc = await self.wc()
+        rt = await wc.grab_json_response(
+            '/designs/imm/dataproviders/imm_rp_images.php',
+            referer=self.adp_referer)
+        for item in rt['items']:
+            if 'images' in item:
+                for uload in item['images']:
+                    if uload['status'] != 0:
+                        yield media.Media(uload['filename'])
+            for attached in item.get('urls', []):
+                filename = attached['url']
+                filename = filename.split('/')[-1]
+                url = '/'.join(attached['url'].split('/')[:-1])
+                yield media.Media(filename, url)
+
+    async def detach_remote_media(self):
+        wc = await self.wc()
+        mnt = await wc.grab_json_response(
+            '/designs/imm/dataproviders/imm_rp_images.php',
+            referer=self.adp_referer)
+        removeurls = []
+        for item in mnt['items']:
+            if 'urls' in item:
+                for url in item['urls']:
+                    removeurls.append(url['url'])
+            if 'images' in item:
+                for uload in item['images']:
+                    await wc.grab_json_response(
+                        '/data/set', 'RP_RemoveFile({0}, 0)'.format(
+                            uload['slotId']))
+        for url in removeurls:
+            url = url.replace(':', '\\:')
+            params = urlencode({
+                'RP_VmAllocateUnMountUrl({0},{1},0,)'.format(
+                    self.username, url): ''})
+            result = await wc.grab_json_response('/data?set', params,
+                                                referer=self.adp_referer)
+            if not result:
+                result = await wc.grab_json_response('/data/set', params,
+                                                    referer=self.adp_referer)
+            if result['return'] != 'Success':
+                raise Exception(result['reason'])
+        await self.weblogout()
+
+    def fetch_psu_firmware(self):
+        return []
+
+    async def fetch_agentless_firmware(self, needdisk=True, needadp=True):
+        skipkeys = set([])
+        wc = await self.wc()
+        if needadp:
+            cd = self.get_cached_data('lenovo_cached_adapters_fu')
+            if cd:
+                adapterdata, fwu = cd
+            else:
+                adapterdata = None
+            if not adapterdata:
+                if self.updating:
+                    raise pygexc.TemporaryError(
+                        'Cannot read extended inventory during firmware update')
+                if wc:
+                    adapterdata = await wc.grab_json_response(
+                        self.ADP_URL, referer=self.adp_referer)
+                    if self.ADP_FU_URL:
+                        fwu = await wc.grab_json_response(
+                            self.ADP_FU_URL, referer=self.adp_referer)
+                    else:
+                        fwu = {}
+                    if adapterdata:
+                        self.datacache['lenovo_cached_adapters_fu'] = (
+                            (adapterdata, fwu), util._monotonic_time())
+            if adapterdata and 'items' in adapterdata:
+                anames = {}
+                for adata in adapterdata['items']:
+                    aname = adata[self.ADP_NAME]
+                    if aname in anames:
+                        anames[aname] += 1
+                        aname = '{0} {1}'.format(aname, anames[aname])
+                    else:
+                        anames[aname] = 1
+                    donenames = set([])
+                    for fundata in adata[self.ADP_FUN]:
+                        fdata = fundata.get('firmwares', ())
+                        for firm in fdata:
+                            fname = firm['firmwareName'].rstrip()
+                            if '.' in fname:
+                                fname = firm['description'].rstrip()
+                            if fname in donenames:
+                                # ignore redundant entry
+                                continue
+                            if not fname:
+                                continue
+                            donenames.add(fname)
+                            bdata = {}
+                            if 'versionStr' in firm and firm['versionStr']:
+                                bdata['version'] = firm['versionStr']
+                            if ('releaseDate' in firm
+                                    and firm['releaseDate']
+                                    and firm['releaseDate'] != 'N/A'):
+                                try:
+                                    bdata['date'] = self._parse_builddate(
+                                        firm['releaseDate'])
+                                except ValueError:
+                                    pass
+                            yield '{0} {1}'.format(aname, fname), bdata
+                    for fwi in fwu.get('items', []):
+                        if fwi.get('key', -1) == adata.get('key', -2):
+                            skipkeys.add(fwi['key'])
+                            if fwi.get('fw_status', 0) == 2:
+                                bdata = {}
+                                if 'fw_pkg_version' in fwi and fwi['fw_pkg_version']:
+                                    bdata['version'] = fwi['fw_pkg_version']
+                                elif 'fw_version_pend' in fwi:
+                                    bdata['version'] = fwi['fw_version_pend']
+                                yield '{0} Pending Update'.format(aname), bdata
+            for fwi in fwu.get('items', []):
+                if fwi.get('key', -1) > 0 and fwi['key'] not in skipkeys:
+                    bdata = {}
+                    bdata['version'] = fwi['fw_version']
+                    yield fwi['adapterName'], bdata
+                    if fwi.get('fw_status', 0) == 2:
+                        bdata = {}
+                        if 'fw_version_pend' in fwi:
+                            bdata['version'] = fwi['fw_version_pend']
+                        yield '{0} Pending Update'.format(fwi['adapterName']), bdata
+        if needdisk:
+            async for disk in self.disk_inventory():
+                yield disk
+        await self.weblogout()
+
+    async def disk_inventory(self, mode=0):
+        if mode == 1:
+            # Bypass IMM hardware inventory for now
+            return
+        wc = await self.wc()
+        storagedata = self.get_cached_data('lenovo_cached_storage')
+        if not storagedata:
+            if wc:
+                storagedata = await wc.grab_json_response(
+                    '/designs/imm/dataproviders/raid_alldevices.php')
+                if storagedata:
+                    self.datacache['lenovo_cached_storage'] = (
+                        storagedata, util._monotonic_time())
+        if storagedata and 'items' in storagedata:
+            for adp in storagedata['items']:
+                if 'storage.vpd.productName' not in adp:
+                    continue
+                adpname = adp['storage.vpd.productName']
+                if 'children' not in adp:
+                    adp['children'] = ()
+                for diskent in adp['children']:
+                    bdata = {}
+                    diskname = '{0} Disk {1}'.format(
+                        adpname,
+                        diskent['storage.slotNo'])
+                    bdata['model'] = diskent[
+                        'storage.vpd.productName'].rstrip()
+                    bdata['version'] = diskent['storage.firmwares'][0][
+                        'versionStr']
+                    yield (diskname, bdata)
+
+    async def get_hw_inventory(self):
+        hwmap = await self.hardware_inventory_map()
+        for key in natural_sort(hwmap):
+            yield (key, hwmap[key])
+
+    async def get_hw_descriptions(self):
+        hwmap = await self.hardware_inventory_map()
+        for key in natural_sort(hwmap):
+            yield key
+
+    async def get_component_inventory(self, compname):
+        hwmap = await self.hardware_inventory_map()
+        try:
+            return hwmap[compname]
+        except KeyError:
+            return None
+
+    async def get_oem_sensor_names(self, ipmicmd):
+        try:
+            if self._energymanager is None:
+                self._energymanager = await energy.EnergyManager.create(ipmicmd)
+            for meter in self._energymanager.supportedmeters:
+                yield meter
+        except pygexc.UnsupportedFunctionality:
+            return
+
+    async def get_oem_sensor_descriptions(self, ipmicmd):
+        async for x in self.get_oem_sensor_names(ipmicmd):
+            yield {
+                'name': x,
+                'type': 'Power' if 'Power' in x else 'Energy'
+            }
+
+    async def get_oem_sensor_reading(self, name, ipmicmd):
+        if self._energymanager is None:
+            self._energymanager = await energy.EnergyManager.create(ipmicmd)
+        if name == 'AC Energy':
+            kwh = await self._energymanager.get_ac_energy(ipmicmd)
+        elif name == 'DC Energy':
+            kwh = await self._energymanager.get_dc_energy(ipmicmd)
+        elif self._energymanager.supports(name):
+            value, units = await self._energymanager.get_sensor(name, ipmicmd)
+            return sdr.SensorReading({
+                'name': name, 'imprecision': None,
+                'value': value,
+                'states': [], 'state_ids': [], 'health': pygconst.Health.Ok,
+                'type': 'Power'}, units)
+        else:
+            raise pygexc.UnsupportedFunctionality('No such sensor ' + name)
+        return sdr.SensorReading({'name': name, 'imprecision': None,
+                                  'value': kwh, 'states': [],
+                                  'state_ids': [],
+                                  'health': pygconst.Health.Ok,
+                                  'type': 'Energy'}, 'kWh')
+
+    async def weblogout(self):
+        if self._wc:
+            try:
+                await self._wc.grab_json_response(self.logouturl)
+            except Exception:
+                pass
+            self._wc = None
+
+    async def hardware_inventory_map(self):
+        hwmap = self.get_cached_data('lenovo_cached_hwmap')
+        if hwmap:
+            return hwmap
+        hwmap = {}
+        enclosureuuid = await self.get_property('/v2/ibmc/smm/chassis/uuid')
+        if enclosureuuid:
+            bay = hex(int(await self.get_property('/v2/cmm/sp/7'))).replace(
+                '0x', '')
+            serial = await self.get_property('/v2/ibmc/smm/chassis/sn')
+            model = await self.get_property('/v2/ibmc/smm/chassis/mtm')
+            hwmap['Enclosure'] = {
+                'UUID': fixup_uuid(enclosureuuid),
+                'Bay': bay,
+                'Model': fixup_str(model),
+                'Serial': fixup_str(serial),
+            }
+        async for disk in self.disk_inventory(mode=1):  # hardware mode
+            hwmap[disk[0]] = disk[1]
+        adapterdata = self.get_cached_data('lenovo_cached_adapters')
+        if not adapterdata:
+            if self.updating:
+                raise pygexc.TemporaryError(
+                    'Cannot read extended inventory during firmware update')
+            wc = await self.wc()
+            if wc:
+                adapterdata = await wc.grab_json_response(
+                    self.ADP_URL, referer=self.adp_referer)
+                if adapterdata:
+                    self.datacache['lenovo_cached_adapters'] = (
+                        adapterdata, util._monotonic_time())
+        if adapterdata and 'items' in adapterdata:
+            anames = {}
+            for adata in adapterdata['items']:
+                skipadapter = False
+                clabel = adata[self.ADP_LABEL]
+                if clabel == 'Unknown':
+                    continue
+                if clabel != 'Onboard':
+                    aslot = adata[self.ADP_SLOTNO]
+                    if clabel == 'ML2':
+                        clabel = 'ML2 (Slot {0})'.format(aslot)
+                    else:
+                        clabel = 'Slot {0}'.format(aslot)
+                aname = adata[self.ADP_NAME]
+                bdata = {'location': clabel, 'name': aname}
+                if aname in anames:
+                    anames[aname] += 1
+                    aname = '{0} {1}'.format(aname, anames[aname])
+                else:
+                    anames[aname] = 1
+                for fundata in adata[self.ADP_FUN]:
+                    bdata['pcislot'] = '{0:02x}:{1:02x}'.format(
+                        fundata[self.BUSNO], fundata[self.DEVNO])
+                    serialdata = fundata.get(self.ADP_SERIALNO, None)
+                    if (serialdata and serialdata != 'N/A'
+                            and '---' not in serialdata):
+                        bdata['serial'] = serialdata
+                    partnum = fundata.get(self.ADP_PARTNUM, None)
+                    if partnum and partnum != 'N/A':
+                        bdata['Part Number'] = partnum
+                    cardtype = funtypes.get(fundata.get('funType', None),
+                                            None)
+                    if cardtype is not None:
+                        bdata['Type'] = cardtype
+                    venid = fundata.get(self.ADP_VENID, None)
+                    if venid is not None:
+                        bdata['PCI Vendor ID'] = '{0:04x}'.format(venid)
+                    devid = fundata.get(self.ADP_DEVID, None)
+                    if devid is not None and 'PCI Device ID' not in bdata:
+                        bdata['PCI Device ID'] = '{0:04x}'.format(devid)
+                    venid = fundata.get(self.ADP_SUBVENID, None)
+                    if venid is not None:
+                        bdata['PCI Subsystem Vendor ID'] = '{0:04x}'.format(
+                            venid)
+                    devid = fundata.get(self.ADP_SUBDEVID, None)
+                    if devid is not None:
+                        bdata['PCI Subsystem Device ID'] = '{0:04x}'.format(
+                            devid)
+                    fruno = fundata.get(self.ADP_FRU, None)
+                    if fruno is not None:
+                        bdata['FRU Number'] = fruno
+                    if self.PORTS in fundata:
+                        for portinfo in fundata[self.PORTS]:
+                            for lp in portinfo['logicalPorts']:
+                                ma = lp['networkAddr']
+                                ma = ':'.join(
+                                    [ma[i:i + 2] for i in range(
+                                        0, len(ma), 2)]).lower()
+                                bdata['MAC Address {0}'.format(
+                                    portinfo['portIndex'])] = ma
+                    elif clabel == 'Onboard':  # skip the various non-nic
+                        skipadapter = True
+                if not skipadapter:
+                    hwmap[aname] = bdata
+            self.datacache['lenovo_cached_hwmap'] = (hwmap,
+                                                     util._monotonic_time())
+        self.weblogout()
+        return hwmap
+
+    async def get_firmware_inventory(self, bmcver, components, category):
+        # First we fetch the system firmware found in imm properties
+        # then check for agentless, if agentless, get adapter info using
+        # https, using the caller TLS verification scheme
+        components = set(components)
+        if 'core' in components:
+            category = 'core'        
+        if not components or set(('imm', 'xcc', 'bmc', 'core')) & components:
+            rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0x50)
+            immverdata = self.parse_imm_buildinfo(rsp['data'])
+            bmcmajor, bmcminor = [int(x) for x in bmcver.split('.')]
+            bmcver = '{0}.{1:02d}'.format(bmcmajor, bmcminor)
+            bdata = {
+                'version': bmcver, 'build': immverdata[0],
+                'date': immverdata[1]}
+            yield (self.bmcname, bdata)
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/ibmc/dm/fw/imm2/backup_build_id',
+                'version': '/v2/ibmc/dm/fw/imm2/backup_build_version',
+                'date': '/v2/ibmc/dm/fw/imm2/backup_build_date'})
+            if bdata:
+                yield ('{0} Backup'.format(self.bmcname), bdata)
+                bdata = await self.fetch_grouped_properties({
+                    'build': '/v2/ibmc/trusted_buildid',
+                })
+            if bdata:
+                yield ('{0} Trusted Image'.format(self.bmcname), bdata)
+        if not components or set(('uefi', 'bios', 'core')) & components:
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/bios/build_id',
+                'version': '/v2/bios/build_version',
+                'date': '/v2/bios/build_date'})
+            if bdata:
+                yield ('UEFI', bdata)
+            else:
+                yield ('UEFI', {'version': 'unknown'})
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/ibmc/dm/fw/bios/backup_build_id',
+                'version': '/v2/ibmc/dm/fw/bios/backup_build_version'})
+            if bdata:
+                yield ('UEFI Backup', bdata)
+            # Note that the next pending could be pending for either primary
+            # or backup, so can't promise where it will go
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/bios/pending_build_id'})
+            if bdata:
+                yield ('UEFI Pending Update', bdata)
+        if not components or set(('fpga', 'core')) & components:
+            try:
+                fpga = await self.ipmicmd.raw_command(netfn=0x3a, command=0x6b,
+                                                 data=(0,))
+                fpga = '{0}.{1}.{2}'.format(*bytearray(fpga['data']))
+                yield ('FPGA', {'version': fpga})
+            except pygexc.IpmiException as ie:
+                if ie.ipmicode != 193:
+                    raise
+        if (not components or (components - set((
+                'core', 'uefi', 'bios', 'bmc', 'xcc', 'imm', 'fpga',
+                'lxpm')))):
+            async for firm in self.fetch_agentless_firmware():
+                yield firm
+
+
+class XCCClient(IMMClient):
+    logouturl = '/api/providers/logout'
+    bmcname = 'XCC'
+    ADP_URL = '/api/dataset/imm_adapters?params=pci_GetAdapters'
+    ADP_NAME = 'adapterName'
+    ADP_FUN = 'functions'
+    ADP_FU_URL = '/api/function/adapter_update?params=pci_GetAdapterListAndFW'
+    ADP_LABEL = 'connectorLabel'
+    ADP_SLOTNO = 'slotNo'
+    ADP_OOB = 'oobSupported'
+    ADP_PARTNUM = 'vpd_partNo'
+    ADP_SERIALNO = 'vpd_serialNo'
+    ADP_VENID = 'generic_vendorId'
+    ADP_SUBVENID = 'generic_subVendor'
+    ADP_DEVID = 'generic_devId'
+    ADP_SUBDEVID = 'generic_subDevId'
+    ADP_FRU = 'vpd_cardSKU'
+    BUSNO = 'generic_busNo'
+    PORTS = 'network_pPorts'
+    DEVNO = 'generic_devNo'
+
+    def __init__(self, ipmicmd):
+        super(XCCClient, self).__init__(ipmicmd)
+        self.ipmicmd.ipmi_session.register_keepalive(self.keepalive, None)
+        self.adp_referer = None
+
+    async def get_screenshot(self, outfile):
+        wc = await self.wc()
+        await wc.grab_json_response('/api/providers/rp_screenshot')
+        url = '/download/HostScreenShot.png'
+        fd = webclient.make_downloader(wc, url, outfile)
+        await fd.join()
+
+    async def get_user_privilege_level(self, uid):
+        uid = uid - 1
+        accurl = '/redfish/v1/AccountService/Accounts/{0}'.format(uid)
+        accinfo, status = await self.grab_redfish_response_with_status(accurl)
+        if status == 200:
+            return accinfo.get('RoleId', None)
+        return None
+
+    async def get_ikvm_methods(self):
+        return ['url']
+
+    async def get_ikvm_launchdata(self):
+        access = await self.grab_redfish_response_with_status('/redfish/v1/Managers/1/Oem/Lenovo/RemoteControl/Actions/LenovoRemoteControlService.GetRemoteConsoleToken', {})
+        if access[0].get('Token', None):
+            accessinfo = {
+                'url': '/#/login?{}&context=remote&mode=multi'.format(access[0]['Token'])
+                }
+            return accessinfo
+        return {}
+    
+    async def set_user_access(self, uid, privilege_level):
+        uid = uid - 1
+        role = None
+        if privilege_level == 'administrator':
+            role = 'Administrator'
+        elif privilege_level == 'operator':
+            role = 'Operator'
+        elif privilege_level == 'user':
+            role = 'ReadOnly'
+        elif privilege_level.startswith('custom.'):
+            role = privilege_level.replace('custom.', '')
+        if role:
+            await self.grab_redfish_response_with_status(
+                '/redfish/v1/AccountService/Accounts/{0}'.format(uid),
+                {'RoleId': role}, method='PATCH')
+
+    async def reseat(self):
+        owc = await self.wc()
+        wc = owc.dupe(timeout=5)
+        try:
+            rsp = await wc.grab_json_response_with_status(
+                '/api/providers/virt_reseat', '{}')
+        except socket.timeout:
+            return # probably reseated itself and unable to reply        
+        if rsp[1] == 500 and rsp[0] == 'Target Unavailable':
+            return
+        if rsp[1] != 200 or rsp[0].get('return', 1) != 0:
+            raise pygexc.UnsupportedFunctionality(
+                'This platform does not support AC reseat.')
+
+    async def fetch_dimm(self, name, fru):
+        meminfo = await self.grab_cacheable_json('/api/dataset/imm_memory')
+        meminfo = meminfo.get('items', [{}])[0].get('memory', [])
+        for memi in meminfo:
+            if memi.get('memory_description', None) == name:
+                fru['model'] = memi['memory_part_number']
+                fru['ecc'] = memi.get('memory_ecc_bits', 0) != 0
+                fru['manufacture_location'] = 0
+                fru['memory_type'] = memi['memory_type']
+                fru['module_type'] = fru['memory_type']
+                mdate = memi['memory_manuf_date']
+                mdate = '20{}-W{}'.format(mdate[-2:], mdate[:-2])
+                fru['manufacture_date'] = mdate
+                speed = memi['memory_config_speed'] * 8 / 100 * 100
+                fru['speed'] = speed
+                fru['capacity_mb'] = memi['memory_capacity'] * 1024
+                fru['serial'] = memi['memory_serial_number'].strip()
+                fru['manufacturer'] = memi['memory_manufacturer']
+                break
+
+    async def set_identify(self, on, duration, blink):
+        if blink:
+            await self.grab_redfish_response_with_status(
+                '/redfish/v1/Systems/1',
+                {'IndicatorLED': 'Blinking'},
+                method='PATCH')
+            raise pygexc.BypassGenericBehavior()
+        raise pygexc.UnsupportedFunctionality()
+
+    async def get_description(self):
+        wc = await self.wc()
+        dsc = await wc.grab_json_response('/DeviceDescription.json')
+        dsc = dsc[0]
+        if not dsc.get('u-height', None):
+            if dsc.get('enclosure-machinetype-model', '').startswith('7Y36'):
+                return {'height': 2, 'slot': 0}
+            else:
+                return {}
+        return {'height': int(dsc['u-height']), 'slot': int(dsc['slot'])}
+
+    async def get_extended_bmc_configuration(self):
+        immsettings = await self.get_system_configuration(fetchimm=True)
+        for setting in list(immsettings):
+            if not setting.startswith('IMM.'):
+                del immsettings[setting]
+        return immsettings
+
+    async def user_delete(self, uid):
+        uid = uid - 1
+        wc = await self.wc()
+        userinfo = await wc.grab_json_response('/api/dataset/imm_users')
+        uidtonamemap = {}
+        for user in userinfo.get('items', [{'users': []}])[0].get('users', []):
+            uidtonamemap[user['users_user_id']] = user['users_user_name']
+        if uid in uidtonamemap:
+            deltarget = '{0},{1}'.format(uid, uidtonamemap[uid])
+            await wc.grab_json_response('/api/function', {"USER_UserDelete": deltarget})
+            raise pygexc.BypassGenericBehavior()
+
+    async def get_bmc_configuration(self):
+        settings = {}
+        wc = await self.wc()
+        passrules = await wc.grab_json_response('/api/dataset/imm_users_global')
+        passrules = passrules.get('items', [{}])[0]
+        settings['password_reuse_count'] = {
+            'value': passrules.get('pass_min_resuse')}
+        settings['password_change_interval'] = {
+            'value': passrules.get('pass_change_interval')}
+        settings['password_expiration'] = {
+            'value': passrules.get('pass_expire_days')}
+        settings['password_login_failures'] = {
+            'value': passrules.get('max_login_failures')}
+        settings['password_complexity'] = {
+            'value': passrules.get('pass_complex_required')}
+        settings['password_min_length'] = {
+            'value': passrules.get('pass_min_length')}
+        settings['password_lockout_period'] = {
+            'value': passrules.get('lockout_period')}
+        presassert = await wc.grab_json_response('/api/dataset/imm_rpp')
+        asserted = presassert.get('items', [{}])[0].get('rpp_Assert', None)
+        if asserted is not None:
+            settings['presence_assert'] = {
+                'value': 'Enable' if asserted else 'Disable'
+            }
+        usbparms = await wc.grab_json_response('/api/dataset/imm_usb')
+        if usbparms:
+            usbparms = usbparms.get('items', [{}])[0]
+            if usbparms['usb_eth_over_usb_enabled'] == 1:
+                usbeth = 'Enable'
+            else:
+                usbeth = 'Disable'
+            settings['usb_ethernet'] = {
+                'value': usbeth
+            }
+            if usbparms['usb_eth_to_eth_enabled'] == 1:
+                fwd = 'Enable'
+            else:
+                fwd = 'Disable'
+            settings['usb_ethernet_port_forwarding'] = {
+                'value': fwd
+            }
+            mappings = []
+            for mapping in usbparms['usb_mapped_ports']:
+                src = mapping['ext_port']
+                dst = mapping['eth_port']
+                if src != 0 and dst != 0:
+                    mappings.append('{0}:{1}'.format(src, dst))
+            settings['usb_forwarded_ports'] = {'value': ','.join(mappings)}
+        try:
+            enclosureinfo = await self.ipmicmd.raw_command(0x3a, 0xf1, data=[0])
+        except pygexc.IpmiException:
+            return settings
+        settings['smm'] = {
+            'default': 'Disable',
+            'possible': ['Enable', 'Disable', 'IPMI'],
+            'help': 'Enables or disables the network of the '
+                    'enclosure manager. IPMI Enables with IPMI '
+                    'for v2 systems.',
+        }
+        if bytearray(enclosureinfo['data'])[0] == 2:
+            settings['smm']['value'] = 'Disable'
+        elif bytearray(enclosureinfo['data'])[0] == 1:
+            settings['smm']['value'] = 'Enable'
+        elif bytearray(enclosureinfo['data'])[0] == 4:
+            settings['smm']['value'] = 'IPMI'
+        else:
+            settings['smm']['value'] = None
+        smmip = await self.get_property('/v2/ibmc/smm/smm_ip')
+        if smmip:
+            smmip = socket.inet_ntoa(bytes(smmip[-1::-1]))
+            settings['smm_ip'] = {
+                'help': 'Current IPv4 address as reported by SMM, read-only',
+                'value': smmip,
+            }
+        return settings
+
+    rulemap = {
+        'password_change_interval': 'USER_GlobalMinPassChgInt',
+        'password_reuse_count': 'USER_GlobalMinPassReuseCycle',
+        'password_expiration': 'USER_GlobalPassExpPeriod',
+        'password_login_failures': 'USER_GlobalMaxLoginFailures',
+        'password_complexity': 'USER_GlobalPassComplexRequired',
+        'password_min_length': 'USER_GlobalMinPassLen',
+        'password_lockout_period': 'USER_GlobalLockoutPeriod',
+    }
+
+    async def set_bmc_configuration(self, changeset):
+        ruleset = {}
+        usbsettings = {}
+        wc = await self.wc()
+        for key in changeset:
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            currval = changeset[key].get('value', None)
+            if 'smm'.startswith(key.lower()):
+                if 'enabled'.startswith(currval.lower()):
+                    await self.ipmicmd.raw_command(0x3a, 0xf1, data=[1])
+                elif 'disabled'.startswith(currval.lower()):
+                    await self.ipmicmd.raw_command(0x3a, 0xf1, data=[2])
+                elif 'ipmi'.startswith(currval.lower()):
+                    await self.ipmicmd.raw_command(0x3a, 0xf1, data=[4])
+            elif key.lower() in self.rulemap:
+                ruleset[self.rulemap[key.lower()]] = changeset[key]['value']
+                if key.lower() == 'password_expiration':
+                    warntime = str(int(int(changeset[key]['value']) * 0.08))
+                    ruleset['USER_GlobalPassExpWarningPeriod'] = warntime
+            elif 'presence_asserted'.startswith(key.lower()):
+                assertion = changeset[key]['value']
+                if 'enabled'.startswith(assertion.lower()):
+                    await wc.grab_json_response('/api/dataset',
+                                               {'IMM_RPPAssert': '0'})
+                    await wc.grab_json_response('/api/dataset',
+                                               {'IMM_RPPAssert': '1'})
+                elif 'disabled'.startswith(assertion.lower()):
+                    await wc.grab_json_response('/api/dataset',
+                                               {'IMM_RPPAssert': '0'})
+                else:
+                    raise pygexc.InvalidParameterValue(
+                        '"{0}" is not a recognized value for {1}'.format(
+                            assertion, key))
+            elif key.lower() in (
+                    'usb_ethernet', 'usb_ethernet_port_forwarding',
+                    'usb_forwarded_ports'):
+                usbsettings[key] = changeset[key]['value']
+            else:
+                raise pygexc.InvalidParameterValue(
+                    '{0} not a known setting'.format(key))
+        if ruleset:
+            await wc.grab_json_response('/api/dataset', ruleset)
+        if usbsettings:
+            await self.apply_usb_configuration(usbsettings)
+
+    async def apply_usb_configuration(self, usbsettings):
+        def numify(val):
+            if 'enabled'.startswith(val.lower()):
+                return '1'
+            if 'disabled'.startswith(val.lower()):
+                return '0'
+            raise Exception('Usupported value')
+        wc = await self.wc()
+        usbparms = await wc.grab_json_response('/api/dataset/imm_usb')
+        usbparms = usbparms.get('items', [{}])[0]
+        addrmode = '{0}'.format(usbparms['lan_over_usb_addr_mode'])
+        ethena = '{0}'.format(usbparms['usb_eth_over_usb_enabled'])
+        fwdena = '{0}'.format(usbparms['usb_eth_to_eth_enabled'])
+        newena = usbsettings.get('usb_ethernet', None)
+        newfwd = usbsettings.get('usb_ethernet_port_forwarding', None)
+        newsettings = {
+            'USB_LANOverUSBAddrMode': addrmode,
+            'USB_EthOverUsbEna': ethena,
+            'USB_PortForwardEna': fwdena,
+            'USB_IPChangeEna': '0',
+        }
+        needsettings = False
+        if newena is not None:
+            needsettings = True
+            newsettings['USB_EthOverUsbEna'] = numify(newena)
+        if newfwd is not None:
+            needsettings = True
+            newsettings['USB_PortForwardEna'] = numify(newfwd)
+        if needsettings:
+            await wc.grab_json_response('/api/dataset', newsettings)
+        if 'usb_forwarded_ports' in usbsettings:
+            oldfwds = {}
+            usedids = set([])
+            newfwds = usbsettings['usb_forwarded_ports'].split(',')
+            for mapping in usbparms['usb_mapped_ports']:
+                rule = '{0}:{1}'.format(
+                    mapping['ext_port'], mapping['eth_port'])
+                if rule not in newfwds:
+                    await wc.grab_json_response(
+                        '/api/function', {
+                            'USB_RemoveMapping': '{0}'.format(mapping['id'])})
+                else:
+                    usedids.add(mapping['id'])
+                    oldfwds[rule] = mapping['id']
+            for mapping in usbsettings['usb_forwarded_ports'].split(','):
+                if mapping not in oldfwds:
+                    newid = 1
+                    while newid in usedids:
+                        newid += 1
+                    if newid > 11:
+                        raise Exception('Too Many Port Forwards')
+                    usedids.add(newid)
+                    newmapping = '{0},{1}'.format(
+                        newid, mapping.replace(':', ','))
+                    await wc.grab_json_response(
+                        '/api/function', {'USB_AddMapping': newmapping})
+
+    async def clear_system_configuration(self):
+        wc = await self.wc()
+        res = await wc.grab_json_response_with_status(
+            '/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios',
+            {'Action': 'Bios.ResetBios'},
+            headers={
+                'Authorization': 'Basic %s' % base64.b64encode(
+                    (self.username + ':' + self.password).encode('utf8')
+                ).decode('utf8'),
+                'Content-Type': 'application/json'
+            }
+        )
+        if res[1] < 200 or res[1] >= 300:
+            raise Exception(
+                'Unexpected response to clear configuration: {0}'.format(
+                    res[0]))
+
+    async def get_webclient(self, login=True):
+        cv = self.ipmicmd.certverify
+        wc = webclient.WebConnection(self.imm, 443, verifycallback=cv)
+        wc.vintage = util._monotonic_time()
+        if not login:
+            return wc
+        adata = {'username': self.username,
+                 'password': self.password
+                }
+        headers = {'Connection': 'keep-alive',
+                   'Referer': 'https://xcc/',
+                   'Host': 'xcc',
+                   'Content-Type': 'application/json'}
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/providers/get_nonce', {})
+        if status == 200:
+            nonce = rsp.get('nonce', None)
+            headers['Content-Security-Policy'] = 'nonce={0}'.format(nonce)
+        rspdata = await wc.grab_json_response('/api/login', data=adata, headers=headers)
+        if rspdata:
+            wc.set_header('Content-Type', 'application/json')
+            wc.set_header('Referer', 'https://xcc/')
+            wc.set_header('Host', 'xcc')
+            wc.set_header('Authorization', 'Bearer ' + rspdata['access_token'])
+            for cky in wc.cookies:
+                if cky.key == '_csrf_token':
+                    wc.set_header('X-XSRF-TOKEN', cky.value)
+                    break
+            return wc
+
+    async def _raid_number_map(self, controller):
+        themap = {}
+        cid = controller.split(',')
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function/raid_conf?'
+            'params=raidlink_GetDisksToConf,{0}'.format(cid[0]))
+        if rsp.get('return') == 22:  # New style firmware
+            if cid[2] == 2:
+                arg = '{0},{1}'.format(cid[1], cid[2])
+            else:
+                arg = '{0},{1}'.format(cid[0], cid[2])
+            arg = 'params=raidlink_GetDisksToConf,{0}'.format(arg)
+            rsp = await wc.grab_json_response(
+                '/api/function/raid_conf?{0}'.format(arg))
+        for lvl in rsp['items'][0]['supported_raidlvl']:
+            mapdata = (lvl['rdlvl'], lvl['maxSpan'])
+            raidname = lvl['rdlvlstr'].replace(' ', '').lower()
+            themap[raidname] = mapdata
+            raidname = raidname.replace('raid', 'r')
+            themap[raidname] = mapdata
+            raidname = raidname.replace('r', '')
+            themap[raidname] = mapdata
+        return themap
+
+    async def check_storage_configuration(self, cfgspec=None):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function/raid_conf?params=raidlink_GetStatus')
+        if rsp['items'][0]['status'] not in (2, 3):
+            raise pygexc.TemporaryError('Storage configuration unavailable in '
+                                        'current state (try boot to setup or '
+                                        'an OS)')
+        if not cfgspec:
+            return True
+        for pool in cfgspec.arrays:
+            self._parse_storage_cfgspec(pool)
+        await self.weblogout()
+        return True
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        wc = await self.wc()
+        result = await wc.grab_json_response('/api/providers/ffdc',
+                                            {'Generate_FFDC_status': 1})
+        rsp = await wc.grab_json_response('/api/providers/ffdc',
+                                         {'Generate_FFDC': 1})
+        if rsp.get('return', 0) == 4:
+            rsp = await wc.grab_json_response('/api/providers/ffdc',
+                                             {'Generate_FFDC': 1,
+                                              'thermal_log': 0})        
+        percent = 0
+        while percent != 100:
+            await ipmisession.Session.pause(3)
+            result = await wc.grab_json_response('/api/providers/ffdc',
+                                                {'Generate_FFDC_status': 1})
+            await self._refresh_token_wc(wc)
+            if progress:
+                progress({'phase': 'initializing', 'progress': float(percent)})
+            percent = result['progress']
+        while 'FileName' not in result:
+            result = await wc.grab_json_response('/api/providers/ffdc',
+                                                {'Generate_FFDC_status': 1})
+        url = '/ffdc/{0}'.format(result['FileName'])
+        if autosuffix and not savefile.endswith('.tzz'):
+            savefile += '-{0}'.format(result['FileName'])
+        fd = webclient.make_downloader(wc, url, savefile)
+        while not fd.completed():
+            try:
+                await fd.join(1)
+            except asyncio.TimeoutError:
+                pass
+            if progress and await fd.get_progress():
+                progress({'phase': 'download',
+                          'progress': 100 * await fd.get_progress()})
+            await self._refresh_token()
+        if fd.exc:
+            raise fd.exc
+        if progress:
+            progress({'phase': 'complete'})
+        return savefile
+
+    async def disk_inventory(self, mode=0):
+        # mode 0 is firmware, 1 is hardware
+        storagedata = self.get_cached_data('lenovo_cached_storage')
+        wc = await self.wc()
+        if not storagedata:
+            if wc:
+                storagedata = await wc.grab_json_response(
+                    '/api/function/raid_alldevices?params=storage_GetAllDisks')
+                if storagedata:
+                    self.datacache['lenovo_cached_storage'] = (
+                        storagedata, util._monotonic_time())
+        if storagedata and 'items' in storagedata:
+            for adp in storagedata['items']:
+                for diskent in adp.get('disks', ()):
+                    if mode == 0:
+                        yield self.get_disk_firmware(diskent)
+                    elif mode == 1:
+                        yield self.get_disk_hardware(diskent)
+                for diskent in adp.get('aimDisks', ()):
+                    if mode == 0:
+                        yield self.get_disk_firmware(diskent)
+                    elif mode == 1:
+                        yield self.get_disk_hardware(diskent)
+                if mode == 1:
+                    bdata = {'Description': 'Unmanaged Disk'}
+                    if adp.get('m2Type', -1) == 2:
+                        yield 'M.2 Disk', bdata
+                    for umd in adp.get('unmanagedDisks', []):
+                        yield 'Disk {0}'.format(umd['slotNo']), bdata
+
+    def get_disk_hardware(self, diskent, prefix=''):
+        bdata = {}
+        if not prefix:
+            location = diskent.get('location', '')
+            if location.startswith('M.2'):
+                prefix = 'M.2-'
+            elif location.startswith('7MM'):
+                prefix = '7MM-'
+        diskname = 'Disk {1}{0}'.format(diskent['slotNo'], prefix)
+        bdata['Model'] = diskent['productName'].rstrip()
+        bdata['Serial Number'] = diskent['serialNo'].rstrip()
+        bdata['FRU Number'] = diskent['fruPartNo'].rstrip()
+        bdata['Description'] = diskent['type'].rstrip()
+        return (diskname, bdata)
+
+    def get_disk_firmware(self, diskent, prefix=''):
+        bdata = {}
+        if not prefix:
+            location = diskent.get('location', '')
+            if location.startswith('M.2'):
+                prefix = 'M.2-'
+            elif location.startswith('7MM'):
+                prefix = '7MM-'
+        diskname = 'Disk {1}{0}'.format(diskent['slotNo'], prefix)
+        bdata['model'] = diskent[
+            'productName'].rstrip()
+        bdata['version'] = diskent['fwVersion']
+        return (diskname, bdata)
+
+    async def _parse_array_spec(self, arrayspec):
+        controller = None
+        wc = await self.wc()
+        if arrayspec.disks:
+            for disk in list(arrayspec.disks) + list(arrayspec.hotspares):
+                if controller is None:
+                    controller = disk.id[0]
+                if controller != disk.id[0]:
+                    raise pygexc.UnsupportedFunctionality(
+                        'Cannot span arrays across controllers')
+            raidmap = self._raid_number_map(controller)
+            if not raidmap:
+                raise pygexc.InvalidParameterValue(
+                    'There are no available drives for a new array')
+            requestedlevel = str(arrayspec.raid).lower()
+            if requestedlevel not in raidmap:
+                raise pygexc.InvalidParameterValue(
+                    'Requested RAID "{0}" not available on this '
+                    'system with currently available drives'.format(
+                        requestedlevel))
+            rdinfo = raidmap[str(arrayspec.raid).lower()]
+            rdlvl = str(rdinfo[0])
+            defspan = 1 if rdinfo[1] == 1 else 2
+            spancount = defspan if arrayspec.spans is None else arrayspec.spans
+            drivesperspan = str(len(arrayspec.disks) // int(spancount))
+            hotspares = arrayspec.hotspares
+            drives = arrayspec.disks
+            if hotspares:
+                hstr = '|'.join([str(x.id[1]) for x in hotspares]) + '|'
+            else:
+                hstr = ''
+            drvstr = '|'.join([str(x.id[1]) for x in drives]) + '|'
+            ctl = controller.split(',')
+            pth = '/api/function/raid_conf?params=raidlink_CheckConfisValid'
+            args = [pth, ctl[0], rdlvl, spancount, drivesperspan, drvstr,
+                    hstr]
+            url = ','.join([str(x) for x in args])
+            rsp = await wc.grab_json_response(url)
+            if rsp.get('return', -1) == 22:
+                args.append(ctl[1])
+                args = [pth, ctl[0], rdlvl, spancount, drivesperspan, drvstr,
+                        hstr, ctl[1]]
+                url = ','.join([str(x) for x in args])
+                rsp = await wc.grab_json_response(url)
+            if rsp['items'][0]['errcode'] == 16:
+                raise pygexc.InvalidParameterValue('Incorrect number of disks')
+            elif rsp['items'][0]['errcode'] != 0:
+                raise pygexc.InvalidParameterValue(
+                    'Invalid configuration: {0}'.format(
+                        rsp['items'][0]['errcode']))
+            return {
+                'capacity': rsp['items'][0]['freeCapacity'],
+                'controller': controller,
+                'drives': drvstr,
+                'hotspares': hstr,
+                'raidlevel': rdlvl,
+                'spans': spancount,
+                'perspan': drivesperspan,
+            }
+        else:
+            # TODO(): adding new volume to existing array would be here
+            pass
+
+    def _make_jbod(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        if currstatus.lower() == 'jbod':
+            return
+        self._make_available(disk, realcfg)
+        self._set_drive_state(disk, 16)
+
+    def _make_global_hotspare(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        if currstatus.lower() == 'global hot spare':
+            return
+        self._make_available(disk, realcfg)
+        self._set_drive_state(disk, 1)
+
+    def _make_available(self, disk, realcfg):
+        # 8 if jbod, 4 if hotspare.., leave alone if already...
+        currstatus = self._get_status(disk, realcfg)
+        newstate = None
+        if currstatus == 'Unconfigured Good':
+            return
+        elif currstatus.lower() == 'global hot spare':
+            newstate = 4
+        elif currstatus.lower() == 'jbod':
+            newstate = 8
+        self._set_drive_state(disk, newstate)
+
+    def _get_status(self, disk, realcfg):
+        for cfgdisk in realcfg.disks:
+            if disk.id == cfgdisk.id:
+                currstatus = cfgdisk.status
+                break
+        else:
+            raise pygexc.InvalidParameterValue('Requested disk not found')
+        return currstatus
+
+    async def _set_drive_state(self, disk, state):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function',
+            {'raidlink_DiskStateAction': '{0},{1}'.format(disk.id[1], state)})
+        if rsp.get('return', -1) != 0:
+            raise Exception(
+                'Unexpected return to set disk state: {0}'.format(
+                    rsp.get('return', -1)))
+
+    async def clear_storage_arrays(self):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function', {'raidlink_ClearRaidConf': '1'})
+        self.weblogout()
+        if rsp['return'] != 0:
+            raise Exception('Unexpected return to clear config: ' + repr(rsp))
+
+    async def remove_storage_configuration(self, cfgspec):
+        realcfg = await self.get_storage_configuration(False)
+        wc = await self.wc()
+        for pool in cfgspec.arrays:
+            for volume in pool.volumes:
+                cid = volume.id[0].split(',')
+                if cid[2] == 2:
+                    vid = '{0},{1},{2}'.format(volume.id[1], cid[1], cid[2])
+                else:
+                    vid = '{0},{1},{2}'.format(volume.id[1], cid[0], cid[2])
+                rsp = await wc.grab_json_response(
+                    '/api/function', {'raidlink_RemoveVolumeAsync': vid})
+                if rsp.get('return', -1) == 2:
+                    # older firmware
+                    vid = '{0},{1}'.format(volume.id[1], cid[0])
+                    rsp = await wc.grab_json_response(
+                        '/api/function', {'raidlink_RemoveVolumeAsync': vid})
+                if rsp.get('return', -1) != 0:
+                    raise Exception(
+                        'Unexpected return to volume deletion: ' + repr(rsp))
+                self._wait_storage_async()
+        for disk in cfgspec.disks:
+            await self._make_available(disk, realcfg)
+        self.weblogout()
+
+    async def apply_storage_configuration(self, cfgspec):
+        realcfg = await self.get_storage_configuration(False)
+        for disk in cfgspec.disks:
+            if disk.status.lower() == 'jbod':
+                await self._make_jbod(disk, realcfg)
+            elif disk.status.lower() == 'hotspare':
+                await self._make_global_hotspare(disk, realcfg)
+            elif disk.status.lower() in ('unconfigured', 'available', 'ugood',
+                                         'unconfigured good'):
+                await self._make_available(disk, realcfg)
+        for pool in cfgspec.arrays:
+            if pool.disks:
+                await self._create_array(pool)
+        await self.weblogout()
+
+    async def _create_array(self, pool):
+        wc = await self.wc()
+        params = await self._parse_array_spec(pool)
+        cid = params['controller'].split(',')[0]
+        cslotno = params['controller'].split(',')[1]
+        url = '/api/function/raid_conf?params=raidlink_GetDefaultVolProp'
+        args = (url, cid, 0, params['drives'])
+        props = await wc.grab_json_response(','.join([str(x) for x in args]))
+        usesctrlslot = False
+        if not props:  # newer firmware requires raidlevel too
+            args = (url, cid, params['raidlevel'], 0, params['drives'])
+            props = await wc.grab_json_response(','.join([str(x) for x in args]))
+        elif 'return' in props and props['return'] == 22:
+            # Jan 2023 XCC FW - without controller slot number
+            args = (url, cid, params['raidlevel'], 0, params['drives'])
+            props = await wc.grab_json_response(','.join([str(x) for x in args]))
+            if 'return' in props and props['return'] == 22:
+                usesctrlslot = True
+                # Jan 2023 XCC FW - with controller slot number
+                args = (url, cid, params['raidlevel'], 0, params['drives'], cslotno)
+                props = await wc.grab_json_response(','.join([str(x) for x in args]))
+        props = props['items'][0]
+        volumes = pool.volumes
+        remainingcap = params['capacity']
+        nameappend = 1
+        vols = []
+        currvolnames = None
+        currcfg = None
+        for vol in volumes:
+            if vol.name is None:
+                # need to iterate while there exists a volume of that name
+                if currvolnames is None:
+                    currcfg = await self.get_storage_configuration(False)
+                    currvolnames = set([])
+                    for pool in currcfg.arrays:
+                        for volume in pool.volumes:
+                            currvolnames.add(volume.name)
+                name = props['name'] + '_{0}'.format(nameappend)
+                nameappend += 1
+                while name in currvolnames:
+                    name = props['name'] + '_{0}'.format(nameappend)
+                    nameappend += 1
+            else:
+                name = vol.name
+            if vol.stripsize is not None:
+                stripsize = int(math.log(vol.stripsize * 2, 2))
+            else:
+                stripsize = props['stripsize']
+            if vol.read_policy is not None:
+                read_policy = vol.read_policy
+            else:
+                read_policy = props["cpra"]
+            if vol.write_policy is not None:
+                write_policy = vol.write_policy
+            else:
+                write_policy = props["cpwb"]
+            if vol.default_init is not None:
+                default_init = vol.default_init
+            else:
+                default_init = props["initstate"]
+            strsize = 'remainder' if vol.size is None else str(vol.size)
+            if strsize in ('all', '100%'):
+                volsize = params['capacity']
+            elif strsize in ('remainder', 'rest'):
+                volsize = remainingcap
+            elif strsize.endswith('%'):
+                volsize = int(params['capacity']
+                              * float(strsize.replace('%', '')) / 100.0)
+            else:
+                try:
+                    volsize = int(strsize)
+                except ValueError:
+                    raise pygexc.InvalidParameterValue(
+                        'Unrecognized size ' + strsize)
+            remainingcap -= volsize
+            if remainingcap < 0:
+                raise pygexc.InvalidParameterValue(
+                    'Requested sizes exceed available capacity')
+            vols.append('{0};{1};{2};{3};{4};{5};{6};{7};{8};|'.format(
+                name, volsize, stripsize, write_policy, read_policy,
+                props['cpio'], props['ap'], props['dcp'], default_init))
+        url = '/api/function'
+        cid = params['controller'].split(',')
+        cnum = cid[0]
+        arglist = '{0},{1},{2},{3},{4},{5},'.format(
+            cnum, params['raidlevel'], params['spans'],
+            params['perspan'], params['drives'], params['hotspares'])
+        arglist += ''.join(vols)
+        parms = {'raidlink_AddNewVolWithNaAsync': arglist}
+        rsp = await wc.grab_json_response(url, parms)
+        if rsp['return'] == 14:  # newer firmware
+            if 'supported_cpwb' in props and not usesctrlslot: # no ctrl_type
+                arglist = '{0},{1},{2},{3},{4},{5},{6},'.format(
+                    cnum, params['raidlevel'], params['spans'],
+                    params['perspan'], 0, params['drives'], params['hotspares'])
+                arglist += ''.join(vols)
+                parms = {'raidlink_AddNewVolWithNaAsync': arglist}
+                rsp = await wc.grab_json_response(url, parms)
+            else: # with ctrl_type
+                if cid[2] == 2:
+                    cnum = cid[1]
+                arglist = '{0},{1},{2},{3},{4},{5},'.format(
+                    cnum, params['raidlevel'], params['spans'],
+                    params['perspan'], params['drives'], params['hotspares'])
+                arglist += ''.join(vols) + ',{0}'.format(cid[2])
+                parms = {'raidlink_AddNewVolWithNaAsync': arglist}
+                rsp = await wc.grab_json_response(url, parms)
+        if rsp['return'] != 0:
+            raise Exception(
+                'Unexpected response to add volume command: ' + repr(rsp))
+        await self._wait_storage_async()
+
+    async def _wait_storage_async(self):
+        rsp = {'items': [{'status': 0}]}
+        wc = await self.wc()
+        while rsp['items'][0]['status'] == 0:
+            await ipmisession.Session.pause(1)
+            rsp = await wc.grab_json_response(
+                '/api/function/raid_conf?params=raidlink_QueryAsyncStatus')
+
+    def extract_drivelist(self, cfgspec, controller, drives):
+        for drive in cfgspec['drives']:
+            ctl, drive = self._extract_drive_desc(drive)
+            if controller is None:
+                controller = ctl
+            if ctl != controller:
+                raise pygexc.UnsupportedFunctionality(
+                    'Cannot span arrays across controllers')
+            drives.append(drive)
+        return controller
+
+    #async def get_oem_sensor_names(self, ipmicmd):
+    #    async for x in super(XCCClient, self).get_oem_sensor_names(ipmicmd):
+    #        yield x
+        # therminfo = self.grab_cacheable_json(
+        #     '/api/dataset/pwrmgmt?params=GetThermalRealTimeData', 1)
+        # if therminfo:
+        #     for name in sorted(therminfo.get('items', [[]])[0]):
+        #         if 'DIMM' in name and 'Temp' in name:
+        #             oemsensornames = oemsensornames + (name,)
+        # return oemsensornames
+
+    async def get_storage_configuration(self, logout=True):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function/raid_alldevices?params=storage_GetAllDevices,0')
+        if not rsp:
+            rsp = await wc.grab_json_response(
+                '/api/function/raid_alldevices?params=storage_GetAllDevices')
+        standalonedisks = []
+        pools = []
+        for item in rsp.get('items', []):
+            for cinfo in item['controllerInfo']:
+                cid = '{0},{1},{2}'.format(
+                    cinfo['id'], cinfo.get('slotNo', -1), cinfo.get(
+                        'type', -1))
+                for pool in cinfo['pools']:
+                    volumes = []
+                    disks = []
+                    spares = []
+                    for volume in pool['volumes']:
+                        volumes.append(
+                            storage.Volume(name=volume['name'],
+                                           size=volume['capacity'],
+                                           status=volume['statusStr'],
+                                           id=(cid, volume['id'])))
+                    for disk in pool['disks']:
+                        diskinfo = storage.Disk(
+                            name=disk['name'], description=disk['type'],
+                            id=(cid, disk['id']), status=disk['RAIDState'],
+                            serial=disk['serialNo'], fru=disk['fruPartNo'])
+                        if disk['RAIDState'] == 'Dedicated Hot Spare':
+                            spares.append(diskinfo)
+                        else:
+                            disks.append(diskinfo)
+                    totalsize = str_to_size(pool['totalCapacityStr'])
+                    freesize = str_to_size(pool['freeCapacityStr'])
+                    pools.append(storage.Array(
+                        disks=disks, raid=pool['rdlvlstr'], volumes=volumes,
+                        id=(cid, pool['id']), hotspares=spares,
+                        capacity=totalsize, available_capacity=freesize))
+                for disk in cinfo.get('unconfiguredDisks', ()):
+                    # can be unused, global hot spare, or JBOD
+                    standalonedisks.append(
+                        storage.Disk(
+                            name=disk['name'], description=disk['type'],
+                            id=(cid, disk['id']), status=disk['RAIDState'],
+                            serial=disk['serialNo'], fru=disk['fruPartNo']))
+        if logout:
+            await self.weblogout()
+        return storage.ConfigSpec(disks=standalonedisks, arrays=pools)
+
+    async def attach_remote_media(self, url, user, password):
+        wc = await self.wc()
+        proto, host, path = util.urlsplit(url)
+        if proto == 'smb':
+            proto = 'cifs'
+        rq = {'Option': '', 'Domain': '', 'Write': 0}
+        # nfs == 1, cifs == 0
+        if proto == 'nfs':
+            rq['Protocol'] = 1
+            rq['Url'] = '{0}:{1}'.format(host, path)
+        elif proto == 'cifs':
+            rq['Protocol'] = 0
+            rq['Credential'] = '{0}:{1}'.format(user, password)
+            rq['Url'] = '//{0}{1}'.format(host, path)
+        elif proto in ('http', 'https'):
+            rq['Protocol'] = 7
+            rq['Url'] = url
+        else:
+            raise pygexc.UnsupportedFunctionality(
+                '"{0}" scheme is not supported on this system or '
+                'invalid url format'.format(proto))
+        rt = await wc.grab_json_response('/api/providers/rp_vm_remote_connect',
+                                        json.dumps(rq))
+        if 'return' not in rt or rt['return'] != 0:
+            if rt['return'] in (657, 659, 656):
+                raise pygexc.InvalidParameterValue(
+                    'Given location was unreachable by the XCC')
+            if rt['return'] == 32:
+                raise pygexc.InvalidParameterValue(
+                    'XCC does not have required license for operation')
+            raise Exception('Unhandled return: ' + repr(rt))
+        rt = await wc.grab_json_response('/api/providers/rp_vm_remote_mountall',
+                                        '{}')
+        if 'return' not in rt or rt['return'] != 0:
+            if rt['return'] in (657, 659, 656):
+                raise pygexc.InvalidParameterValue(
+                    'Given location was unreachable by the XCC')
+            raise Exception('Unhandled return: ' + repr(rt))
+        if not self._keepalivesession:
+            # keep at least one session alive so that the
+            # XCC doesn't unmount the media
+            self._keepalivesession = self._wc
+            self._wc = None
+
+    async def keepalive(self):
+        if self.fwo and util._monotonic_time() - self.fwovintage > 15:
+            self.fwo = None
+        if self._keepalivesession:
+            await self._refresh_token_wc(self._keepalivesession)
+        elif self._wc and self._wc.vintage < util._monotonic_time() - 20:
+            await self.weblogout()
+
+    async def fetch_psu_firmware(self):
+        psudata = self.get_cached_data('lenovo_cached_psu')
+        wc = await self.wc()
+        if not psudata:
+            if wc:
+                psudata = await wc.grab_json_response(
+                    '/api/function/psu_update?params=GetPsuListAndFW')
+                if psudata:
+                    self.datacache['lenovo_cached_psu'] = (
+                        psudata, util._monotonic_time())
+        if not psudata:
+            return
+        for psu in psudata.get('items', ()):
+            yield ('PSU {0}'.format(psu['slot']),
+                   {'model': psu['model'],
+                    'version': psu['version']})
+
+    async def get_firmware_inventory(self, bmcver, components, category):
+        # First we fetch the system firmware found in imm properties
+        # then check for agentless, if agentless, get adapter info using
+        # https, using the caller TLS verification scheme
+        if 'core' in components:
+            category = 'core'
+        if not category:
+            category = 'all'        
+        components = set(components)
+        if category in ('all', 'core') and (not components
+                or set(('core', 'imm', 'bmc', 'xcc')) & components):
+            rsp = await self.ipmicmd.raw_command(netfn=0x3a, command=0x50)
+            immverdata = self.parse_imm_buildinfo(rsp['data'])
+            bmcmajor, bmcminor = [int(x) for x in bmcver.split('.')]
+            bmcver = '{0}.{1:02d}'.format(bmcmajor, bmcminor)
+            bdata = {'version': bmcver,
+                     'build': immverdata[0],
+                     'date': immverdata[1]}
+            yield self.bmcname, bdata
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/ibmc/dm/fw/imm3/backup_pending_build_id',
+                'version': '/v2/ibmc/dm/fw/imm3/backup_pending_build_version',
+                'date': '/v2/ibmc/dm/fw/imm3/backup_pending_build_date'})
+            if bdata:
+                yield '{0} Backup'.format(self.bmcname), bdata
+            else:
+                bdata = await self.fetch_grouped_properties({
+                    'build': '/v2/ibmc/dm/fw/imm3/backup_build_id',
+                    'version': '/v2/ibmc/dm/fw/imm3/backup_build_version',
+                    'date': '/v2/ibmc/dm/fw/imm3/backup_build_date'})
+                if bdata:
+                    yield '{0} Backup'.format(self.bmcname), bdata
+                    bdata = await self.fetch_grouped_properties({
+                        'build': '/v2/ibmc/trusted_buildid',
+                    })
+            if bdata:
+                bdata = await self.fetch_grouped_properties({
+                    'build': '/v2/ibmc/trusted_buildid',
+                })
+            if bdata:
+                yield '{0} Trusted Image'.format(self.bmcname), bdata
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/ibmc/dm/fw/imm3/primary_pending_build_id',
+                'version': '/v2/ibmc/dm/fw/imm3/primary_pending_build_version',
+                'date': '/v2/ibmc/dm/fw/imm3/primary_pending_build_date'})
+            if bdata:
+                yield '{0} Pending Update'.format(self.bmcname), bdata
+        if category in ('all', 'core') and not components or set(('core', 'uefi', 'bios')) & components:
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/bios/build_id',
+                'version': '/v2/bios/build_version',
+                'date': '/v2/bios/build_date'})
+            if bdata:
+                yield 'UEFI', bdata
+            # Note that the next pending could be pending for either primary
+            # or backup, so can't promise where it will go
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/bios/pending_build_id'})
+            if bdata:
+                yield 'UEFI Pending Update', bdata
+        if category in ('all', 'core') and not components or set(('lxpm', 'core')) & components:
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/tdm/build_id',
+                'version': '/v2/tdm/build_version',
+                'date': '/v2/tdm/build_date'})
+            if bdata:
+                yield 'LXPM', bdata
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/drvwn/build_id',
+                'version': '/v2/drvwn/build_version',
+                'date': '/v2/drvwn/build_date',
+            })
+            if bdata:
+                yield 'LXPM Windows Driver Bundle', bdata
+            bdata = await self.fetch_grouped_properties({
+                'build': '/v2/drvln/build_id',
+                'version': '/v2/drvln/build_version',
+                'date': '/v2/drvln/build_date',
+            })
+            if bdata:
+                yield 'LXPM Linux Driver Bundle', bdata
+        wc = await self.wc()
+        if category in ('all', 'core') and not components or set(('lxpm', 'core')) & components:
+            sysinf = await wc.grab_json_response('/api/dataset/sys_info')
+            for item in sysinf.get('items', {}):
+                for firm in item.get('firmware', []):
+                    firminfo = {
+                        'version': firm['version'],
+                        'build': firm['build'],
+                        'date': parse_time(firm['release_date']),
+                    }
+                    if firm['type'] == 10:
+                        yield ('LXUM', firminfo)
+        if category in ('all', 'core') and (not components or set(('core', 'fpga')) in components):
+            try:
+                fpga = await self.ipmicmd.raw_command(netfn=0x3a, command=0x6b,
+                                                      data=(0,))
+                fpga = '{0}.{1}.{2}'.format(
+                    *struct.unpack('BBB', fpga['data']))
+                yield 'FPGA', {'version': fpga}
+            except pygexc.IpmiException as ie:
+                if ie.ipmicode != 193:
+                    raise
+        needdiskfirmware = category in ('all', 'disks')
+        needadapterfirmware = category in ('all', 'adapters')
+        needpsufirmware = category in ('all', 'misc')
+        async for firm in self.fetch_agentless_firmware(needdisk=needdiskfirmware, needadp=needadapterfirmware):
+            yield firm
+        if needpsufirmware:        
+            async for firm in self.fetch_psu_firmware():
+                yield firm
+
+    async def detach_remote_media(self):
+        if self._keepalivesession:
+            # log out from the extra session
+            try:
+                await self._keepalivesession.grab_json_response(self.logouturl)
+            except Exception:
+                pass
+            self._keepalivesession = None
+        wc = await self.wc()
+        rt = await wc.grab_json_response('/api/providers/rp_vm_remote_getdisk')
+        if 'items' in rt:
+            slots = []
+            for mount in rt['items']:
+                slots.append(mount['slotId'])
+            for slot in slots:
+                rt = await wc.grab_json_response(
+                    '/api/providers/rp_vm_remote_unmount',
+                    json.dumps({'Slot': str(slot)}))
+                if 'return' not in rt or rt['return'] != 0:
+                    raise Exception("Unrecognized return: " + repr(rt))
+        rdocs = await wc.grab_json_response('/api/providers/rp_rdoc_imagelist')
+        for rdoc in rdocs['items']:
+            filename = rdoc['filename']
+            rt = await wc.grab_json_response('/api/providers/rp_rdoc_unmount',
+                                            {'ImageName': filename})
+            if rt.get('return', 1) != 0:
+                raise Exception("Unrecognized return: " + repr(rt))
+        await self.weblogout()
+
+    async def list_media(self):
+        wc = await self.wc()
+        rt = await wc.grab_json_response('/api/providers/rp_vm_remote_getdisk')
+        if 'items' in rt:
+            for mt in rt['items']:
+                url = mt['remotepath']
+                if url.startswith('//'):
+                    url = 'smb:' + url
+                elif (not url.startswith('http://')
+                      and not url.startswith('https://')):
+                    url = url.replace(':', '')
+                    url = 'nfs://' + url
+                yield media.Media(mt['filename'], url)
+        async for rdoc in self._list_rdoc():
+            yield rdoc
+        await self.weblogout()
+
+    
+    async def _list_rdoc(self):
+        wc = await self.wc()
+        rt = await wc.grab_json_response('/api/providers/rp_rdoc_imagelist')
+        if 'items' in rt:
+            for mt in rt['items']:
+                yield media.Media(mt['filename'])
+
+    async def upload_media(self, filename, progress=None, data=None):
+        wc = await self.wc()
+        await self._refresh_token()
+        numrdocs = 0
+        async for rdoc in self._list_rdoc():
+            numrdocs += 1
+            if rdoc.name == os.path.basename(filename):
+                raise pygexc.InvalidParameterValue(
+                    'An image with that name already exists')
+        if numrdocs >= 2:
+            raise pygexc.InvalidParameterValue(
+                'Maximum number of uploaded media reached')        
+        rsp, statu = await wc.grab_json_response_with_status('/rdocupload')
+        newmode = False
+        if statu == 404:
+            xid = random.randint(0, 1000000000)
+            uploadthread = webclient.FileUploader(
+                wc, '/upload?X-Progress-ID={0}'.format(xid), filename, data)
+        else:
+            newmode = True
+            uploadthread = await webclient.make_uploader(
+                wc, '/rdocupload', filename, data)
+        while not uploadthread.completed():
+            try:
+                await uploadthread.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if newmode:
+                if progress:
+                    progress({'phase': 'upload',
+                          'progress': 100 * await uploadthread.get_progress()})
+            else:
+                rsp = await wc.grab_json_response(
+                    '/upload/progress?X-Progress-ID={0}'.format(xid))
+                if progress and rsp['state'] == 'uploading':
+                    progress({'phase': 'upload',
+                            'progress': 100.0 * rsp['received'] / rsp['size']})
+            await self._refresh_token()
+        rspstatus, rsp, headers = uploadthread.get_response()    
+        if progress:
+            progress({'phase': 'upload',
+                      'progress': 100.0})
+        if 'items' not in rsp or len(rsp['items']) == 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror if wc.lastjsonerror else repr(uploadthread.rspstatus)
+            raise pygexc.PyghmiException('Failed to upload image: ' + errmsg)
+        thepath = rsp['items'][0]['path']
+        thename = rsp['items'][0]['name']
+        writeable = 1 if filename.lower().endswith('.img') else 0
+        addfile = {"Url": thepath, "Protocol": 6, "Write": writeable,
+                   "Credential": ":", "Option": "", "Domain": "",
+                   "WebUploadName": thename}
+        rsp = await wc.grab_json_response('/api/providers/rp_rdoc_addfile',
+                                         addfile)
+        await self._refresh_token()
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unrecognized return: ' + errmsg)
+        ready = False
+        while not ready:
+            await ipmisession.Session.pause(3)
+            rsp = await wc.grab_json_response('/api/providers/rp_rdoc_getfiles')
+            if 'items' not in rsp or len(rsp['items']) == 0:
+                raise Exception(
+                    'Image upload was not accepted, it may be too large')
+            ready = rsp['items'][0]['size'] != 0
+        await self._refresh_token()
+        rsp = await wc.grab_json_response('/api/providers/rp_rdoc_mountall',
+                                         {})
+        await self._refresh_token()
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unrecognized return: ' + errmsg)
+        if progress:
+            progress({'phase': 'complete'})
+        await self.weblogout()
+
+    async def grab_redfish_response_emptyonerror(self, url, body=None, method=None):
+        rsp, status = await self.grab_redfish_response_with_status(url, body, method)
+        if status >= 200 and status < 300:
+            return rsp
+        return {}
+
+    async def grab_redfish_response_with_status(self, url, body=None, method=None):
+        wc = await self.wc()
+        return await wc.grab_json_response_with_status(url, body, headers={
+            'Authorization': 'Basic %s' % base64.b64encode(
+                (self.username + ':' + self.password).encode('utf8')
+            ).decode('utf8'),
+            'Content-Type': 'application/json'}, method=method)
+
+    async def redfish_update_firmware(self, usd, filename, data, progress, bank):
+        if usd['HttpPushUriTargetsBusy']:
+            raise pygexc.TemporaryError('Cannot run multiple updates to same '
+                                        'target concurrently')
+        z = None
+        wrappedfilename = None
+        uxzcount = 0
+        needseek = False
+        if data and hasattr(data, 'read'):
+            if zipfile.is_zipfile(data):
+                needseek = True
+                z = zipfile.ZipFile(data)
+            else:
+                data.seek(0)
+        elif data is None and zipfile.is_zipfile(filename):
+            z = zipfile.ZipFile(filename)
+        if z:
+            for tmpname in z.namelist():
+                if tmpname.startswith('payloads/'):
+                    uxzcount += 1
+                    if tmpname.endswith('.uxz'):
+                        wrappedfilename = tmpname
+        if uxzcount == 1 and wrappedfilename:
+            filename = os.path.basename(wrappedfilename)
+            data = z.open(wrappedfilename)
+        elif needseek:
+            data.seek(0)
+        upurl = usd['HttpPushUri']
+        await self.grab_redfish_response_with_status(
+            '/redfish/v1/UpdateService',
+            {'HttpPushUriTargetsBusy': True}, method='PATCH')
+        try:
+            if bank == 'backup':
+                await self.grab_redfish_response_with_status(
+                    '/redfish/v1/UpdateService',
+                    {'HttpPushUriTargets':
+                        ['/redfish/v1/UpdateService'
+                         '/FirmwareInventory/BMC-Backup']}, method='PATCH')
+            owc = await self.wc()
+            wc = owc.dupe()
+            wc.set_basic_credentials(self.username, self.password)
+            uploadthread = await webclient.make_uploader(wc, upurl, filename,
+                                                  data, formwrap=False)
+            while not uploadthread.completed():
+                try:
+                    await uploadthread.join(3)
+                except asyncio.TimeoutError:
+                    pass
+                if progress:
+                    progress({'phase': 'upload',
+                              'progress': 100 * await uploadthread.get_progress()})
+            rspstatus, rsp, headers = uploadthread.get_response()
+            if rspstatus >= 300 or rspstatus < 200:
+                errmsg = f'Upload failed with HTTP status {rspstatus}'
+                try:
+                    rsp = json.loads(rsp)
+                    errmsg = (
+                        rsp['error']['@Message.ExtendedInfo'][0]['Message'])
+                except Exception:                    
+                    errmsg = errmsg + ': ' + str(rsp)
+                    raise Exception(errmsg)                
+                raise Exception(errmsg)
+            monitorurl = rsp['@odata.id']
+            complete = False
+            phase = "apply"
+            statetype = 'TaskState'
+            # sometimes we get an empty pgress when transitioning from the apply phase to
+            # the validating phase; add a retry here so we don't exit the loop in this case
+            retry = 3
+            while not complete and retry > 0:
+                try:
+                    pgress, status = self.grab_redfish_response_with_status(
+                        monitorurl)
+                except socket.timeout:
+                    pgress = None                
+                if status < 200 or status >= 300:
+                    raise Exception(pgress)
+                if not pgress:
+                    retry -= 1
+                    await ipmisession.Session.pause(3)
+                    continue
+                retry = 3
+                for msg in pgress.get('Messages', []):
+                    if 'Verify failed' in msg.get('Message', ''):
+                        raise Exception(msg['Message'])
+                state = pgress[statetype]
+                if state in ('Cancelled', 'Exception',
+                             'Interrupted', 'Suspended'):
+                    raise Exception(json.dumps(pgress['Messages']))
+                pct = float(pgress['PercentComplete'])
+                complete = state == 'Completed'
+                progress({'phase': phase, 'progress': pct})
+                if complete:
+                    msgs = pgress.get('Messages', [])
+                    if msgs and 'OperationTransitionedToJob' in msgs[0].get('MessageId', ''):
+                        monitorurl = pgress['Messages'][0]['MessageArgs'][0]
+                        phase = 'validating'
+                        statetype = 'JobState'
+                        complete = False
+                        await ipmisession.Session.pause(3)
+                else:
+                    await ipmisession.Session.pause(3)
+            if not retry:
+                raise Exception('Falied to monitor update progress due to excessive timeouts')            
+            if bank == 'backup':
+                return 'complete'
+            return 'pending'
+        finally:
+            self.grab_redfish_response_with_status(
+                '/redfish/v1/UpdateService',
+                {'HttpPushUriTargetsBusy': False}, method='PATCH')
+            self.grab_redfish_response_with_status(
+                '/redfish/v1/UpdateService',
+                {'HttpPushUriTargets': []}, method='PATCH')
+
+    async def set_custom_user_privilege(self, uid, privilege):
+        return await self.set_user_access(uid, privilege)
+
+    async def get_update_status(self):
+        upd = await self.grab_redfish_response_emptyonerror('/redfish/v1/UpdateService')
+        health = upd.get('Status', {}).get('Health', 'bod')
+        if health == 'OK':
+            return 'ready'
+        return 'unavailable'       
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        usd = await self.grab_redfish_response_emptyonerror(
+            '/redfish/v1/UpdateService')
+        rfishurl = usd.get('HttpPushUri', None)
+        if rfishurl:
+            await self.weblogout()
+            return await self.redfish_update_firmware(
+                usd, filename, data, progress, bank)
+        result = None
+        if self.updating:
+            raise pygexc.TemporaryError('Cannot run multiple updates to same '
+                                        'target concurrently')
+        self.updating = True
+        try:
+            result = await self.update_firmware_backend(filename, data, progress,
+                                                  bank)
+        except Exception:
+            self.updating = False
+            await self._refresh_token()
+            wc = await self.wc()
+            await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+                {'UPD_WebCancel': 1}))
+            await self.weblogout()
+            raise
+        self.updating = False
+        await self.weblogout()
+        return result
+
+    async def _refresh_token(self):
+        wc = await self.wc()
+        await self._refresh_token_wc(wc)
+
+    async def _refresh_token_wc(self, wc):
+        await wc.grab_json_response('/api/providers/identity')
+        for cky in wc.cookies:
+                if cky.key == '_csrf_token':
+                    wc.set_header('X-XSRF-TOKEN', cky.value)
+                    wc.vintage = util._monotonic_time()
+                    break
+
+
+    async def set_hostname(self, hostname):
+        wc = await self.wc()
+        await wc.grab_json_response('/api/dataset', {'IMM_HostName': hostname})
+        await wc.grab_json_response('/api/dataset', {'IMM_DescName': hostname})
+        await self.weblogout()
+
+    async def get_hostname(self):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response('/api/dataset/sys_info')
+        await self.weblogout()
+        return rsp['items'][0]['system_name']
+
+    async def update_firmware_backend(self, filename, data=None, progress=None,
+                                bank=None):
+        await self.weblogout()
+        await self._refresh_token()
+        wc = await self.wc()
+        rsv = await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+            {'UPD_WebReserve': 1}))
+        if rsv['return'] == 103:
+            raise Exception('Update already in progress')
+        if rsv['return'] != 0:
+            raise Exception('Unexpected return to reservation: ' + repr(rsv))
+        xid = random.randint(0, 1000000000)
+        uploadthread = await webclient.make_uploader(
+            wc, '/upload?X-Progress-ID={0}'.format(xid), filename, data)
+        uploadstate = None
+        while not uploadthread.completed():
+            try:
+                await uploadthread.join(3)
+            except asyncio.TimeoutError:
+                pass
+            rsp = await wc.grab_json_response(
+                '/upload/progress?X-Progress-ID={0}'.format(xid))
+            if rsp['state'] == 'uploading':
+                progress({'phase': 'upload',
+                          'progress': 100.0 * rsp['received'] / rsp['size']})
+            elif rsp['state'] != 'done':
+                if (rsp.get('status', None) == 413
+                        or uploadthread.rspstatus == 413):
+                    raise Exception('File is larger than supported')
+                raise Exception('Unexpected result:' + repr(rsp))
+            uploadstate = rsp['state']
+            await self._refresh_token()
+        while uploadstate != 'done':
+            rsp = await wc.grab_json_response(
+                '/upload/progress?X-Progress-ID={0}'.format(xid))
+            uploadstate = rsp['state']
+            await self._refresh_token()
+        rsp = json.loads(uploadthread.rsp)
+        if rsp['items'][0]['name'] != os.path.basename(filename):
+            raise Exception('Unexpected response: ' + repr(rsp))
+        progress({'phase': 'validating',
+                  'progress': 0.0})
+        await ipmisession.Session.pause(3)
+        # aggressive timing can cause the next call to occasionally
+        # return 25 and fail
+        await self._refresh_token()
+        rsp = await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+            {'UPD_WebSetFileName': rsp['items'][0]['path']}))
+        if rsp.get('return', 0) in (25, 108):
+            raise Exception('Temporary error validating update, try again')
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unexpected return to set filename: ' + errmsg)
+        await self._refresh_token()
+        progress({'phase': 'validating',
+                  'progress': 25.0})
+        rsp = await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+            {'UPD_WebVerifyUploadFile': 1}))
+        if rsp.get('return', 0) == 115:
+            raise Exception('Update image not intended for this system')
+        elif rsp.get('return', -1) == 108:
+            raise Exception('Temporary error validating update, try again')
+        elif rsp.get('return', -1) == 109:
+            raise Exception('Invalid update file or component does '
+                            'not support remote update')
+        elif rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unexpected return to verify: ' + errmsg)
+        verifystatus = 0
+        verifyuploadfilersp = None
+        while verifystatus != 1:
+            await self._refresh_token()
+            rsp, status = await wc.grab_json_response_with_status(
+                '/api/providers/fwupdate',
+                json.dumps({'UPD_WebVerifyUploadFileStatus': 1}))
+            if not rsp or status != 200 or rsp.get('return', -1) == 2:
+                # The XCC firmware predates the FileStatus api
+                verifyuploadfilersp = rsp
+                break
+            if rsp.get('return', -1) == 109:
+                raise Exception('Invalid update file or component does '
+                                'not support remote update')
+            if rsp.get('return', -1) != 0:
+                errmsg = repr(rsp) if rsp else wc.lastjsonerror
+                raise Exception(
+                    'Unexpected return to verifystate: {0}'.format(errmsg))
+            verifystatus = rsp['status']
+            if verifystatus == 2:
+                raise Exception('Failed to verify firmware image')
+            if verifystatus != 1:
+                ipmisession.Session.pause(1)
+            if verifystatus not in (0, 1, 255):
+                errmsg = repr(rsp) if rsp else wc.lastjsonerror
+                raise Exception(
+                    'Unexpected reply to verifystate: ' + errmsg)
+        progress({'phase': 'validating',
+                  'progress': 99.0})
+        await self._refresh_token()
+        rsp = await wc.grab_json_response('/api/dataset/imm_firmware_success')
+        if len(rsp['items']) != 1:
+            raise Exception('Unexpected result: ' + repr(rsp))
+        firmtype = rsp['items'][0]['firmware_type']
+        if not firmtype:
+            raise Exception('Unknown firmware description returned: ' + repr(
+                rsp['items'][0]) + ' last verify return was: ' + repr(
+                    verifyuploadfilersp) + ' with code {0}'.format(status))
+        if firmtype not in (
+                'TDM', 'WINDOWS DRIV', 'LINUX DRIVER', 'UEFI', 'IMM'):
+            # adapter firmware
+            webid = rsp['items'][0]['webfile_build_id']
+            locations = webid[webid.find('[') + 1:webid.find(']')]
+            locations = locations.split(':')
+            validselectors = set([])
+            for loc in locations:
+                validselectors.add(loc.replace('#', '-'))
+            await self._refresh_token()
+            rsp = await wc.grab_json_response(
+                '/api/function/adapter_update?params=pci_GetAdapterListAndFW')
+            foundselectors = []
+            for adpitem in rsp['items']:
+                selector = '{0}-{1}'.format(adpitem['location'],
+                                            adpitem['slotNo'])
+                if selector in validselectors:
+                    foundselectors.append(selector)
+                    if len(foundselectors) == len(validselectors):
+                        break
+            else:
+                raise Exception('Could not find matching adapter for update')
+            await self._refresh_token()
+            rsp = await wc.grab_json_response('/api/function', json.dumps(
+                {'pci_SetOOBFWSlots': '|'.join(foundselectors)}))
+            if rsp.get('return', -1) != 0:
+                errmsg = repr(rsp) if rsp else wc.lastjsonerror
+                raise Exception(
+                    'Unexpected result from PCI select: ' + errmsg)
+            self.set_property('/v2/ibmc/uefi/force-inventory', 1)
+        else:
+            await self._refresh_token()
+            rsp = await wc.grab_json_response(
+                '/api/dataset/imm_firmware_update')
+            if rsp['items'][0]['upgrades'][0]['id'] != 1:
+                raise Exception('Unexpected answer: ' + repr(rsp))
+        await self._refresh_token()
+        progress({'phase': 'apply',
+                  'progress': 0.0})
+        if bank in ('primary', None):
+            rsp = await wc.grab_json_response(
+                '/api/providers/fwupdate', json.dumps(
+                    {'UPD_WebStartDefaultAction': 1}))
+        elif bank == 'backup':
+            rsp = await wc.grab_json_response(
+                '/api/providers/fwupdate', json.dumps(
+                    {'UPD_WebStartOptionalAction': 2}))
+
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unexpected result starting update: %s' % errmsg)
+        complete = False
+        while not complete:
+            await self._refresh_token()
+            ipmisession.Session.pause(3)
+            rsp = await wc.grab_json_response(
+                '/api/dataset/imm_firmware_progress')
+            progress({'phase': 'apply',
+                      'progress': rsp['items'][0]['action_percent_complete']})
+            if rsp['items'][0]['action_state'] == 'Idle':
+                complete = True
+                break
+            if rsp['items'][0]['action_state'] == 'Complete OK':
+                complete = True
+                if rsp['items'][0]['action_status'] != 0:
+                    raise Exception('Unexpected failure: ' + repr(rsp))
+                break
+            if (rsp['items'][0]['action_state'] == 'In Progress'
+                    and rsp['items'][0]['action_status'] == 2):
+                raise Exception('Unexpected failure: ' + repr(rsp))
+            if rsp['items'][0]['action_state'] != 'In Progress':
+                raise Exception(
+                    'Unknown condition waiting for '
+                    'firmware update: ' + repr(rsp))
+        if bank == 'backup':
+            return 'complete'
+        return 'pending'
+
+    async def add_psu_hwinfo(self, hwmap):
+        wc = await self.wc()
+        psud = await wc.grab_json_response('/api/dataset/imm_power_supplies')
+        if not psud:
+            return
+        for psus in psud['items'][0]['power']:
+            hwmap['PSU {0}'.format(psus['name'])] = {
+                'Wattage': psus['rated_power'],
+                'FRU Number': psus['fru_number'],
+            }
+
+    async def augment_psu_info(self, info, psuname):
+        psud = self.get_cached_data('lenovo_cached_psuhwinfo')
+        if not psud:
+            wc = await self.wc()
+            psud = await wc.grab_json_response(
+                '/api/dataset/imm_power_supplies')
+            if not psud:
+                return
+            self.datacache['lenovo_cached_psuhwinfo'] = (
+                psud, util._monotonic_time())
+        matchname = int(psuname.split(' ')[1])
+        for psus in psud['items'][0]['power']:
+            if psus['name'] == matchname:
+                info['Wattage'] = psus['rated_power']
+                break
+
+    async def get_health(self, summary):
+        try:
+            wc = await self.get_webclient(False)
+        except (socket.timeout, socket.error):
+            wc = None
+        if not wc:
+            summary['health'] = pygconst.Health.Critical
+            summary['badreadings'].append(
+                sdr.SensorReading({'name': 'HTTPS Service',
+                                   'states': ['Unreachable'],
+                                   'state_ids': [3],
+                                   'health': pygconst.Health.Critical,
+                                   'type': 'BMC'}, ''))
+            raise pygexc.BypassGenericBehavior()
+        rsp = await wc.grab_json_response('/api/providers/imm_active_events')
+        if 'items' in rsp and len(rsp['items']) == 0:
+            # The XCC reports healthy, no need to interrogate
+            raise pygexc.BypassGenericBehavior()
+        fallbackdata = []
+        hmap = {
+            'I': pygconst.Health.Ok,
+            'E': pygconst.Health.Critical,
+            'W': pygconst.Health.Warning,
+        }
+        infoevents = False
+        existingevts = set([])
+        for item in rsp.get('items', ()):
+            # while usually the ipmi interrogation shall explain things,
+            # just in case there is a gap, make sure at least the
+            # health field is accurately updated
+            itemseverity = hmap.get(item.get('severity', 'E'),
+                                    pygconst.Health.Critical)
+            if itemseverity == pygconst.Health.Ok:
+                infoevents = True
+                continue
+            if (summary['health'] < itemseverity):
+                summary['health'] = itemseverity
+            if item['cmnid'] == 'FQXSPPW0104J':
+                # This event does not get modeled by the sensors
+                # add a made up sensor to explain
+                fallbackdata.append(
+                    sdr.SensorReading({'name': item['source'],
+                                       'states': ['Not Redundant'],
+                                       'state_ids': [3],
+                                       'health': pygconst.Health.Warning,
+                                       'type': 'Power'}, ''))
+            elif item['cmnid'] == 'FQXSFMA0041K':
+                fallbackdata.append(
+                    sdr.SensorReading({
+                        'name': 'Optane DCPDIMM',
+                        'health': pygconst.Health.Warning,
+                        'type': 'Memory',
+                        'states': [item['message']]},
+                        '')
+                )
+            else:
+                currevt = '{}:{}'.format(item['source'], item['message'])
+                if currevt in existingevts:
+                    continue
+                existingevts.add(currevt)
+                fallbackdata.append(sdr.SensorReading({
+                    'name': item['source'],
+                    'states': [item['message']],
+                    'health': itemseverity,
+                    'type': item['source'],
+                }, ''))
+        if (summary.get('health', pygconst.Health.Ok) == pygconst.Health.Ok
+                and not infoevents):
+            # Fault LED is lit without explanation, mark to encourage
+            # examination
+            summary['health'] = pygconst.Health.Warning
+            if not fallbackdata:
+                fallbackdata.append(sdr.SensorReading({
+                    'name': 'Fault LED',
+                    'states': ['Active'],
+                    'health': pygconst.Health.Warning,
+                    'type': 'LED',
+                }, ''))
+        summary['badreadings'] = fallbackdata
+        if fallbackdata:
+            raise pygexc.BypassGenericBehavior()
+        return fallbackdata
+        # Will use the generic handling for unhealthy systems
+
+    async def get_licenses(self):
+        wc = await self.wc()
+        licdata = await wc.grab_json_response('/api/providers/imm_fod')
+        for lic in licdata.get('items', [{}])[0].get('keys', []):
+            if lic['status'] == 0:
+                yield {'name': lic['feature'], 'state': 'Active'}
+            elif lic['status'] == 10:
+                yield {'name': lic['feature'],
+                       'state': 'Missing required license'}
+
+    async def save_licenses(self, directory):
+        wc = await self.wc()
+        licdata = await wc.grab_json_response('/api/providers/imm_fod')
+        for lic in licdata.get('items', [{}])[0].get('keys', []):
+            licid = ','.join((str(lic['type']), str(lic['id'])))
+            rsp = await wc.grab_json_response(
+                '/api/providers/imm_fod', {'FOD_LicenseKeyExport': licid})
+            filename = rsp.get('FileName', None)
+            if filename:
+                url = '/download/' + filename
+                savefile = os.path.join(directory, filename)
+                wc = await self.wc()
+                fd = webclient.make_downloader(wc, url, savefile)
+                while not fd.completed():
+                    try:
+                        await fd.join(1)
+                    except asyncio.TimeoutError:
+                        pass
+                    await self._refresh_token()
+                yield savefile
+
+    async def delete_license(self, name):
+        wc = await self.wc()
+        licdata = await wc.grab_json_response('/api/providers/imm_fod')
+        for lic in licdata.get('items', [{}])[0].get('keys', []):
+            if lic.get('feature', None) == name:
+                licid = ','.join((str(lic['type']), str(lic['id'])))
+                await wc.grab_json_response(
+                    '/api/providers/imm_fod', {'FOD_LicenseKeyDelete': licid})
+                break
+
+    async def apply_license(self, filename, progress=None, data=None):
+        license_errors = {
+            310: "License is for a different model of system",
+            311: "License is for a different system serial number",
+            312: "License is invalid",
+            313: "License is expired",
+            314: "License usage limit reached",
+        }
+        wc = await self.wc()
+        uploadthread = await webclient.make_uploader(wc, '/upload', filename,
+                                              data=data)
+        await uploadthread.join()
+        rspstatus, rsp, headers = uploadthread.get_response()
+        licpath = rsp.get('items', [{}])[0].get('path', None)
+        if licpath:
+            wc = await self.wc()
+            rsp = await wc.grab_json_response(
+                '/api/providers/imm_fod', {'FOD_LicenseKeyInstall': licpath})
+            if rsp.get('return', 0) in license_errors:
+                raise pygexc.InvalidParameterValue(
+                    license_errors[rsp['return']])
+        async for x in self.get_licenses():
+            yield x
+
+    async def get_user_expiration(self, uid):
+        uid = uid - 1
+        wc = await self.wc()
+        userinfo = await wc.grab_json_response('/api/dataset/imm_users')
+        for user in userinfo['items'][0]['users']:
+            if user['users_user_id'] == uid:
+                days = user['users_pass_left_days']
+                if days == 366:
+                    return 0
+                else:
+                    return days
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/inventory.py b/confluent_server/aiohmi/ipmi/oem/lenovo/inventory.py
new file mode 100755
index 00000000..f2107e1f
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/inventory.py
@@ -0,0 +1,181 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import struct
+
+categories = {}
+
+
+def register_inventory_category(module):
+    c = module.get_categories()
+    for id in c:
+        categories[id] = c[id]
+
+
+class EntryField(object):
+    """Store inventory field parsing options.
+
+    Represents an inventory field and its options for the custom requests to a
+    ThinkServer's BMC.
+
+    :param name: the name of the field
+    :param fmt: the format of the field (see struct module for details)
+    :param include: whether to include the field in the parse output
+    :param mapper: a dictionary mapping values to new values for the parse
+                   output
+    :param valuefunc: a function to be called to change the value in the last
+                      step of the build process.
+    :param presence: whether the field indicates presence. In this case, the
+                     field will not be included. If the value is false, the
+                     item will be discarded.
+    """
+    def __init__(self, name, fmt, include=True, mapper=None, valuefunc=None,
+                 multivaluefunc=False, presence=False):
+        self.name = name
+        self.fmt = fmt
+        self.include = include
+        self.mapper = mapper
+        self.valuefunc = valuefunc
+        self.multivaluefunc = multivaluefunc
+        self.presence = presence
+
+
+# General parameter parsing functions
+def parse_inventory_category(name, info, asrock=False, countable=True):
+    """Parses every entry in an inventory category
+
+    For example: CPU, memory, PCI, drives
+    Expects the first byte to be a count of the number of entries, followed
+    by a list of elements to be parsed by a dedicated parser (below).
+
+    :param name: the name of the parameter (e.g.: "cpu")
+    :param info: a list of integers with raw data read from an IPMI requests
+    :param asrock: a boolean represents if RS160 with asrockrack or not
+    :param countable: whether the data have an entries count field
+    :returns: dict -- a list of entries in the category.
+    """
+    raw = info["data"][1:]
+
+    if name == "cpu" and asrock:
+        raw = info["data"]
+
+    cur = 0
+    if countable:
+        count = bytearray(raw)[cur]
+        cur += 1
+    else:
+        count = 0
+    discarded = 0
+
+    entries = []
+    while cur < len(raw):
+        read, parser = categories[name]["parser"](raw[cur:])
+        cur = cur + read
+        # Account for discarded entries (because they are not present)
+        if parser is None:
+            discarded += 1
+            continue
+        if not countable:
+            # count by myself
+            count += 1
+            parser["index"] = count
+        entries.append(parser)
+
+    # TODO(avidal): raise specific exception to point that there's data left in
+    # the buffer
+    if cur != len(raw):
+        raise Exception
+    # TODO(avidal): raise specific exception to point that the number of
+    # entries is different than the expected
+    if count - discarded != len(entries) and not asrock:
+        raise Exception
+    return entries
+
+
+def parse_inventory_category_entry(raw, fields):
+    """Parses one entry in an inventory category.
+
+    :param raw: the raw data to the entry. May contain more than one entry,
+                only one entry will be read in that case.
+    :param fields: an iterable of EntryField objects to be used for parsing the
+                   entry.
+
+    :returns: dict -- a tuple with the number of bytes read and a dictionary
+                      representing the entry.
+    """
+    r = raw
+
+    obj = {}
+    bytes_read = 0
+    discard = False
+    for field in fields:
+        value = struct.unpack_from(field.fmt, r)[0]
+        read = struct.calcsize(field.fmt)
+        bytes_read += read
+        if bytes_read > len(raw):
+            break
+
+        r = r[read:]
+        # If this entry is not actually present, just parse and then discard it
+        if field.presence and not bool(value):
+            discard = True
+        if not field.include:
+            continue
+
+        if (field.fmt[-1] == "s"):
+            value = value.rstrip(b'\x00\xff')
+        if (field.mapper and value in field.mapper):
+            value = field.mapper[value]
+        if (field.valuefunc):
+            value = field.valuefunc(value)
+
+        if not field.multivaluefunc:
+            obj[field.name] = value
+        else:
+            for key in value:
+                obj[key] = value[key]
+
+    if discard:
+        obj = None
+    return bytes_read, obj
+
+
+def parse_bios_number_entry(raw):
+    """Parses the Bios number given a raw data.
+
+    :param raw: the raw data to the entry.
+
+    :returns: dict -- structure with read current and newest versions
+    """
+    new_major_version = struct.unpack_from("1B", raw, 25)[0]
+    new_minor_version = struct.unpack_from("1B", raw, 26)[0]
+    new_aux = struct.unpack_from("I", raw, 27)[0]
+
+    cur_major_version = struct.unpack_from("1B", raw, 31)[0]
+    cur_minor_version = struct.unpack_from("1B", raw, 32)[0]
+    cur_aux = struct.unpack_from("I", raw, 33)[0]
+
+    new_image_version = "%s.%s.%s" % (
+        str(new_major_version),
+        str(new_minor_version),
+        str(new_aux))
+    cur_image_version = "%s.%s.%s" % (
+        str(cur_major_version),
+        str(cur_minor_version),
+        str(cur_aux))
+
+    return {
+        'new_img_version': new_image_version,
+        'cur_img_version': cur_image_version
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/nextscale.py b/confluent_server/aiohmi/ipmi/oem/lenovo/nextscale.py
new file mode 100644
index 00000000..8549a11f
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/nextscale.py
@@ -0,0 +1,1127 @@
+# Copyright 2016-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import fnmatch
+import struct
+import weakref
+from xml.etree.ElementTree import fromstring as rfromstring
+import zipfile
+
+
+import aiohmi.constants as pygconst
+import aiohmi.exceptions as pygexc
+import aiohmi.ipmi.private.session as ipmisession
+import aiohmi.ipmi.private.util as util
+from aiohmi.ipmi import sdr
+import aiohmi.util.webclient as webclient
+
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+try:
+    range = xrange
+except NameError:
+    pass
+
+
+psutypes = {
+    0x63: 'CFF v3 550W PT',
+    0x64: 'CFF v3 750W PT',
+    0x65: 'CFF v3 750W TT',
+    0x66: 'CFF v3 1100W PT',
+    0x67: 'CFF v3 1600W PT',
+    0x68: 'CFF v3 2000W PT',
+    0x6B: 'CFF v4 500W PT',
+    0x6C: 'CFF v4 750W PT',
+    0x6D: 'CFF v4 750W TT',
+    0x6E: 'CFF v4 1100W PT',
+    0x6F: 'CFF v4 1100W -48Vdc',
+    0x70: 'CFF v4 1100W 200-277Vac/240-380Vdc',
+    0x71: 'CFF v4 1800W PT',
+    0x72: 'CFF v4 2400W PT',
+}
+
+
+def fromstring(inputdata):
+    if b'!entity' in inputdata.lower():
+        raise Exception('!ENTITY not supported in this interface')
+    return rfromstring(inputdata)
+
+
+def stringtoboolean(originput, name):
+    input = originput.lower()
+    try:
+        num = int(input)
+    except ValueError:
+        num = None
+    if 'enabled'.startswith(input) or 'yes'.startswith(input) or num == 1:
+        return True
+    elif 'disabled'.startswith(input) or 'no'.startswith(input) or num == 0:
+        return False
+    raise pygexc.InvalidParameterValue('{0} is an invalid setting for '
+                                       '{1}'.format(originput, name))
+
+
+async def fpc_read_ac_input(ipmicmd):
+    rsp = await ipmicmd.raw_command(netfn=0x32, command=0x90, data=(1,))
+    rsp = rsp['data']
+    if len(rsp) == 6:
+        rsp = b'\x00' + bytes(rsp)
+    return struct.unpack_from('<H', rsp[3:5])[0]
+
+
+async def fpc_read_dc_output(ipmicmd):
+    rsp = await ipmicmd.raw_command(netfn=0x32, command=0x90, data=(2,))
+    rsp = rsp['data']
+    if len(rsp) == 6:
+        rsp = b'\x00' + bytes(rsp)
+    return struct.unpack_from('<H', rsp[3:5])[0]
+
+
+async def fpc_read_fan_power(ipmicmd):
+    rsp = await ipmicmd.raw_command(netfn=0x32, command=0x90, data=(3,))
+    rsp = bytes(rsp['data'])
+    rsp += b'\x00'
+    return struct.unpack_from('<I', rsp[1:])[0] / 100.0
+
+
+async def fpc_read_psu_fan(ipmicmd, number, sz):
+    rsp = await ipmicmd.raw_command(netfn=0x32, command=0xa5, data=(number,))
+    rsp = bytes(rsp['data'])
+    if len(rsp) > 5:
+        return struct.unpack_from('<H', rsp[2:4])[0]
+    else:
+        return struct.unpack_from('<H', rsp[:2])[0]
+
+
+async def fpc_get_psustatus(ipmicmd, number, sz):
+    rsp = await ipmicmd.raw_command(netfn=0x32, command=0x91)
+    mask = 1 << (number - 1)
+    rsp['data'] = bytearray(rsp['data'])
+    if len(rsp['data']) >= 10:
+        tmpdata = rsp['data']
+        rsp['data'] = list(struct.unpack('<HHHHBB', tmpdata[:10]))
+    if len(rsp['data']) == 6:
+        statdata = [0]
+    else:
+        statdata = []
+    statdata += rsp['data']
+    presence = statdata[3] & mask == mask
+    pwrgood = statdata[4] & mask == mask
+    throttle = (statdata[6] | statdata[2]) & mask == mask
+    health = pygconst.Health.Ok
+    states = []
+    if presence and not pwrgood:
+        health = pygconst.Health.Critical
+        states.append('Power input lost')
+    if throttle:
+        health = pygconst.Health.Critical
+        states.append('Throttled')
+    if presence:
+        states.append('Present')
+    else:
+        states.append('Absent')
+        health = pygconst.Health.Critical
+    return (health, states)
+
+
+async def fpc_get_nodeperm(ipmicmd, number, sz):
+    try:
+        rsp = await ipmicmd.raw_command(netfn=0x32, command=0xa7, data=(number,))
+    except pygexc.IpmiException as ie:
+        if ie.ipmicode == 0xd5:  # no node present
+            return (pygconst.Health.Ok, ['Absent'])
+        raise
+    health = pygconst.Health.Ok
+    states = []
+    if len(rsp['data']) == 4:  # different gens handled rc differently
+        rsp['data'] = b'\x00' + bytes(rsp['data'])
+    elif len(rsp['data']) == 6:  # New FPC format
+        rsp['data'] = bytes(rsp['data'][:2]) + bytes(rsp['data'][3:])
+    permdata = bytearray(rsp['data'])
+    perminfo = permdata[1]
+    if sz == 6:  # FPC
+        permfail = (2, 3)
+    else:  # SMM
+        permfail = (2,)
+    if perminfo & 0x20:
+        if permdata[4] in permfail:
+            states.append('Insufficient Power')
+            health = pygconst.Health.Failed
+        elif rsp['data'][3:5] != '\x00\x00' and permdata[4] not in (0, 1):
+            states.append('No Power Permission')
+            health = pygconst.Health.Failed
+    if perminfo & 0x40:
+        states.append('Node Fault')
+        health = pygconst.Health.Failed
+    if rsp['data'][3:5] == '\x00\x00' or permdata[4] == 0:
+        states.append('Absent')
+    return (health, states)
+
+
+async def fpc_read_powerbank(ipmicmd):
+    rsp = await ipmicmd.raw_command(netfn=0x32, command=0xa2)
+    return struct.unpack_from('<H', rsp['data'][3:])[0]
+
+
+async def get_psu_count(ipmicmd, variant):
+    if variant == 0x26:
+        mymsg = await ipmicmd.raw_command(netfn=0x32, command=0xa8)
+        builddata = bytearray(mymsg['data'])
+        if builddata[13] in (3, 6):
+            return 9
+        else:
+            return 6
+    else:
+        return variant & 0xf
+
+
+async def fpc_get_dripstatus(ipmicmd, number, sz):
+    health = pygconst.Health.Ok
+    states = []
+    rsp = await ipmicmd.raw_command(0x34, 5)
+    rdata = bytearray(rsp['data'])
+    number = number - 1
+    if rdata[0] & (1 << number) == 0:
+        states.append('Absent')
+        health = pygconst.Health.Critical
+    if rdata[1] & (1 << number) != 0:
+        states.append('Leak detected')
+        health = pygconst.Health.Critical
+    return (health, states)
+
+
+fpc_sensors = {
+    'AC Power': {
+        'type': 'Power',
+        'units': 'W',
+        'provider': fpc_read_ac_input,
+    },
+    'DC Power': {
+        'type': 'Power',
+        'units': 'W',
+        'provider': fpc_read_dc_output,
+    },
+    'PSU Power Loss': {
+        'type': 'Power',
+        'units': 'W',
+        'provider': fpc_read_dc_output,
+    },
+    'Fan Power': {
+        'type': 'Power',
+        'units': 'W',
+        'provider': fpc_read_fan_power
+    },
+    'PSU Fan Speed': {
+        'type': 'Fan',
+        'units': 'RPM',
+        'provider': fpc_read_psu_fan,
+        'elementsfun': get_psu_count,
+    },
+    'Total Power Capacity': {
+        'type': 'Power',
+        'units': 'W',
+        'provider': fpc_read_powerbank,
+    },
+    'Node Power Permission': {
+        'type': 'Management Subsystem Health',
+        'returns': 'tuple',
+        'units': None,
+        'provider': fpc_get_nodeperm,
+        'elements': 2,
+    },
+    'Power Supply': {
+        'type': 'Power Supply',
+        'returns': 'tuple',
+        'units': None,
+        'elements': True,
+        'provider': fpc_get_psustatus,
+        'elementsfun': get_psu_count,
+    },
+    'Drip Sensor': {
+        'type': 'Management Subsystem Health',
+        'elements': True,
+        'abselements': 2,
+        'returns': 'tuple',
+        'units': None,
+        'provider': fpc_get_dripstatus,
+    }
+}
+
+
+def get_sensor_names(ipmicmd, size):
+    global fpc_sensors
+    for name in fpc_sensors:
+        if size != 6 and name in ('Fan Power', 'Total Power Capacity',
+                                  'DC Power'):
+            continue
+        if size == 6 and name == 'PSU Power Loss':
+            continue
+        if size != 0x26 and name == 'Drip Sensor':
+            continue
+        sensor = fpc_sensors[name]
+
+        if 'abselements' in sensor:
+            for elemidx in range(sensor['abselements']):
+                elemidx += 1
+                yield '{0} {1}'.format(name, elemidx)
+        elif 'elementsfun' in sensor:
+            for elemidx in range(sensor['elementsfun'](ipmicmd, size)):
+                elemidx += 1
+                yield '{0} {1}'.format(name, elemidx)
+        elif 'elements' in sensor:
+            for elemidx in range(sensor['elements'] * (size & 0b11111)):
+                elemidx += 1
+                yield '{0} {1}'.format(name, elemidx)
+        else:
+            yield name
+
+
+def get_sensor_descriptions(ipmicmd, size):
+    global fpc_sensors
+    for name in fpc_sensors:
+        if size != 6 and name in ('Fan Power', 'Total Power Capacity',
+                                  'DC Power'):
+            continue
+        if size == 6 and name == 'PSU Power Loss':
+            continue
+        if size != 0x26 and name == 'Drip Sensor':
+            continue
+        sensor = fpc_sensors[name]
+        if 'abselements' in sensor:
+            for elemidx in range(sensor['abselements']):
+                elemidx += 1
+                yield {'name': '{0} {1}'.format(name, elemidx),
+                       'type': sensor['type']}
+        elif 'elementsfun' in sensor:
+            for elemidx in range(sensor['elementsfun'](ipmicmd, size)):
+                elemidx += 1
+                yield {'name': '{0} {1}'.format(name, elemidx),
+                       'type': sensor['type']}
+        elif 'elements' in sensor:
+            for elemidx in range(sensor['elements'] * (size & 0b11111)):
+                elemidx += 1
+                yield {'name': '{0} {1}'.format(name, elemidx),
+                       'type': sensor['type']}
+        else:
+            yield {'name': name, 'type': sensor['type']}
+
+
+async def get_fpc_firmware(bmcver, ipmicmd, fpcorsmm):
+    mymsg = await ipmicmd.raw_command(netfn=0x32, command=0xa8)
+    builddata = bytearray(mymsg['data'])
+    name = None
+    if fpcorsmm != 6:  # SMM
+        if fpcorsmm >> 5:
+            name = 'SMM2'
+            buildid = '{0}{1}{2}{3}{4}{5}{6}'.format(
+                *[chr(x) for x in builddata[6:13]])
+        else:
+            name = 'SMM'
+            buildid = '{0}{1}{2}{3}{4}{5}{6}'.format(
+                *[chr(x) for x in builddata[5:12]])
+    elif len(builddata) == 8:
+        builddata = builddata[1:]  # discard the 'completion code'
+        name = 'FPC'
+        buildid = '{0:02X}{1}'.format(builddata[-2], chr(builddata[-1]))
+    bmcmajor, bmcminor = [int(x) for x in bmcver.split('.')]
+    bmcver = '{0}.{1:02d}'.format(bmcmajor, bmcminor)
+    yield (name, {'version': bmcver, 'build': buildid})
+    if fpcorsmm == 6:
+        yield ('PSOC', {'version': '{0}.{1}'.format(builddata[2],
+                                                    builddata[3])})
+    else:
+        yield ('PSOC', {'version': '{0}.{1}'.format(builddata[3],
+                                                    builddata[4])})
+
+
+async def get_sensor_reading(name, ipmicmd, sz):
+    value = None
+    sensor = None
+    health = pygconst.Health.Ok
+    states = []
+    if name in fpc_sensors and 'elements' not in fpc_sensors[name]:
+        sensor = fpc_sensors[name]
+        value = await sensor['provider'](ipmicmd)
+    else:
+        bnam, _, idx = name.rpartition(' ')
+        idx = int(idx)
+        if bnam in fpc_sensors:
+            max = -1
+            if 'abselements' in fpc_sensors[bnam]:
+                max = fpc_sensors[bnam]['abselements']
+            elif 'elementsfun' in fpc_sensors[bnam]:
+                max = 99
+            elif 'elements' in fpc_sensors[bnam]:
+                max = fpc_sensors[bnam]['elements'] * sz
+            if idx <= max:
+                sensor = fpc_sensors[bnam]
+                if 'returns' in sensor:
+                    health, states = await sensor['provider'](ipmicmd, idx, sz)
+                else:
+                    value = await sensor['provider'](ipmicmd, idx, sz)
+    if sensor is not None:
+        return sdr.SensorReading({'name': name, 'imprecision': None,
+                                  'value': value, 'states': states,
+                                  'state_ids': [], 'health': health,
+                                  'type': sensor['type']},
+                                 sensor['units'])
+    raise Exception('Sensor not found: ' + name)
+
+
+class SMMClient(object):
+
+    def __init__(self, ipmicmd, variant):
+        self.smm_variant = variant
+        self.ipmicmd = weakref.proxy(ipmicmd)
+        self.smm = ipmicmd.bmc
+        self.username = ipmicmd.ipmi_session.userid
+        self.password = ipmicmd.ipmi_session.password
+        self._wc = None
+
+    async def clear_bmc_configuration(self):
+        await self.ipmicmd.raw_command(0x32, 0xad)
+
+    rulemap = {
+        'password_reuse_count': 'passwordReuseCheckNum',
+        'password_change_interval': 'passwordChangeInterval',
+        'password_expiration': 'passwordDurationDays',
+        'password_login_failures': 'passwordFailAllowdNum',
+        'password_min_length': 'passwordMinLength',
+        'password_lockout_period': 'passwordLockoutTimePeriod',
+        'timezone': 'timeZone',
+    }
+
+    fanmodes = {
+        1: 'Capped_20%',
+        2: 'Capped_25%',
+        3: 'Capped_30%',
+        4: 'Capped_45%',
+        0: 'Normal',
+        5: 'Boosted',
+    }
+
+    async def get_bmc_configuration(self, variant):
+        settings = {}
+        wc = self.wc
+        wc.request(
+            'POST', '/data',
+            ('get=passwordMinLength,passwordForceChange,passwordDurationDays,'
+             'passwordExpireWarningDays,passwordChangeInterval,'
+             'passwordReuseCheckNum,passwordFailAllowdNum,'
+             'passwordLockoutTimePeriod,timeZone'))
+        rsp = wc.getresponse()
+        rspbody = rsp.read()
+        accountinfo = fromstring(rspbody)
+        for rule in self.rulemap:
+            ruleinfo = accountinfo.find(self.rulemap[rule])
+            if ruleinfo is not None:
+                try:
+                    val = int(ruleinfo.text)
+                except ValueError:
+                    val = ruleinfo.text
+                settings[rule] = {'value': val}
+        dwc = await self.ipmicmd.raw_command(0x32, 0x94)
+        dwc = bytearray(dwc['data'])
+        if len(dwc) not in (3, 4) or dwc[0] == 1:
+            rsp = await self.ipmicmd.raw_command(0x34, 3)
+            fanmode = self.fanmodes[bytearray(rsp['data'])[0]]
+            settings['fanspeed'] = {
+                'value': fanmode, 'default': 'Normal',
+                'help': ('Adjust the fan speed of the D2 Chassis. Capped '
+                         'settings will reduce fan speed for better acoustic '
+                         'experience at the expense of performance.  Normal '
+                         'is using the Lenovo engineered cooling adjustments '
+                         'across the full range. Boosted adds fanspeed to '
+                         'the Normal response to provide more aggressive '
+                         'cooling.'),
+                'possible': [self.fanmodes[x] for x in self.fanmodes]}
+        powercfg = await self.ipmicmd.raw_command(0x32, 0xa2)
+        powercfg = bytearray(powercfg['data'])
+        if len(powercfg) == 5:
+            if variant and variant >> 5:
+                powercfg = powercfg[-2:]
+            else:
+                powercfg = powercfg[1:]
+        val = powercfg[0]
+        if val == 2:
+            val = 'N+N'
+        elif val == 1:
+            val = 'N+1'
+        elif val == 0:
+            val = 'Disable'
+        settings['power_redundancy'] = {
+            'default': 'N+1',
+            'value': val,
+            'possible': ['N+N', 'N+1', 'Disable'],
+            'help': ('Configures allowed power budget according to expected '
+                     'redundancy. If N+1, power caps will be set to keep '
+                     'servers from using more power than the installed power '
+                     'supplies could supply if one fails.  If disabled, '
+                     'power budget is set to allow nodes to exceed the '
+                     'capacity of a single power supply')
+        }
+        ovs = powercfg[1]
+        if ovs == 1:
+            ovs = 'Enable'
+        elif ovs == 0:
+            ovs = 'Disable'
+        settings['power_oversubscription'] = {
+            'default': 'Enable',
+            'value': ovs,
+            'possible': ['Enable', 'Disable'],
+            'help': ('In redundant power configuration, permit the power '
+                     'budget to exceed the capacity of a single power supply '
+                     'so long as both power supplies are functioning. This '
+                     'excess is limited to an amount that the remaining power '
+                     'supply can sustain for a brief period of time in the '
+                     'event of losing the other. This excess will be removed '
+                     'at the moment a power supply fails so that power '
+                     'delivery is at the sustained capacity of the remaining '
+                     'supplies.')
+        }
+        try:
+            numbays = 12
+            try:
+                chassiscapinfo = await self.ipmicmd.raw_command(
+                    0x32, 0x9d, data=[13])
+            except pygexc.IpmiException as e:
+                if e.ipmicode == 201:  # this must be a 2U
+                    numbays = 4
+                    chassiscapinfo = await self.ipmicmd.raw_command(
+                        0x32, 0x9d, data=[5])
+                else:
+                    raise
+            retoffset = 0
+            if len(chassiscapinfo['data']) > 10:
+                retoffset = 1
+            chassiscapstate = await self.ipmicmd.raw_command(
+                0x32, 0xa0, data=[numbays + 1])
+            capstate = bool(chassiscapstate['data'][retoffset])
+            capmin, capmax, protcap, usercap, thermcap = struct.unpack(
+                '<HHHHH', chassiscapinfo['data'][retoffset:retoffset + 10])
+            settings['chassis_user_cap'] = {
+                'value': usercap,
+                'help': 'Specify a maximum wattage to consume, this specific '
+                        'system implements a range from {0} to {1}.'.format(
+                            capmin, capmax)
+            }
+            settings['chassis_user_cap_active'] = {
+                'value': 'Enable' if capstate else 'Disable',
+                'help': 'Specify whether the user capping setting should be '
+                        'used or not at the chassis level.',
+            }
+            for baynum in range(numbays):
+                baynum += 1
+                try:
+                    baycapinfo = await self.ipmicmd.raw_command(
+                        0x32, 0x9d, data=[baynum])
+                except Exception:
+                    continue
+                capmin, capmax, protcap, usercap, thermcap = struct.unpack(
+                    '<HHHHH', baycapinfo['data'][retoffset:retoffset + 10])
+                settings['bay{0}_user_cap'.format(baynum)] = {
+                    'value': usercap,
+                    'help': 'Specify a maximum wattage for the server in bay '
+                            '{0} to consume, this specific system implements '
+                            'a range from {1} to {2}'.format(
+                                baynum, capmin, capmax)
+                }
+                settings['bay{0}_protective_cap'.format(baynum)] = {
+                    'value': protcap,
+                    'help': 'Show the current protective cap for the system '
+                            'in bay {0}'.format(baynum)
+                }
+                try:
+                    baycapstate = await self.ipmicmd.raw_command(
+                        0x32, 0xa0, data=[baynum])
+                except Exception:
+                    continue
+                baycapstate = bool(baycapstate['data'][retoffset])
+                settings['bay{0}_user_cap_active'.format(baynum)] = {
+                    'value': 'Enable' if baycapstate else 'Disable',
+                    'help': 'Specify whether the user capping setting should '
+                            'be used or not for bay {0}'.format(baynum),
+                    'possible': ['Enable', 'Disable'],
+                }
+        except Exception:
+            pass
+        try:
+            dhcpsendname = await self.ipmicmd.raw_command(0xc, 0x2,
+                                                     data=[1, 0xc5, 0, 0])
+            dhcpsendname = bytearray(dhcpsendname['data'])
+            dhcpsendname = 'Enable' if dhcpsendname[1] == 1 else 'Disable'
+            settings['dhcp_sends_hostname'] = {
+                'value': dhcpsendname,
+                'help': ('Have the device send  hostname as part of its '
+                         'DHCP client requests in option 12'),
+                'possible': ['Enable', 'Disable']
+            }
+            dhcpsendvci = await self.ipmicmd.raw_command(0xc, 0x2,
+                                                    data=[1, 0xc6, 0, 0])
+            dhcpsendvci = bytearray(dhcpsendvci['data'])
+            dhcpsendvci = 'Enable' if dhcpsendvci[1] == 1 else 'Disable'
+            settings['dhcp_sends_vendor_class_identifier'] = {
+                'value': dhcpsendvci,
+                'possible': ['Enable', 'Disable'],
+                'help': ('Have the device send vendor class identifier '
+                         'as part of its DHCP requests in option 60')
+            }
+        except Exception:
+            pass
+        try:
+            chassisvpd = await self.ipmicmd.raw_command(0x32, 0xb0, data=(5, 0))
+            chassisvpd = bytearray(chassisvpd['data'][2:])
+            chassisvpd = bytes(chassisvpd).strip()
+            if not isinstance(chassisvpd, str):
+                chassisvpd = chassisvpd.decode('utf8')
+            settings['chassis_model'] = {
+                'value': chassisvpd,
+                'help': ('Configure the chassis model number')
+            }
+        except Exception:
+            pass
+        try:
+            chassisvpd = await self.ipmicmd.raw_command(0x32, 0xb0, data=(5, 1))
+            chassisvpd = bytearray(chassisvpd['data'][2:])
+            chassisvpd = bytes(chassisvpd).strip()
+            if not isinstance(chassisvpd, str):
+                chassisvpd = chassisvpd.decode('utf8')
+            settings['chassis_serial'] = {
+                'value': chassisvpd,
+                'help': ('Configure the chassis serial number')
+            }
+        except Exception:
+            pass
+        return settings
+
+    async def set_bay_cap(self, baynum, val):
+        payload = struct.pack('<BH', baynum, int(val))
+        await self.ipmicmd.raw_command(0x32, 0x9e, data=payload)
+
+    async def augment_zerofru(self, zerofru, variant):
+        if variant & 0x20 != 0x20:
+            return
+        model = (await self.ipmicmd.raw_command(
+            netfn=0x32, command=0xb0, data=[5, 11]))['data'][2:]
+        zerofru['Product name'] = bytes(model).strip()
+        zerofru['Manufacturer'] = 'Lenovo'
+
+    async def set_bay_cap_active(self, baynum, val):
+        currstate = await self.ipmicmd.raw_command(0x32, 0xa0, data=[baynum])
+        currstate = currstate['data']
+        if len(currstate) == 5:
+            currstate = currstate[1:]
+        savemode = currstate[3]
+        enable = val.lower().startswith('enable')
+        payload = [baynum, 1 if enable else 0, savemode]
+        await self.ipmicmd.raw_command(0x32, 0x9f, data=payload)
+
+    async def set_bmc_configuration(self, changeset, variant):
+        rules = []
+        powercfg = [None, None]
+        sendhost = None
+        sendvci = None
+        newserial = None
+        newmodel = None
+        for key in changeset:
+            if not key:
+                raise pygexc.InvalidParameterValue('Empty key is invalid')
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            for rule in self.rulemap:
+                if fnmatch.fnmatch(rule, key.lower()):
+                    rules.append('{0}:{1}'.format(
+                        self.rulemap[rule], changeset[key]['value']))
+            if fnmatch.fnmatch('power_redundancy', key.lower()):
+                if 'n+n'.startswith(changeset[key]['value'].lower()):
+                    powercfg[0] = 2
+                elif 'n+1'.startswith(changeset[key]['value'].lower()):
+                    powercfg[0] = 1
+                elif 'disable'.startswith(changeset[key]['value'].lower()):
+                    powercfg[0] = 0
+            if fnmatch.fnmatch('power_oversubscription', key.lower()):
+                ovs = changeset[key]['value']
+                ovs = stringtoboolean(changeset[key]['value'],
+                                      'power_oversubscription')
+                powercfg[1] = 1 if ovs else 0
+            if fnmatch.fnmatch('dhcp_sends_hostname', key.lower()):
+                sendhost = changeset[key]['value']
+                sendhost = stringtoboolean(changeset[key]['value'],
+                                           'dhcp_sends_hostname')
+            if fnmatch.fnmatch(
+                    'dhcp_sends_vendor_class_identifier', key.lower()):
+                sendvci = changeset[key]['value']
+                sendvci = stringtoboolean(
+                    changeset[key]['value'],
+                    'dhcp_sends_vendor_class_identifier')
+            if fnmatch.fnmatch('chassis_serial', key.lower()):
+                newserial = changeset[key]['value']
+            if fnmatch.fnmatch('chassis_model', key.lower()):
+                newmodel = changeset[key]['value']
+            # Variant low 8 bits is the height in U of chassis, so double that
+            #  to get maxbays
+            numbays = (self.smm_variant & 0x0f) << 1
+            for bayn in range(1, numbays + 1):
+                if fnmatch.fnmatch('bay{0}_user_cap'.format(bayn),
+                                   key.lower()):
+                    self.set_bay_cap(bayn, changeset[key]['value'])
+                if fnmatch.fnmatch(
+                        'bay{0}_user_cap_active'.format(bayn), key.lower()):
+                    self.set_bay_cap_active(bayn, changeset[key]['value'])
+            if fnmatch.fnmatch('chassis_user_cap', key.lower()):
+                self.set_bay_cap(numbays + 1, changeset[key]['value'])
+            if fnmatch.fnmatch('chassis_user_cap_active', key.lower()):
+                self.set_bay_cap_active(numbays + 1, changeset[key]['value'])
+            if fnmatch.fnmatch('fanspeed', key.lower()):
+                for mode in self.fanmodes:
+                    byteval = mode
+                    mode = self.fanmodes[mode]
+                    if changeset[key]['value'].lower() == mode.lower():
+                        await self.ipmicmd.raw_command(
+                            0x32, 0x9b, data=[byteval])
+                        break
+                else:
+                    raise pygexc.InvalidParameterValue(
+                        '{0} not a valid mode for fanspeed'.format(
+                            changeset[key]['value']))
+        if rules:
+            rules = 'set={0}'.format(','.join(rules))
+            wc = self.wc
+            wc.request('POST', '/data', rules)
+            wc.getresponse().read()
+        if powercfg != [None, None]:
+            if variant != 6:
+                if None in powercfg:
+                    currcfg = await self.ipmicmd.raw_command(0x32, 0xa2)
+                    currcfg = bytearray(currcfg['data'])
+                    if variant and variant >> 5 and len(currcfg) == 5:
+                        currcfg = currcfg[-2:]
+                    if powercfg[0] is None:
+                        powercfg[0] = currcfg[0]
+                    if powercfg[1] is None:
+                        powercfg[1] = currcfg[1]
+                await self.ipmicmd.raw_command(0x32, 0xa3, data=powercfg)
+            elif variant == 6:
+                if powercfg[0] is not None:
+                    await self.ipmicmd.raw_command(0x32, 0xa3, data=powercfg[:1])
+                if powercfg[1] is not None:
+                    await self.ipmicmd.raw_command(0x32, 0x9c, data=powercfg[1:])
+        if sendhost is not None:
+            sendhost = 1 if sendhost else 0
+            await self.ipmicmd.raw_command(0xc, 1, data=[1, 0xc5, sendhost])
+        if sendvci is not None:
+            sendvci = 1 if sendvci else 0
+            await self.ipmicmd.raw_command(0xc, 1, data=[1, 0xc6, sendvci])
+        if newserial:
+            newserial = newserial.ljust(10).encode('utf8')
+            cmdata = b'\x05\x01' + newserial
+            await self.ipmicmd.raw_command(0x32, 0xaf, data=cmdata)
+        if newmodel:
+            newmodel = newmodel.ljust(10).encode('utf8')
+            cmdata = b'\x05\x00' + newmodel
+            await self.ipmicmd.raw_command(0x32, 0xaf, data=cmdata)
+
+    async def set_user_priv(self, uid, priv):
+        if priv.lower() == 'administrator':
+            rsp = await self.ipmicmd.raw_command(netfn=6, command=0x46, data=(uid,))
+            username = bytes(rsp['data']).rstrip(b'\x00')
+            if not isinstance(username, str):
+                username = username.decode('utf8')
+            wc = self.wc
+            wc.request(
+                'POST', '/data', 'set=user({0},1,{1},511,,4,15,0)'.format(
+                    uid, username))
+            rsp = wc.getresponse()
+            rsp.read()
+
+    async def reseat_bay(self, bay):
+        bay = int(bay)
+        if bay == -1:
+            await self.ipmicmd.raw_command(0x32, 0xf5)
+            return
+        if bay % 2 == 0:
+            # even node may be unable to reseat based on shared io
+            try:
+                rsp = await self.ipmicmd.raw_command(0x32, 0xc5, data=[1])
+            except Exception:
+                rsp = {'data': [1]}
+            rsp['data'] = bytearray(rsp['data'])
+            if rsp['data'][0] == 2:  # shared io
+                try:
+                    rsp = await self.ipmicmd.raw_command(0x32, 0xa7, data=[bay - 1])
+                except Exception:
+                    raise Exception('Shared IO detected trying to reseat {}, '
+                                    'but unable to determine status of '
+                                    'partner bay {}'.format(
+                                        bay, bay - 1))               
+                rsp['data'] = bytearray(rsp['data'])
+                if rsp['data'][1] == 0x80:
+                    raise Exception('Unable to reseat bay {0} due to bay {1} '
+                                    'being on with shared IO'.format(
+                                        bay, bay - 1))
+        await self.ipmicmd.raw_command(netfn=0x32, command=0xa4,
+                                  data=[bay, 2])
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False,
+                            variant=None):
+        if variant == 6:
+            raise Exception('Service data not supported on FPC')
+        rsp = await self.ipmicmd.raw_command(netfn=0x32, command=0xb1, data=[0])
+        if bytearray(rsp['data'])[0] != 0:
+            raise Exception("Service data generation already in progress")
+        rsp = await self.ipmicmd.raw_command(netfn=0x34, command=0x12, data=[0])
+        if bytearray(rsp['data'])[0] != 0:
+            raise Exception("Service data generation already in progress")
+        rsp['data'] = b'\x01'
+        initpct = 1.0
+        if progress:
+            progress({'phase': 'initializing', 'progress': initpct})
+        while bytearray(rsp['data'])[0] != 0:
+            ipmisession.Session.pause(3)
+            initpct += 3.0
+            if initpct > 99.0:
+                initpct = 99.0
+            rsp = await self.ipmicmd.raw_command(netfn=0x34, command=0x12, data=[1])
+            if progress:
+                progress({'phase': 'initializing', 'progress': initpct})
+        wc = self.wc
+        if wc is None:
+            raise Exception("Failed to connect to web api")
+        if variant and variant >> 5:
+            url = '/preview/smm2-ffdc.tgz?ST1={0}'.format(wc.st1)
+        else:
+            url = '/preview/smm-ffdc.tgz?ST1={0}'.format(wc.st1)
+        if autosuffix and not savefile.endswith('.tgz'):
+            savefile += '-smm-ffdc.tgz'
+        fd = webclient.make_downloader(wc, url, savefile)
+        while not fd.completed():
+            try:
+                await fd.join(1)
+            except asyncio.TimeoutError:
+                pass
+            if progress and await fd.get_progress():
+                progress({'phase': 'download',
+                          'progress': 100 * await fd.get_progress()})
+        if progress:
+            progress({'phase': 'complete'})
+        return savefile
+
+    async def process_fru(self, fru):
+        smmv1 = self.smm_variant & 0xf0 == 0
+        # TODO(jjohnson2): can also get EIOM, SMM, and riser data if warranted
+        snum = bytes(await self.ipmicmd.raw_command(
+            netfn=0x32, command=0xb0, data=(5, 1))['data'][:])
+        mnum = bytes(await self.ipmicmd.raw_command(
+            netfn=0x32, command=0xb0, data=(5, 0))['data'][:])
+        if not smmv1:
+            snum = snum[2:]
+            mnum = mnum[2:]
+        fru['Serial Number'] = snum.strip(b' \x00\xff').replace(b'\xff', b'')
+        fru['Model'] = mnum.strip(b' \x00\xff').replace(b'\xff', b'')
+        return fru
+
+    def get_webclient(self):
+        cv = self.ipmicmd.certverify
+        wc = webclient.SecureHTTPConnection(self.smm, 443, verifycallback=cv)
+        wc = webclient.WebConnection(self.smm, 443, verifycallback=cv)
+        wc.vintage = util._monotonic_time()
+        wc.connect()
+        loginform = urlencode(
+            {
+                'user': self.username,
+                'password': self.password
+            }
+        )
+        wc.request('POST', '/data/login', loginform)
+        rsp = wc.getresponse()
+        if rsp.status != 200:
+            raise Exception(rsp.read())
+        authdata = rsp.read()
+        authdata = fromstring(authdata)
+        for data in authdata.findall('authResult'):
+            if int(data.text) != 0:
+                raise Exception("Firmware update already in progress")
+        for data in authdata.findall('forwardUrl'):
+            if 'renew' in data.text:
+                raise Exception("Account password has expired on remote "
+                                "device")
+        wc.st1 = None
+        wc.st2 = None
+        for data in authdata.findall('st1'):
+            wc.st1 = data.text
+        for data in authdata.findall('st2'):
+            wc.st2 = data.text
+        if not wc.st2:
+            # This firmware puts tokens in the html file, parse that
+            wc.request('GET', '/index.html')
+            rsp = wc.getresponse()
+            if rsp.status != 200:
+                raise Exception(rsp.read())
+            indexhtml = rsp.read()
+            if not isinstance(indexhtml, str):
+                indexhtml = indexhtml.decode('utf8')
+            for line in indexhtml.split('\n'):
+                if '"ST1"' in line:
+                    wc.st1 = line.split()[-1].replace(
+                        '"', '').replace(',', '')
+                if '"ST2"' in line:
+                    wc.st2 = line.split()[-1].replace(
+                        '"', '').replace(',', '')
+        if not wc.st2:
+            wc.request('GET', '/scripts/index.ajs')
+            rsp = wc.getresponse()
+            body = rsp.read()
+            if rsp.status != 200:
+                raise Exception(body)
+            if not isinstance(body, str):
+                body = body.decode('utf8')
+            for line in body.split('\n'):
+                if '"ST1"' in line:
+                    wc.st1 = line.split()[-1].replace(
+                        '"', '').replace(',', '')
+                if '"ST2"' in line:
+                    wc.st2 = line.split()[-1].replace(
+                        '"', '').replace(',', '')
+        if not wc.st2:
+            raise Exception('Unable to locate ST2 token')
+        wc.set_header('ST2', wc.st2)
+        return wc
+
+    def set_hostname(self, hostname):
+        wc = self.wc
+        wc.request('POST', '/data', 'set=hostname:' + hostname)
+        rsp = wc.getresponse()
+        if rsp.status != 200:
+            raise Exception(rsp.read())
+        rsp.read()
+        self.logout()
+
+    def get_hostname(self):
+        currinfo = self.get_netinfo()
+        self.logout()
+        for data in currinfo.find('netConfig').findall('hostname'):
+            return data.text
+
+    def get_netinfo(self):
+        wc = self.wc
+        wc.request('POST', '/data', 'get=hostname')
+        rsp = wc.getresponse()
+        data = rsp.read()
+        if rsp.status == 400:
+            wc.request('POST', '/data?get=hostname', '')
+            rsp = wc.getresponse()
+            data = rsp.read()
+        if rsp.status != 200:
+            raise Exception(data)
+        currinfo = fromstring(data)
+        return currinfo
+
+    def set_domain(self, domain):
+        wc = self.wc
+        wc.request('POST', '/data', 'set=dnsDomain:' + domain)
+        rsp = wc.getresponse()
+        if rsp.status != 200:
+            raise Exception(rsp.read())
+        rsp.read()
+        self.logout()
+
+    def get_domain(self):
+        currinfo = self.get_netinfo()
+        self.logout()
+        for data in currinfo.find('netConfig').findall('dnsDomain'):
+            return data.text
+
+    def get_ntp_enabled(self, variant):
+        wc = self.wc
+        wc.request('POST', '/data', 'get=ntpOpMode')
+        rsp = wc.getresponse()
+        info = fromstring(rsp.read())
+        self.logout()
+        for data in info.findall('ntpOpMode'):
+            return data.text == '1'
+
+    def set_ntp_enabled(self, enabled):
+        wc = self.wc
+        wc.request('POST', '/data', 'set=ntpOpMode:{0}'.format(
+            1 if enabled else 0))
+        rsp = wc.getresponse()
+        result = rsp.read()
+        if not isinstance(result, str):
+            result = result.decode('utf8')
+        self.logout()
+        if '<status>ok</status>' not in result:
+            raise Exception("Unrecognized result: " + result)
+
+    def set_ntp_server(self, server, index):
+        wc = self.wc
+        wc.request('POST', '/data', 'set=ntpServer{0}:{1}'.format(
+            index + 1, server))
+        rsp = wc.getresponse()
+        result = rsp.read()
+        if not isinstance(result, str):
+            result = result.decode('utf8')
+        if '<status>ok</status>' not in result:
+            raise Exception("Unrecognized result: " + result)
+        self.logout()
+        return True
+
+    def get_ntp_servers(self):
+        wc = self.wc
+        wc.request(
+            'POST', '/data', 'get=ntpServer1,ntpServer2,ntpServer3')
+        rsp = wc.getresponse()
+        result = fromstring(rsp.read())
+        srvs = []
+        for data in result.findall('ntpServer1'):
+            srvs.append(data.text)
+        for data in result.findall('ntpServer2'):
+            srvs.append(data.text)
+        for data in result.findall('ntpServer3'):
+            srvs.append(data.text)
+        self.logout()
+        return srvs
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        if progress is None:
+            def progress(x):
+                return True
+        z = None
+        if data and hasattr(data, 'read'):
+            if zipfile.is_zipfile(data):
+                z = zipfile.ZipFile(data)
+            else:
+                data.seek(0)
+        elif data is None and zipfile.is_zipfile(filename):
+            z = zipfile.ZipFile(filename)
+        if z:
+            for tmpname in z.namelist():
+                if tmpname.endswith('.rom'):
+                    filename = tmpname
+                    data = z.open(filename)
+                    break
+        progress({'phase': 'upload', 'progress': 0.0})
+        wc = self.wc
+        wc.request('POST', '/data', 'set=fwType:10')  # SMM firmware
+        rsp = wc.getresponse()
+        rsp.read()
+        url = '/fwupload/fwupload.esp?ST1={0}'.format(wc.st1)
+        fu = await webclient.make_uploader(
+            wc, url, filename, data, formname='fileUpload',
+            otherfields={'preConfig': 'on'})
+        while not fu.completed():
+            try:
+                await fu.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({'phase': 'upload',
+                          'progress': 100 * await fu.get_progress()})
+        progress({'phase': 'validating', 'progress': 0.0})
+        url = '/data'
+        wc.request('POST', url, 'get=fwVersion,spfwInfo')
+        rsp = wc.getresponse()
+        rsp.read()
+        if rsp.status != 200:
+            raise Exception('Error validating firmware')
+        progress({'phase': 'apply', 'progress': 0.0})
+        wc.request('POST', '/data', 'set=securityrollback:1')
+        wc.getresponse().read()
+        wc.request('POST', '/data', 'set=fwUpdate:1')
+        rsp = wc.getresponse()
+        rsp.read()
+        complete = False
+        tries = 0
+        while not complete:
+            ipmisession.Session.pause(3)
+            wc.request('POST', '/data', 'get=fwProgress,fwUpdate')
+            try:
+                rsp = wc.getresponse()
+                progdata = rsp.read()
+            except Exception:
+                if tries > 2:
+                     break
+                tries += 1
+                continue
+            if rsp.status != 200:
+                raise Exception('Error applying firmware')
+            progdata = fromstring(progdata)
+            if progdata.findall('fwUpdate')[0].text == 'invalid signature':
+                raise Exception('Firmware signature invalid')
+            percent = float(progdata.findall('fwProgress')[0].text)
+
+            progress({'phase': 'apply',
+                      'progress': percent})
+            complete = percent >= 100.0
+        return 'complete'
+
+    def get_inventory_descriptions(self, ipmicmd, variant):
+        if variant >> 5 == 0:
+            return
+        psucount = get_psu_count(ipmicmd, variant)
+        for idx in range(psucount):
+            yield 'PSU {}'.format(idx + 1)
+
+    def get_inventory_of_component(self, ipmicmd, component):
+        psuidx = int(component.replace('PSU ', ''))
+        return self.get_psu_info(ipmicmd, psuidx)
+
+    async def get_psu_info(self, ipmicmd, psunum):
+        psuinfo = await ipmicmd.raw_command(0x34, 0x6, data=(psunum,))
+        psuinfo = bytearray(psuinfo['data'])
+        psutype = struct.unpack('<H', psuinfo[23:25])[0]
+        psui = {}
+        if psuinfo[0] != 1:
+            return {'Model': 'Unavailable'}
+        psui['Revision'] = psuinfo[34]
+        psui['Description'] = psutypes.get(
+            psutype, 'Unknown ({})'.format(psutype))
+        psui['Part Number'] = str(psuinfo[35:47].strip(
+            b' \x00\xff').decode('utf8'))
+        psui['FRU Number'] = str(psuinfo[47:59].strip(
+            b' \x00\xff').decode('utf8'))
+        psui['Serial Number'] = str(psuinfo[59:71].strip(
+            b' \x00\xff').decode('utf8'))
+        psui['Header Code'] = str(psuinfo[71:75].strip(
+            b' \x00\xff').decode('utf8'))
+        psui['Vendor'] = str(psuinfo[25:29].strip(
+            b' \x00\xff').decode('utf8'))
+        psui['Manufacturing Date'] = '20{}-W{}'.format(
+            psuinfo[77:79].decode('utf8'), psuinfo[75:77].decode('utf8'))
+        psui['Primary Firmware Version'] = '{:x}.{:x}'.format(
+            psuinfo[80], psuinfo[79])
+        psui['Secondary Firmware Version'] = '{:x}.{:x}'.format(
+            psuinfo[82], psuinfo[81])
+        psui['Model'] = str(psuinfo[5:23].strip(b' \x00\xff').decode('utf8'))
+        psui['Manufacturer Location'] = str(
+            psuinfo[83:85].strip(b' \x00\xff').decode('utf8'))
+        psui['Barcode'] = str(psuinfo[85:108].strip(
+            b' \x00\xff').decode('utf8'))
+        return psui
+
+    def logout(self):
+        wc = self.wc
+        wc.request('POST', '/data/logout', None)
+        rsp = wc.getresponse()
+        rsp.read()
+        self._wc = None
+
+    async def wc(self):
+        if (not self._wc or self._wc.broken
+                or self._wc.vintage < util._monotonic_time() + 30):
+            self._wc = await self.get_webclient()
+        return self._wc
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/pci.py b/confluent_server/aiohmi/ipmi/oem/lenovo/pci.py
new file mode 100755
index 00000000..4468eece
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/pci.py
@@ -0,0 +1,62 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+pci_fields = (
+    inventory.EntryField("index", "B"),
+    inventory.EntryField("PCIType", "B", mapper={
+        0x0: "On board slot",
+        0x1: "Riser Type 1",
+        0x2: "Riser Type 2",
+        0x3: "Riser Type 3",
+        0x4: "Riser Type 4",
+        0x5: "Riser Type 5",
+        0x6: "Riser Type 6a",
+        0x7: "Riser Type 6b",
+        0x8: "ROC",
+        0x9: "Mezz"
+    }),
+    inventory.EntryField("BusNumber", "B"),
+    inventory.EntryField("DeviceFunction", "B"),
+    inventory.EntryField("VendorID", "<H", presence=True),
+    inventory.EntryField("DeviceID", "<H"),
+    inventory.EntryField("SubSystemVendorID", "<H"),
+    inventory.EntryField("SubSystemID", "<H"),
+    inventory.EntryField("InterfaceType", "B"),
+    inventory.EntryField("SubClassCode", "B"),
+    inventory.EntryField("BaseClassCode", "B"),
+    inventory.EntryField("LinkSpeed", "B"),
+    inventory.EntryField("LinkWidth", "B"),
+    inventory.EntryField("Reserved", "h")
+)
+
+
+def parse_pci_info(raw):
+    return inventory.parse_inventory_category_entry(raw, pci_fields)
+
+
+def get_categories():
+    return {
+        "pci": {
+            "idstr": "PCI {0}",
+            "parser": parse_pci_info,
+            "command": {
+                "netfn": 0x06,
+                "command": 0x59,
+                "data": (0x00, 0xc1, 0x03, 0x00)
+            },
+            "workaround_bmc_bug": lambda t: t == "ami"
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/psu.py b/confluent_server/aiohmi/ipmi/oem/lenovo/psu.py
new file mode 100755
index 00000000..d325ac6d
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/psu.py
@@ -0,0 +1,111 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+
+psu_type = {
+    0b0001: "Other",
+    0b0010: "Unknown",
+    0b0011: "Linear",
+    0b0100: "Switching",
+    0b0101: "Battery",
+    0b0110: "UPS",
+    0b0111: "Converter",
+    0b1000: "Regulator",
+}
+psu_status = {
+    0b001: "Other",
+    0b010: "Unknown",
+    0b011: "OK",
+    0b100: "Non-critical",
+    0b101: "Critical; power supply has failed and has been taken off-line"
+}
+psu_voltage_range_switch = {
+    0b0001: "Other",
+    0b0010: "Unknown",
+    0b0011: "Manual",
+    0b0100: "Auto-switch",
+    0b0101: "Wide range",
+    0b0110: "Not applicable"
+}
+
+
+def psu_status_word_slice(w, s, e):
+    return int(w[-e - 1:-s], 2)
+
+
+def psu_status_word_bit(w, b):
+    return int(w[-b - 1])
+
+
+def psu_status_word_parser(word):
+    fields = {}
+    word = "{0:016b}".format(word)
+
+    fields["DMTF Power Supply Type"] = psu_type.get(psu_status_word_slice(
+        word, 10, 13), "Invalid")
+
+    fields["DMTF Input Voltage Range"] = psu_voltage_range_switch.get(
+        psu_status_word_slice(word, 3, 6), "Invalid")
+
+    # Power supply is unplugged from the wall
+    fields["Unplugged"] = bool(psu_status_word_bit(word, 2))
+
+    # Power supply is hot-replaceable
+    fields["Hot Replaceable"] = bool(psu_status_word_bit(word, 0))
+
+    return fields
+
+
+psu_fields = (
+    inventory.EntryField("index", "B"),
+    inventory.EntryField("Presence State", "B", presence=True),
+    inventory.EntryField("Capacity W", "<H"),
+    inventory.EntryField("Board manufacturer", "18s"),
+    inventory.EntryField("Board model", "18s"),
+    inventory.EntryField("Board manufacture date", "10s"),
+    inventory.EntryField("Board serial number", "34s"),
+    inventory.EntryField("Board manufacturer revision", "5s"),
+    inventory.EntryField("Board product name", "10s"),
+    inventory.EntryField("PSU Asset Tag", "10s"),
+    inventory.EntryField(
+        "PSU Redundancy Status",
+        "B",
+        valuefunc=lambda v: "Not redundant" if v == 0x00 else "Redundant"
+    ),
+    inventory.EntryField(
+        "PSU Status Word",
+        "<H",
+        valuefunc=psu_status_word_parser, multivaluefunc=True
+    )
+)
+
+
+def parse_psu_info(raw):
+    return inventory.parse_inventory_category_entry(raw, psu_fields)
+
+
+def get_categories():
+    return {
+        "psu": {
+            "idstr": "Power Supply {0}",
+            "parser": parse_psu_info,
+            "command": {
+                "netfn": 0x06,
+                "command": 0x59,
+                "data": (0x00, 0xc6, 0x00, 0x00)
+            }
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/raid_controller.py b/confluent_server/aiohmi/ipmi/oem/lenovo/raid_controller.py
new file mode 100644
index 00000000..25d2fbc6
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/raid_controller.py
@@ -0,0 +1,64 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+
+raid_controller_fields = (
+    inventory.EntryField("ControllerID", "I"),
+    inventory.EntryField("AdapterType", "B", mapper={
+        0x00: "Unknown",
+        0x01: "RAIDController"
+    }),
+    inventory.EntryField("SupercapPresence", "B", mapper={
+        0x00: "Absent",
+        0x01: "Present"
+    }),
+    inventory.EntryField("FlashComponent1Name", "16s"),
+    inventory.EntryField("FlashComponent1Version", "64s"),
+    inventory.EntryField("FlashComponent2Name", "16s"),
+    inventory.EntryField("FlashComponent2Version", "64s"),
+    inventory.EntryField("FlashComponent3Name", "16s"),
+    inventory.EntryField("FlashComponent3Version", "64s"),
+    inventory.EntryField("FlashComponent4Name", "16s"),
+    inventory.EntryField("FlashComponent4Version", "64s"),
+    inventory.EntryField("FlashComponent5Name", "16s"),
+    inventory.EntryField("FlashComponent5Version", "64s"),
+    inventory.EntryField("FlashComponent6Name", "16s"),
+    inventory.EntryField("FlashComponent6Version", "64s"),
+    inventory.EntryField("FlashComponent7Name", "16s"),
+    inventory.EntryField("FlashComponent7Version", "64s"),
+    inventory.EntryField("FlashComponent8Name", "16s"),
+    inventory.EntryField("FlashComponent8Version", "64s")
+)
+
+
+def parse_raid_controller_info(raw):
+    return inventory.parse_inventory_category_entry(
+        raw, raid_controller_fields)
+
+
+def get_categories():
+    return {
+        "raid_controller": {
+            "idstr": "RAID Controller {0}",
+            "parser": parse_raid_controller_info,
+            "countable": False,
+            "command": {
+                "netfn": 0x06,
+                "command": 0x59,
+                "data": (0x00, 0xc4, 0x00, 0x00)
+            }
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lenovo/raid_drive.py b/confluent_server/aiohmi/ipmi/oem/lenovo/raid_drive.py
new file mode 100644
index 00000000..9ad08b31
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lenovo/raid_drive.py
@@ -0,0 +1,71 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.ipmi.oem.lenovo import inventory
+
+
+raid_drive_fields = (
+    inventory.EntryField("index", "B"),
+    inventory.EntryField("VendorID", "64s"),
+    inventory.EntryField("Size", "I",
+                         valuefunc=lambda v: str(v) + " MB"),
+    inventory.EntryField("MediaType", "B", mapper={
+        0x00: "HDD",
+        0x01: "SSD",
+        0x02: "SSM_FLASH"
+    }),
+    inventory.EntryField("InterfaceType", "B", mapper={
+        0x00: "Unknown",
+        0x01: "ParallelSCSI",
+        0x02: "SAS",
+        0x03: "SATA",
+        0x04: "FC"
+    }),
+    inventory.EntryField("FormFactor", "B", mapper={
+        0x00: "Unknown",
+        0x01: "2.5in",
+        0x02: "3.5in"
+    }),
+    inventory.EntryField("LinkSpeed", "B", mapper={
+        0x00: "Unknown",
+        0x01: "1.5 Gb/s",
+        0x02: "3.0 Gb/s",
+        0x03: "6.0 Gb/s",
+        0x04: "12.0 Gb/s"
+    }),
+    inventory.EntryField("SlotNumber", "B"),
+    inventory.EntryField("ControllerIndex", "B"),
+    inventory.EntryField("DeviceState", "B", mapper={
+        0x00: "active",
+        0x01: "stopped",
+        0xff: "transitioning"
+    }))
+
+
+def parse_raid_drive_info(raw):
+    return inventory.parse_inventory_category_entry(raw, raid_drive_fields)
+
+
+def get_categories():
+    return {
+        "raid_raid_drive": {
+            "idstr": "RAID Drive {0}",
+            "parser": parse_raid_drive_info,
+            "command": {
+                "netfn": 0x06,
+                "command": 0x59,
+                "data": (0x00, 0xc5, 0x00, 0x00)
+            }
+        }
+    }
diff --git a/confluent_server/aiohmi/ipmi/oem/lookup.py b/confluent_server/aiohmi/ipmi/oem/lookup.py
new file mode 100755
index 00000000..a55ba37e
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/oem/lookup.py
@@ -0,0 +1,112 @@
+# Copyright 2015 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+import sys
+
+import aiohmi.ipmi.oem.generic as generic
+import aiohmi.ipmi.oem.lenovo.handler as lenovo
+
+
+logger = logging.getLogger(__name__)
+
+# The mapping comes from
+# http://www.iana.org/assignments/enterprise-numbers/enterprise-numbers
+# Only mapping the ones with known backends
+oemmap = {
+    20301: lenovo,  # IBM x86 (and System X at Lenovo)
+    19046: lenovo,  # Lenovo x86 (e.g. Thinkserver)
+    7154: lenovo,
+}
+
+
+async def get_oem_handler(oemid, ipmicmd, *args):
+    # first try to find with composite key manufacturer_id.product_id,
+    # if found return directly
+    # then try to find with manufacturer_id
+    for item in (
+        '{}.{}'.format(oemid['manufacturer_id'], oemid['product_id']),
+        oemid['manufacturer_id'],
+    ):
+        if item in oemmap:
+            return (await oemmap[item].OEMHandler.create(oemid, ipmicmd, *args), True)
+    else:
+        return await generic.OEMHandler.create(oemid, ipmicmd, *args), False
+
+
+def load_plugins():
+    # load plugins and register oemmap
+    path = os.path.dirname(os.path.realpath(__file__))
+
+    for plugindir in os.listdir(path):
+        plugindir = os.path.join(path, plugindir)
+
+        if not os.path.isdir(plugindir):
+            continue
+        sys.path.insert(1, plugindir)
+        # two passes, to avoid adding both py and pyc files
+        find_plugin(path, plugindir)
+        # restore path to not include the plugindir
+        sys.path.pop(1)
+
+
+def find_plugin(base_dir, cur_dir):
+    # scan to process items in the dir
+    # if is a directory, go into the directory to find plugins
+    # if is handler.py try to load and find the key to register
+    # else skip
+    for item in os.listdir(cur_dir):
+        abs_path = os.path.join(cur_dir, item)
+        if os.path.isdir(abs_path):
+            find_plugin(base_dir, abs_path)
+        elif item == 'handler.py':
+            load_and_register(base_dir, cur_dir)
+        else:
+            pass
+
+
+def load_and_register(base_dir, cur_dir):
+    try:
+        oem_handler = __import__(make_plugin_name(base_dir, cur_dir),
+                                 fromlist=['handler'])
+        if 'device_type_supported' in oem_handler.__dict__:
+            for type in oem_handler.device_type_supported:
+                register_oem_map(type, oem_handler)
+        else:
+            logger.debug(
+                'handler in {} does not support plugin.'.format(cur_dir))
+    except Exception as ex:
+        logger.exception('exception while loading handler in {} : {}'
+                         .format(cur_dir, ex))
+
+
+def register_oem_map(type, handler):
+    if type in oemmap:
+        logger.info('type {} already registered as {}, replaced with {}.'
+                    .format(type, oemmap.get(type), handler))
+        oemmap[type] = handler
+    else:
+        oemmap[type] = handler
+
+
+def make_plugin_name(base_dir, cur_dir):
+    return '{}.{}.{}'.format(__package__,
+                             os.path.relpath(cur_dir, base_dir)
+                             .replace('/', '.'),
+                             'handler')
+
+
+# load_plugins
+load_plugins()
diff --git a/confluent_server/aiohmi/ipmi/private/__init__.py b/confluent_server/aiohmi/ipmi/private/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/ipmi/private/constants.py b/confluent_server/aiohmi/ipmi/private/constants.py
new file mode 100644
index 00000000..165dfeee
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/constants.py
@@ -0,0 +1,1886 @@
+# Copyright 2013 IBM Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.constants as const
+
+IPMI_BMC_ADDRESS = 0x20
+IPMI_SEND_MESSAGE_CMD = 0x34
+
+
+payload_types = {
+    'ipmi': 0x0,
+    'sol': 0x1,
+    'rmcpplusopenreq': 0x10,
+    'rmcpplusopenresponse': 0x11,
+    'rakp1': 0x12,
+    'rakp2': 0x13,
+    'rakp3': 0x14,
+    'rakp4': 0x15,
+}
+
+# sensor type codes, table 42-3
+sensor_type_codes = {
+    1: 'Temperature',
+    2: 'Voltage',
+    3: 'Current',
+    4: 'Fan',
+    5: 'Physical Security',
+    6: 'Platform Security',
+    7: 'Processor',
+    8: 'Power Supply',
+    9: 'Power Unit',
+    0xa: 'Cooling Device',
+    0xb: 'Other',
+    0xc: 'Memory',
+    0xC6: 'PSU Redundancy',
+    0xd: 'Drive Bay',
+    0xe: 'POST Memory Resize',
+    0xf: 'System Firmware',
+    0x10: 'Event Log Disabled',
+    0x11: 'Watchdog',
+    0x12: 'System Event',
+    0x13: 'Critical interrupt',
+    0x14: 'Button/switch',
+    0x15: 'Module/Board',
+    0x16: 'Microcontroller/Coprocessor',
+    0x17: 'Add-in Card',
+    0x18: 'Chassis',
+    0x19: 'Chip Set',
+    0x1a: 'Other FRU',
+    0x1b: 'Cable/Interconnect',
+    0x1c: 'Terminator',
+    0x1d: 'System Boot',
+    0x1e: 'Boot Error',
+    0x1f: 'OS Boot',
+    0x20: 'OS Stop',
+    0x21: 'Slot/Connector',
+    0x22: 'System ACPI Power State',
+    0x23: 'Watchdog',
+    0x24: 'Platform alert',
+    0x25: 'Entity Presence',
+    0x26: 'Monitor ASIC/IC',
+    0x27: 'LAN',
+    0x28: 'Management Subsystem Health',
+    0x29: 'Battery',
+    0x2a: 'Session',
+    0x2b: 'Version Change',
+    0x2c: 'FRU State',
+}
+
+# This is from table 42-2
+# digital discrete poses a challenge from a health perspective.  So far all
+# observed ones are no more or less 'healthy' by being asserted or not asserted
+# for example asserting that an add-on is installed
+
+generic_type_offsets = {
+    1: {  # threshold based
+        # Some explanation is offered in the specification around 'get sensor
+        # event status' command.  Assertions should indicate the new state
+        # and deassertion should indicate leaving the state.  The 'going high'
+        # and 'going low' do not denote leaving a state.  For example, going
+        # from Lower Critical to Lower Non-Critical would be 'going high'
+        # Will just report the new state rather than the direction from
+        # which things came from, since in a vacuum it is not useful data
+        # and in the context of event log, it should be better discerned
+        # from the pattern of prior events
+        0: {
+            'desc': 'Lower non-critical',  # - going low',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Lower Non-critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Lower non-critical',  # - going high',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Lower non-critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Lower Critical',  # - going low',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Lower critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Lower Critical',  # - going high',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Lower critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Lower non-recoverable',  # - going low
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Lower non-recoverable deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Lower non-recoverable',  # - going high
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Lower non-recoverable deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Upper non-critical',  # - going low
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Upper non-critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Upper non-critical',  # - going high
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Upper non-critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Upper critical',  # - going low
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Upper critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        9: {
+            'desc': 'Upper critical',  # - going high
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Upper critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xa: {
+            'desc': 'Upper non-recoverable',  # - going low
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Upper non-recoverable deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xb: {
+            'desc': 'Upper non-recoverable',  # - going high
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Upper non-recoverable deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    2: {
+        0: {
+            'desc': 'Idle',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Idle deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Active',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Active deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Busy',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Busy deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    3: {
+        0: {
+            'desc': 'Deasserted',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Asserted',  # this would be very peculiar
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Asserted',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    4: {
+        0: {
+            'desc': 'Predictive failure deasserted',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Predictive failure',
+            'deassertion_severity': const.Health.Warning,
+        },
+        1: {
+            'desc': 'Predictive failure',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Predictive failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    5: {
+        0: {
+            'desc': 'Limit not exceeded',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Limit exceeded',
+            'deassertion_severity': const.Health.Warning,
+        },
+        1: {
+            'desc': 'Limit exceeded',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Limit no longer exceeded',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    6: {
+        0: {
+            'desc': 'Performance met',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Performance lags',
+            'deassertion_severity': const.Health.Warning,
+        },
+        1: {
+            'desc': 'Performance lags',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Performance no longer lags',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    7: {
+        0: {
+            'desc': 'Ok',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Not ok',
+            'deassertion_severity': const.Health.Warning,
+        },
+        1: {
+            'desc': 'Non-Critical',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Non-critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Critical',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Non-recoverable',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Non-recoverable deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Non-critical',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Non-critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Critical',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Critical deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Non-recoverable',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Non-recoverable deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Monitor',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Monitor deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Informational',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Informational deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    8: {
+        0: {
+            'desc': 'Absent',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Present',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    9: {
+        0: {
+            'desc': 'Disabled',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Enabled',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Disabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0xa: {
+        0: {
+            'desc': 'Running',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Running deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'In test',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'In test deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Power off',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Power off deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Online',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Online deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Offline',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Offline deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Off duty',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Off duty deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Degraded',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Degraded deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Power save',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Power save deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Install error',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Install error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0xb: {
+        0: {
+            'desc': 'Redundant',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Redundant lost',
+            'deassertion_severity': const.Health.Critical,
+        },
+        1: {
+            'desc': 'Not redundant',  # redundancy lost
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Redundancy restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Redundancy degraded',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Redundancy restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Not redundant',  # down to non redundant
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Redundancy restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Not Redundant',  # it has come back, but not redundant
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Redundancy restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Degraded',  # abnormal operation
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Present',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Redundancy degraded',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Redundancy restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Redundancy degraded',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Redundancy restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0xc: {
+        0: {
+            'desc': 'ACPI D0',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'ACPI D0 deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'ACPI D1',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'ACPI D1 deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'ACPI D2',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'ACPI D2 deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'ACPI D3',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'ACPI D3 deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+}
+
+sensor_type_offsets = {
+    # For the security sensors, we assume if armed,
+    # the operator considers these to  be critical situations
+    # Even though many of these would never reasonably be 'deasserted', provide
+    # some language that hypothetically would make sense if it were ever
+    # observed
+    5: {
+        0: {
+            'desc': 'Chassis intrusion',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Chassis intrusion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Drive area intrusion',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Drive area intrusion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'I/O card area intrusion',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'I/O card area intrusion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Processor area intrusion',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Processor area intrusion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'LAN connection lost',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'LAN connection restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Unauthorized dock',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Unauthorized dock deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Fan area intrusion',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Fan area intrusion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    6: {
+        0: {
+            'desc': 'Front Panel Lockout Violation attempt',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Front Panel Lockout deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Pre-boot password violation - user',
+            'severity': const.Health.Critical,
+            'deassertion_severity': const.Health.Ok,
+            'deassertion_desc': 'Boot Password violation deasserted',
+        },
+        2: {
+            'desc': 'Pre-boot password violation - setup',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Setup password violation deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Pre-boot password violation - netboot',
+            'severity': const.Health.Critical,
+            'deassertion_desc':
+            'Pre-boot password violation - netboot deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Pre-boot password violation',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Pre-boot password violation deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Out-of-band access password violation',
+            'severity': const.Health.Critical,
+            'deassertion_desc':
+            'Out-of-band access password violation deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    7: {
+        0: {
+            'desc': 'Internal error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Internal error recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Thermal trip',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Thermal trip recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Self test failure',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Self test recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Hang in POST',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Hang in POST recovered',
+            'deassertion_severity': const.Health.Ok,
+
+        },
+        4: {
+            'desc': 'Startup failure',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Startup recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Configuration error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Configuration error recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Uncorrectable cpu complex error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Uncorrectable cpu complex error recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Disabled',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        9: {
+            'desc': 'Terminator presence detected',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Terminator absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xa: {
+            'desc': 'Throttled',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'No longer throttled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xb: {
+            'desc': 'Uncorrectable machine check exception',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Uncorrectable machine check recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xc: {
+            'desc': 'Correctable machine check exception',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Correctable machine check recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    8: {  # power supply
+        0: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Failure',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Recovered',
+            'deassertion_severity': const.Health.Ok,
+
+        },
+        2: {
+            'desc': 'Predictive failure',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Predictive failure recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Power input lost',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Power input restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Power input out of range or lost',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Power input present and in range',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Power input out of range',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Power input in range',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            # clarified by SEL/PET event data 3
+            'desc': 'Configuration error',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Configuration error recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Standby',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Active',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    9: {  # power unit
+        0: {
+            'desc': 'Power off',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Power on',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Power cycle',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Power cycle deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': '240VA power down',
+            'severity': const.Health.Warning,
+            'deassertion_desc': '240VA power down deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Interlock power down',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Interlock power down deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Power input lost',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Power input restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Soft power control failure',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Soft power control failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Power unit failure',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Power unit failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Power unit predictive failure',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Power unit predictive failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0xc: {  # memory
+        0: {
+            'desc': 'Correctable error',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Correctable error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Uncorrectable error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Uncorrectable error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Parity error',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Parity error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Scrub failed',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Scrub failed deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Device disabled',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Device enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Correctable memory error logging limit reached',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Correctable memory error logging restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Configuration error',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Configuration error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Spare',  # event data 3 available
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Spare deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        9: {
+            'desc': 'Throttled',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'No longer throttled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xa: {
+            'desc': 'Critical over temperature',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Critical over temperature deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0xd: {  # drive bay
+        0: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Drive fault',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Drive fault deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Predictive drive failure',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Predictive drive failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Hot spare drive',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Hot spare drive deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Drive consistency check in progress',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Drive consistency check complete',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Drive in critical array',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Drive in critical array deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Drive in failed array',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Drive in failed array deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Rebuild in progress',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Rebuild complete',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Rebuild aborted',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Rebuild abort deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0xf: {
+        0: {
+            'desc': 'Boot error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Boot error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Hang',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Hang deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Progress',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Progress deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x10: {  # event log disabled
+        0: {
+            'desc': 'Correctable memory error logging disabled',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Correctable memory error logging enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Specific event logging disabled',
+            'deassertion_desc': 'Event logging enabled',
+            'severity': const.Health.Warning,
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Log clear',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Log clear complete',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Logging disabled',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Logging enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Event log full',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Event log no longer full',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Event log nearly full',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Event log no longer nearly full',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Correctable machine check logging disabled',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Correctable machine check logging enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x12: {  # system event
+        0: {
+            'desc': 'System reconfigured',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'System reconfiguration deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'OEM boot event',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OEM boot event deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Undetermined hardware failure',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Undetermined hardware failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Aux log entry',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Aux log entry deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Event response',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Event response deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Clock time change',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Clock time change deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x13: {  # critical interrupt
+        0: {
+            'desc': 'Front panel diagnostic interrupt',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Front panel diagnostic interrupt deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Bus timeout',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Bus timeout recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'I/O NMI',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'I/O NMI deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Software NMI',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Software NMI deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'PCI PERR',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'PCI PERR deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'PCI SERR',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'PCI SERR deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'EISA fail safe timeout',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'EISA fail safe timeout deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Bus correctable error',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Bus correctable error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'Bus uncorrectable error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Bus uncorrectable error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        9: {
+            'desc': 'Fatal NMI',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Fatal NMI deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xa: {
+            'desc': 'Bus fatal error',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Bus fatal error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xb: {
+            'desc': 'Bus degraded',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Bus degraded deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x14: {  # button/switch
+        0: {
+            'desc': 'Power button pressed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Power button released',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Sleep button pressed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Sleep button released',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Reset button pressed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Reset button released',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'FRU latch open',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'FRU latch closed',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Service requested',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Service no longer requested',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x19: {  # chip set
+        0: {
+            'desc': 'Soft power control failure',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Soft power control failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Thermal trip',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Thermal trip deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x1b: {  # Cable/Interconnect
+        0: {
+            'desc': 'Connected',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Disconnected',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Connection error',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Connection error deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x1d: {  # system boot initiated
+        0: {
+            'desc': 'Power up',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Power up deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Hard reset',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Hard reset deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Warm reset',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Warm reset deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'PXE boot',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'PXE boot deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Automatic boot to diagnostic',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Automatic boot to diagnostic deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'OS hard reset',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS hard reset deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'OS warm reset',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS warm reset deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'System restart',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'System restart deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x1e: {  # boot error
+        0: {
+            'desc': 'No bootable media',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'No bootable media deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Unbootable removable media',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Unbootable removable media deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'PXE failure',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'PXE failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+
+        },
+        3: {
+            'desc': 'Invalid boot sector',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Invalid boot sector deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Interactive boot timeout',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'Interactive boot timeout deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x1f: {  # OS boot
+        0: {
+            'desc': 'A: boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Unbootable removable media deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Hard drive boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Hard drive boot completed not failed',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Network boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Network boot completion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Diagnostic boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Diagnostic boot deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'CD boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'CD boot completion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'ROM boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'ROM boot completion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Boot completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Boot completion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'OS deployment started',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS deployment deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        8: {
+            'desc': 'OS deployment completed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS deployment completion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        9: {
+            'desc': 'OS deployment aborted',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS deployment abortion deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xa: {
+            'desc': 'OS deployment failed',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'OS deployment failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x20: {  # OS Stop
+        0: {
+            'desc': 'OS boot stop',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'OS boot stop deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'OS crash',
+            'severity': const.Health.Failed,
+            'deassertion_desc': 'OS crash deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'OS cleanly halted',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS clean halt deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'OS cleanly shutdown',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'OS clean shutdown deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Event driven soft shutdown',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Event driven soft shutdown deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Event driven soft shutdown failed',
+            'severity': const.Health.Warning,
+            'deassertion_desc':
+            'Event driven soft shutdown failure deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x21: {  # slot/connector
+        0x0: {
+            'desc': 'Fault',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Fault recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x1: {
+            'desc': 'Identify',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Identify deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x2: {
+            'desc': 'Slot/connector installed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Slot/connector removed',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x3: {
+            'desc': 'Slot/connector ready for install',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Slot/connector no longer ready for install',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x4: {
+            'desc': 'Slot/connector ready for removal',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Slot/connector no longer ready for removal',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x5: {
+            'desc': 'Slot powered down',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Slot powered up',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x6: {
+            'desc': 'Slot/connector device removal requested',
+            'severity': const.Health.Warning,
+            'deassertion_desc':
+            'Slot/connector device removal no longer requested',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x7: {
+            'desc': 'Slot/connector interlock',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Slot/connector interlock deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x8: {
+            'desc': 'Slot/connector disabled',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Slot/connector enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x9: {
+            'desc': 'Slot holds spare device',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Slot no longer holds spare device',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x22: {  # system acpi power state
+        0x0: {
+            'desc': 'Online',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Online deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x1: {
+            'desc': 'S1 sleep',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'S1 sleep deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x2: {
+            'desc': 'S2 sleep',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'S2 sleep deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x3: {
+            'desc': 'Sleep',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Sleep deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x4: {
+            'desc': 'Hibernated',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Hibernation deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x5: {
+            'desc': 'Off',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Off deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x6: {
+            'desc': 'Hibernated or off',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Hibernate or off deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x7: {
+            'desc': 'Mechanically off',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Mechanically on',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x8: {
+            'desc': 'Sleep',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Sleep deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x9: {
+            'desc': 'G1 sleep',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'G1 sleep deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xa: {
+            'desc': 'Shutdown',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Shutdown deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xb: {
+            'desc': 'On',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Off',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xc: {
+            'desc': 'Off',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'On',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0xe: {
+            'desc': 'Unknown',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Unknown deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x23: {  # watchdog
+        0x0: {
+            'desc': 'Watchdog expired',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Watchdog expiry deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x1: {
+            'desc': 'Watchdog hard reset',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Watchdog hard reset deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x2: {
+            'desc': 'Watchdog power down',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Watchdog power down deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x3: {
+            'desc': 'Watchdog power cycle',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Watchdog power cycle deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x8: {
+            'desc': 'Watchdog interrupt',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Watchdog interrupt deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x24: {  # platform event
+        0x0: {
+            'desc': 'Platform generated page',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Platform generated page deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x1: {
+            'desc': 'Platform generated network alert',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Platform generated network alert deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x2: {
+            'desc': 'Platform generated PET alert',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Platform generated PET alert deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        0x3: {
+            'desc': 'Platform generated OEM SNMP Alert',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Platform generated OEM SNMP Alert deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x25: {  # entity presence
+        0: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Absent',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Present',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Disabled',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x27: {  # LAN heartbeat
+        0: {
+            'desc': 'Heartbeat lost',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Heartbeat recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Heartbeat',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Heartbeat lost',
+            'deassertion_severity': const.Health.Warning,
+        },
+    },
+    0x28: {  # management subsystem health
+        0: {
+            'desc': 'Sensor access degraded or unavailable',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Sensor access restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Controller access degraded or unavailable',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Controller access restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Controller Offline',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Controller online',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Controller Offline',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Controller online',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Sensor Error',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Sensor recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'FRU Failure',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'FRU recovered',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x29: {  # battery
+        0: {
+            'desc': 'Low',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Battery no longer low',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Failed',
+            # Critical here because typical battery failure
+            # does not indicate a 'failed' runtime
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Recovered',
+            'deassertion_severity': const.Health.Ok
+        },
+        2: {
+            'desc': 'Present',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Absent',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x2a: {  # session audit
+        0: {
+            'desc': 'Activated',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Deactivated',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Deactivated',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Activated',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Invalid username/password',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Valid username/password',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Account disabled due to failure count',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Account re-enabled',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x2b: {  # Version Change
+        0: {
+            'desc': 'Hardware change detected',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Hardware change deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Firmware or software change detected',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Firmware or software change deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Hardware incompatibility detected',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Hardware incompatibility deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Firmware/software incompatibility detected',
+            'severity': const.Health.Critical,
+            'deassertion_desc': 'Firmware/software incompatibility deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Invalid/Unsupported hardware revision',
+            'severity': const.Health.Critical,
+            'deassertion_desc':
+            'Invalid/unsupported hardware revision deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Invalid/unsupported firmware/software version',
+            'severity': const.Health.Critical,
+            'deassertion_desc':
+            'Invalid/unsupported firmware/software version',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Successful hardware change',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Successful hardware change deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Successful software/firmware change',
+            'severity': const.Health.Ok,
+            'deassertion_desc':
+            'Successful software/firmware change deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+    0x2c: {  # FRU state
+        0: {
+            'desc': 'Not Installed',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Installed',
+            'deassertion_severity': const.Health.Ok,
+        },
+        1: {
+            'desc': 'Inactive',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Inactive deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        2: {
+            'desc': 'Activation requested',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Activation request deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        3: {
+            'desc': 'Activation in progress',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Activation no longer in progress',
+            'deassertion_severity': const.Health.Ok,
+        },
+        4: {
+            'desc': 'Active',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Inactive',
+            'deassertion_severity': const.Health.Ok,
+        },
+        5: {
+            'desc': 'Deactivation requested',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Deactivation request deasserted',
+            'deassertion_severity': const.Health.Ok,
+        },
+        6: {
+            'desc': 'Deactivation in progress',
+            'severity': const.Health.Ok,
+            'deassertion_desc': 'Deactivation no longer in progress',
+            'deassertion_severity': const.Health.Ok,
+        },
+        7: {
+            'desc': 'Communication lost',
+            'severity': const.Health.Warning,
+            'deassertion_desc': 'Communication restored',
+            'deassertion_severity': const.Health.Ok,
+        },
+    },
+}
+
+# entity ids from table 43-13 entity id codes
+entity_ids = {
+    0x0: 'Unspecified',
+    0x1: 'Other',
+    0x2: 'Unknown',
+    0x3: 'Processor',
+    0x4: 'Disk or disk bay',
+    0x5: 'Peripheral bay',
+    0x6: 'System management module',
+    0x7: 'System board',
+    0x8: 'Memory module',
+    0x9: 'Processor module',
+    0xa: 'Power supply',
+    0xb: 'Add-in card',
+    0xc: 'Front panel board',
+    0xd: 'Back panel board',
+    0xe: 'Power system board',
+    0xf: 'Drive backplane',
+    0x10: 'System internal expansion board',
+    0x11: 'Other system board',
+    0x12: 'Processor board',
+    0x13: 'Power unit / power domain',
+    0x14: 'Power module / DC-to-DC converter',
+    0x15: 'Power management /power distribution board',
+    0x16: 'Chassis back panel board',
+    0x17: 'System chassis',
+    0x18: 'Sub-chassis',
+    0x19: 'Other chassis board',
+    0x1a: 'Disk drive bay',
+    0x1b: 'Peripheral bay',
+    0x1c: 'Device bay',
+    0x1d: 'Fan/cooling device',
+    0x1e: 'Cooling unit / cooling domain',
+    0x1f: 'Cable / interconnect',
+    0x20: 'Memory device',
+    0x21: 'System management software',
+    0x22: 'System firmware',
+    0x23: 'Operating system',
+    0x24: 'System bus',
+    0x25: 'Group',
+    0x26: 'Remote management communication device',
+    0x27: 'External environment',
+    0x28: 'Battery',
+    0x29: 'Processing blade',
+    0x2a: 'Connectivity switch',
+    0x2b: 'Processor/memory module',
+    0x2c: 'I/O module',
+    0x2d: 'Processor I/O module',
+    0x2e: 'Management controller firmware',
+    0x2f: 'IPMI channel',
+    0x30: 'PCI Bus',
+    0x31: 'PCIe Bus',
+    0x32: 'SCSI Bus',
+    0x33: 'SATA/SAS Bus',
+    0x34: 'Processor / front-side bus',
+    0x35: 'Real time clock',
+    0x37: 'Air inlet',
+    0x40: 'Air inlet',
+    0x41: 'Processor',
+    0x42: 'System board',
+}
+
+
+rmcp_codes = {
+    1: ("Insufficient resources to create new session (wait for existing "
+        "sessions to timeout)"),
+    2: "Invalid Session ID",
+    3: "Invalid payload type",
+    4: "Invalid authentication algorithm",
+    5: "Invalid integrity algorithm",
+    6: "No matching integrity payload",
+    7: "No matching integrity payload",
+    8: "Inactive Session ID",
+    9: "Invalid role",
+    0xa: "Unauthorized role or privilege level requested",
+    0xb: "Insufficient resources to create a session at the requested role",
+    0xc: "Invalid username length",
+    0xd: "Unauthorized name",
+    0xe: "Unauthorized GUID",
+    0xf: "Invalid integrity check value",
+    0x10: "Invalid confidentiality algorithm",
+    0x11: "No Cipher suite match with proposed security algorithms",
+    0x12: "Illegal or unrecognized parameter",
+}
+
+netfn_codes = {
+    "chassis": 0x0,
+    "bridge": 0x2,
+    "sensorevent": 0x4,
+    "application": 0x6,
+    "firmware": 0x8,
+    "storage": 0xa,
+    "transport": 0xc,
+}
+
+command_completion_codes = {
+    (7, 0x39): {
+        0x81: "Invalid user name",
+        0x82: "Null user disabled",
+    },
+    (7, 0x3a): {
+        0x81: "No available login slots",
+        0x82: "No available login slots for requested user",
+        0x83: "No slot available with requested privilege level",
+        0x84: "Session sequence number out of range",
+        0x85: "Invalid session ID",
+        0x86: ("Requested privilege level exceeds requested user permissions "
+               "on this channel"),
+    },
+    (7, 0x3b): {  # Set session privilege level
+        0x80: "User is not allowed requested privilege level",
+        0x81: "Requested privilege level is not allowed over this channel",
+        0x82: "Cannot disable user level authentication",
+    },
+    (1, 8): {  # set system boot options
+        0x80: "Parameter not supported",
+        0x81: "Attempt to set set 'set in progress' when not 'set complete'",
+        0x82: "Attempt to write read-only parameter",
+    },
+    (7, 0x48): {  # activate payload
+        0x80: "Payload already active on another session",
+        0x81: "Payload is disabled",
+        0x82: "Payload activation limit reached",
+        0x83: "Cannot activate payload with encryption",
+        0x84: "Cannot activate payload without encryption",
+    },
+    (6, 0x47): {  # set user password
+        0x80: "Password test failed. Password does not match stored value",
+        0x81: "Password test failed. Wrong password size was used"
+    },
+}
+
+ipmi_completion_codes = {
+    0x00: "Success",
+    0xc0: "Node Busy",
+    0xc1: "Invalid command",
+    0xc2: "Invalid command for given LUN",
+    0xc3: "Timeout while processing command",
+    0xc4: "Out of storage space on BMC",
+    0xc5: "Reservation canceled or invalid reservation ID",
+    0xc6: "Request data truncated",
+    0xc7: "Request data length invalid",
+    0xc8: "Request data field length limit exceeded",
+    0xc9: "Parameter out of range",
+    0xca: "Cannot return number of requested data bytes",
+    0xcb: "Requested sensor, data, or record not present",
+    0xcc: "Invalid data field in request",
+    0xcd: "Command illegal for specified sensor or record type",
+    0xce: "Command response could not be provided",
+    0xcf: "Cannot execute duplicated request",
+    0xd0: "SDR repository in update mode",
+    0xd1: "Device in firmware update mode",
+    0xd2: "BMC initialization in progress",
+    0xd3: "Internal destination unavailable",
+    0xd4: "Insufficient privilege level or firmware firewall",
+    0xd5: "Command not supported in present state",
+    0xd6: "Cannot execute command because subfunction disabled or unavailable",
+    0xff: "Unspecified",
+    0xffff: "Timeout",  # not ipmi, but used internally
+}
+
+priv_levels = {
+    'callback': 1,
+    'user': 2,
+    'operator': 3,
+    'admin': 4,
+    'oem': 5,
+}
diff --git a/confluent_server/aiohmi/ipmi/private/localsession.py b/confluent_server/aiohmi/ipmi/private/localsession.py
new file mode 100644
index 00000000..2489d272
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/localsession.py
@@ -0,0 +1,145 @@
+# Copyright 2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import ctypes
+import fcntl
+from select import select
+
+import aiohmi.ipmi.private.util as iutil
+
+
+class IpmiMsg(ctypes.Structure):
+    _fields_ = [('netfn', ctypes.c_ubyte),
+                ('cmd', ctypes.c_ubyte),
+                ('data_len', ctypes.c_short),
+                ('data', ctypes.POINTER(ctypes.c_ubyte))]
+
+
+class IpmiSystemInterfaceAddr(ctypes.Structure):
+    _fields_ = [('addr_type', ctypes.c_int),
+                ('channel', ctypes.c_short),
+                ('lun', ctypes.c_ubyte)]
+
+
+class IpmiRecv(ctypes.Structure):
+    _fields_ = [('recv_type', ctypes.c_int),
+                ('addr', ctypes.POINTER(IpmiSystemInterfaceAddr)),
+                ('addr_len', ctypes.c_uint),
+                ('msgid', ctypes.c_long),
+                ('msg', IpmiMsg)]
+
+
+class IpmiReq(ctypes.Structure):
+    _fields_ = [('addr', ctypes.POINTER(IpmiSystemInterfaceAddr)),
+                ('addr_len', ctypes.c_uint),
+                ('msgid', ctypes.c_long),
+                ('msg', IpmiMsg)]
+
+
+_IONONE = 0
+_IOWRITE = 1
+_IOREAD = 2
+IPMICTL_SET_MY_ADDRESS_CMD = (
+    _IOREAD << 30 | ctypes.sizeof(ctypes.c_uint) << 16
+    | ord('i') << 8 | 17)  # from ipmi.h
+IPMICTL_SEND_COMMAND = (
+    _IOREAD << 30 | ctypes.sizeof(IpmiReq) << 16
+    | ord('i') << 8 | 13)  # from ipmi.h
+# next is really IPMICTL_RECEIVE_MSG_TRUNC, but will only use that
+IPMICTL_RECV = (
+    (_IOWRITE | _IOREAD) << 30 | ctypes.sizeof(IpmiRecv) << 16
+    | ord('i') << 8 | 11)  # from ipmi.h
+BMC_SLAVE_ADDR = ctypes.c_uint(0x20)
+CURRCHAN = 0xf
+ADDRTYPE = 0xc
+
+
+class Session(object):
+    def __init__(self, devnode='/dev/ipmi0'):
+        """Create a local session inband
+
+        :param: devnode: The path to the ipmi device
+        """
+        self.ipmidev = open(devnode, 'r+')
+        fcntl.ioctl(self.ipmidev, IPMICTL_SET_MY_ADDRESS_CMD, BMC_SLAVE_ADDR)
+        # the interface is initted, create some reusable memory for our session
+        self.databuffer = ctypes.create_string_buffer(4096)
+        self.req = IpmiReq()
+        self.rsp = IpmiRecv()
+        self.addr = IpmiSystemInterfaceAddr()
+        self.req.msg.data = ctypes.cast(
+            ctypes.addressof(self.databuffer),
+            ctypes.POINTER(ctypes.c_ubyte))
+        self.rsp.msg.data = self.req.msg.data
+        self.userid = None
+        self.password = None
+
+    def await_reply(self):
+        rd, _, _ = select((self.ipmidev,), (), (), 1)
+        while not rd:
+            rd, _, _ = select((self.ipmidev,), (), (), 1)
+
+    async def pause(self, seconds):
+        await asyncio.sleep(seconds)
+
+    @property
+    def parsed_rsp(self):
+        response = {'netfn': self.rsp.msg.netfn, 'command': self.rsp.msg.cmd,
+                    'code': bytearray(self.databuffer.raw)[0],
+                    'data': bytearray(
+                        self.databuffer.raw[1:self.rsp.msg.data_len])}
+        errorstr = iutil.get_ipmi_error(response)
+        if errorstr:
+            response['error'] = errorstr
+        return response
+
+    def raw_command(self,
+                    netfn,
+                    command,
+                    data=(),
+                    bridge_request=None,
+                    retry=True,
+                    delay_xmit=None,
+                    timeout=None,
+                    waitall=False, rslun=0):
+        self.addr.channel = CURRCHAN
+        self.addr.addr_type = ADDRTYPE
+        self.addr.lun = rslun
+        self.req.addr_len = ctypes.sizeof(IpmiSystemInterfaceAddr)
+        self.req.addr = ctypes.pointer(self.addr)
+        self.req.msg.netfn = netfn
+        self.req.msg.cmd = command
+        if data:
+            data = memoryview(bytearray(data))
+            try:
+                self.databuffer[:len(data)] = data[:len(data)]
+            except ValueError:
+                self.databuffer[:len(data)] = data[:len(data)].tobytes()
+        self.req.msg.data_len = len(data)
+        fcntl.ioctl(self.ipmidev, IPMICTL_SEND_COMMAND, self.req)
+        self.await_reply()
+        self.rsp.msg.data_len = 4096
+        self.rsp.addr = ctypes.pointer(self.addr)
+        self.rsp.addr_len = ctypes.sizeof(IpmiSystemInterfaceAddr)
+        fcntl.ioctl(self.ipmidev, IPMICTL_RECV, self.rsp)
+        return self.parsed_rsp
+
+
+def main():
+    a = Session('/dev/ipmi0')
+    print(repr(a.raw_command(0, 1)))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/confluent_server/aiohmi/ipmi/private/serversession.py b/confluent_server/aiohmi/ipmi/private/serversession.py
new file mode 100644
index 00000000..a96a2342
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/serversession.py
@@ -0,0 +1,395 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This represents the server side of a session object
+Split into a separate file to avoid overly manipulating the as-yet
+client-centered session object
+"""
+
+import collections
+import hashlib
+import hmac
+import os
+import socket
+import struct
+import uuid
+
+import aiohmi.ipmi.private.constants as constants
+import aiohmi.ipmi.private.session as ipmisession
+
+
+class ServerSession(ipmisession.Session):
+    def __new__(cls, authdata, kg, clientaddr, netsocket, request, uuid,
+                bmc):
+        # Need to do default new type behavior.  The normal session
+        # takes measures to assure the caller shares even when they
+        # didn't try.  We don't have that operational mode to contend
+        # with in the server case (one file descriptor per bmc)
+        return object.__new__(cls)
+
+    def create_open_session_response(self, request):
+        clienttag = request[0]
+        # role = request[1]
+        self.clientsessionid = request[4:8]
+        # TODO(jbjohnso): intelligently handle integrity/auth/conf
+        # for now, forcibly do cipher suite 3
+        self.managedsessionid = os.urandom(4)
+        # table 13-17, 1 for now (hmac-sha1), 3 should also be supported
+        # table 13-18, integrity, 1 for now is hmac-sha1-96, 4 is sha256
+        # confidentiality: 1 is aes-cbc-128, the only one
+        self.privlevel = 4
+        response = (bytearray([clienttag, 0, self.privlevel, 0])
+                    + self.clientsessionid + self.managedsessionid
+                    + bytearray([
+                        0, 0, 0, 8, 1, 0, 0, 0,  # auth
+                        1, 0, 0, 8, 1, 0, 0, 0,  # integrity
+                        2, 0, 0, 8, 1, 0, 0, 0,  # privacy
+                    ]))
+        return response
+
+    def __init__(self, authdata, kg, clientaddr, netsocket, request, uuid,
+                 bmc):
+        # begin conversation per RMCP+ open session request
+        self.uuid = uuid
+        self.currhashlib = hashlib.sha1
+        self.currhashlen = 12
+        self.rqaddr = constants.IPMI_BMC_ADDRESS
+        self.authdata = authdata
+        self.servermode = True
+        self.ipmiversion = 2.0
+        self.sequencenumber = 0
+        self.sessionid = 0
+        self.bmc = bmc
+        self.lastpayload = None
+        self.rqlun = None  # This will be provided by the client
+        self.broken = False
+        self.authtype = 6
+        self.integrityalgo = 0
+        self.confalgo = 0
+        self.kg = kg
+        self.socket = netsocket
+        self.sockaddr = clientaddr
+        self.pendingpayloads = collections.deque([])
+        self.pktqueue = collections.deque([])
+        if clientaddr not in ipmisession.Session.bmc_handlers:
+            ipmisession.Session.bmc_handlers[clientaddr] = {bmc.port: self}
+        else:
+            ipmisession.Session.bmc_handlers[clientaddr][bmc.port] = self
+        response = self.create_open_session_response(bytearray(request))
+        self.send_payload(response,
+                          constants.payload_types['rmcpplusopenresponse'],
+                          retry=False)
+
+    def _got_rmcp_openrequest(self, data):
+        response = self.create_open_session_response(
+            struct.pack('B' * len(data), *data))
+        self.send_payload(response,
+                          constants.payload_types['rmcpplusopenresponse'],
+                          retry=False)
+
+    def _got_rakp1(self, data):
+        clienttag = data[0]
+        self.Rm = data[8:24]
+        self.rolem = data[24]
+        self.maxpriv = self.rolem & 0b111
+        namepresent = data[27]
+        if namepresent == 0:
+            # ignore null username for now
+            return
+        self.username = bytes(data[28:])
+        password = self.authdata.get(self.username.decode('utf-8'))
+        if password is None:
+            # don't think about invalid usernames for now
+            return
+        uuidbytes = self.uuid.bytes
+        self.uuiddata = uuidbytes
+        self.Rc = os.urandom(16)
+        hmacdata = (self.clientsessionid + self.managedsessionid
+                    + self.Rm + self.Rc + uuidbytes
+                    + bytearray([self.rolem, len(self.username)]))
+        hmacdata += self.username
+        self.kuid = password.encode('utf-8')
+        if self.kg is None:
+            self.kg = self.kuid
+        authcode = hmac.new(
+            self.kuid, bytes(hmacdata), hashlib.sha1).digest()
+        # regretably, ipmi mandates the server send out an hmac first
+        # akin to a leak of /etc/shadow, not too worrisome if the secret
+        # is complex, but terrible for most likely passwords selected by
+        # a human
+        newmessage = (bytearray([clienttag, 0, 0, 0]) + self.clientsessionid
+                      + self.Rc + uuidbytes + authcode)
+        self.send_payload(newmessage, constants.payload_types['rakp2'],
+                          retry=False)
+
+    def _got_rakp2(self, data):
+        # stub, server should not think about rakp2
+        pass
+
+    def _got_rakp3(self, data):
+        # for now drop rakp3 with bad authcode
+        # respond correctly a TODO(jjohnson2), since Kg being used
+        # yet incorrect is a scenario why rakp3 could be bad
+        # even if rakp2 was good
+        RmRc = self.Rm + self.Rc
+        self.sik = hmac.new(self.kg,
+                            bytes(RmRc)
+                            + struct.pack("2B", self.rolem, len(self.username))
+                            + self.username, hashlib.sha1).digest()
+        self.k1 = hmac.new(self.sik, b'\x01' * 20, hashlib.sha1).digest()
+        self.k2 = hmac.new(self.sik, b'\x02' * 20, hashlib.sha1).digest()
+        self.aeskey = self.k2[0:16]
+        hmacdata = (self.Rc + self.clientsessionid
+                    + struct.pack("2B", self.rolem, len(self.username))
+                    + self.username)
+        expectedauthcode = hmac.new(self.kuid, bytes(hmacdata), hashlib.sha1
+                                    ).digest()
+        authcode = struct.pack("%dB" % len(data[8:]), *data[8:])
+        if expectedauthcode != authcode:
+            # TODO(jjohnson2): RMCP error back at invalid rakp3
+            return
+        clienttag = data[0]
+        if data[1] != 0:
+            # client did not like our response, so ignore the rakp3
+            return
+        self.localsid = struct.unpack('<I', self.managedsessionid)[0]
+        self.ipmicallback = self.handle_client_request
+        self._send_rakp4(clienttag, 0)
+
+    def handle_client_request(self, request):
+        if request['netfn'] == 6 and request['command'] == 0x3b:
+            pendingpriv = request['data'][0]
+            returncode = 0
+            if pendingpriv > 1:
+                if pendingpriv > self.maxpriv:
+                    returncode = 0x81
+                else:
+                    self.clientpriv = request['data'][0]
+            self._send_ipmi_net_payload(code=returncode,
+                                        data=[self.clientpriv])
+        elif request['netfn'] == 6 and request['command'] == 0x3c:
+            self.send_ipmi_response()
+            self.close_server_session()
+        else:
+            self.bmc.handle_raw_request(request, self)
+
+    def close_server_session(self):
+        pass
+
+    def _send_rakp4(self, tagvalue, statuscode):
+        payload = bytearray(
+            [tagvalue, statuscode, 0, 0]) + self.clientsessionid
+        hmacdata = self.Rm + self.managedsessionid + self.uuiddata
+        hmacdata = struct.pack('%dB' % len(hmacdata), *hmacdata)
+        authdata = hmac.new(self.sik, hmacdata, hashlib.sha1).digest()[:12]
+        payload += authdata
+        self.send_payload(payload, constants.payload_types['rakp4'],
+                          retry=False)
+        self.confalgo = 'aes'
+        self.integrityalgo = 'sha1'
+        self.sequencenumber = 1
+        self.sessionid = struct.unpack(
+            '<I', struct.pack('4B', *self.clientsessionid))[0]
+
+    def _got_rakp4(self, data):
+        # stub, server should not think about rakp4
+        pass
+
+    def _timedout(self):
+        """Expire a client session after a period of inactivity
+
+        After the session inactivity timeout, this invalidate the client
+        session.
+        """
+        # for now, we will have a non-configurable 60 second timeout
+        pass
+
+    def _handle_channel_auth_cap(self, request):
+        """Handle incoming channel authentication capabilities request
+
+        This is used when serving as an IPMI target to service client
+        requests for client authentication capabilities
+        """
+        pass
+
+    def send_ipmi_response(self, data=[], code=0):
+        self._send_ipmi_net_payload(data=data, code=code)
+
+    def logout(self):
+        pass
+
+
+class IpmiServer(object):
+    # auth capabilities for now is a static payload
+    # for now always completion code 0, otherwise ignore
+    # authentication type fixed to ipmi2, ipmi1 forbidden
+    # 0b10000000
+
+    def __init__(self, authdata, port=623, bmcuuid=None, address='::'):
+        """Create a new ipmi bmc instance.
+
+        :param authdata: A dict or object with .get() to provide password
+                        lookup by username.  This does not support the full
+                        complexity of what IPMI can support, only a
+                        reasonable subset.
+        :param port: The default port number to bind to.  Defaults to the
+                     standard 623
+        :param address: The IP address to bind to. Defaults to '::' (all
+                        zeroes)
+        """
+        self.revision = 0
+        self.deviceid = 0
+        self.firmwaremajor = 1
+        self.firmwareminor = 0
+        self.ipmiversion = 2
+        self.additionaldevices = 0
+        self.mfgid = 0
+        self.prodid = 0
+        self.pktqueue = collections.deque([])
+        if bmcuuid is None:
+            self.uuid = uuid.uuid4()
+        else:
+            self.uuid = bmcuuid
+        lanchannel = 1
+        authtype = 0b10000000  # ipmi2 only
+        authstatus = 0b00000100  # change based on authdata/kg
+        chancap = 0b00000010  # ipmi2 only
+        oemdata = (0, 0, 0, 0)
+        self.authdata = authdata
+        self.authcap = struct.pack('BBBBBBBBB', 0, lanchannel, authtype,
+                                   authstatus, chancap, *oemdata)
+        self.kg = None
+        self.timeout = 60
+        self.port = port
+        addrinfo = socket.getaddrinfo(address, port, 0,
+                                      socket.SOCK_DGRAM)[0]
+        self.serversocket = ipmisession.Session._assignsocket(addrinfo)
+        ipmisession.Session.bmc_handlers[self.serversocket] = {0: self}
+
+    def send_auth_cap(self, myaddr, mylun, clientaddr, clientlun, clientseq,
+                      sockaddr):
+        header = bytearray(
+            b'\x06\x00\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10')
+        headerdata = [clientaddr, clientlun | (7 << 2)]
+        headersum = ipmisession._checksum(*headerdata)
+        header += bytearray(headerdata + [headersum, myaddr,
+                                          mylun | (clientseq << 2), 0x38])
+        header += self.authcap
+        bodydata = struct.unpack('B' * len(header[17:]), bytes(header[17:]))
+        header.append(ipmisession._checksum(*bodydata))
+        ipmisession._io_sendto(self.serversocket, header, sockaddr)
+
+    def process_pktqueue(self):
+        while self.pktqueue:
+            pkt = self.pktqueue.popleft()
+            self.sessionless_data(pkt[0], pkt[1])
+
+    def send_cipher_suites(self, myaddr, mylun, clientaddr, clientlun,
+                           clientseq, data, sockaddr):
+        # the last two bytes is length of message, fixed at 14 for now
+        # the rest is boilerplate ipmi, follow along in ipmi spec
+        # 'example ipmi over lan' if desired
+        header = bytearray(
+            b'\x06\x00\xff\x07\x06\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x0e\x00')
+        # now the generic inner ipmi packet, per figure-13-4,
+        # ipmi lan message formats
+        ipmihdr = bytearray([clientaddr, clientlun | (7 << 2)])
+        hdrsum = ipmisession._checksum(*ipmihdr)
+        ipmihdr.append(hdrsum)
+        rq = bytearray([myaddr, mylun | clientseq << 2, 0x54])
+        # for now, hard code a cipher suite 3 only response
+        rq.extend(bytearray(b'\x00\x01\xc0\x03\x01\x41\x81'))
+        hdrsum = ipmisession._checksum(*rq)
+        rq.append(hdrsum)
+        pkt = header + ipmihdr + rq
+        ipmisession._io_sendto(self.serversocket, pkt, sockaddr)
+
+    def sessionless_data(self, data, sockaddr):
+        """Examines unsolocited packet and decides appropriate action.
+
+        For a listening IpmiServer, a packet without an active session
+        comes here for examination.  If it is something that is utterly
+        sessionless (e.g. get channel authentication), send the appropriate
+        response.  If it is a get session challenge or open rmcp+ request,
+        spawn a session to handle the context.
+        """
+        if len(data) < 22:
+            return
+        data = bytearray(data)
+        if not (data[0] == 6 and data[2:4] == b'\xff\x07'):  # not ipmi
+            return
+        if data[4] == 6:  # ipmi 2 payload...
+            payloadtype = data[5]
+            if payloadtype not in (0, 16):
+                return
+            if payloadtype == 16:  # new session to handle conversation
+                ServerSession(self.authdata, self.kg, sockaddr,
+                              self.serversocket, data[16:], self.uuid,
+                              bmc=self)
+                return
+            # ditch two byte, because ipmi2 header is two
+            # bytes longer than ipmi1 (payload type added, payload length 2).
+            data = data[2:]
+        myaddr, netfnlun = struct.unpack('2B', bytes(data[14:16]))
+        netfn = (netfnlun & 0b11111100) >> 2
+        mylun = netfnlun & 0b11
+        if netfn == 6:  # application request
+            if data[19] == 0x38:  # cmd = get channel auth capabilities
+                verchannel, level = struct.unpack('2B', bytes(data[20:22]))
+                version = verchannel & 0b10000000
+                if version != 0b10000000:
+                    return
+                channel = verchannel & 0b1111
+                if channel != 0xe:
+                    return
+                (clientaddr, clientlun) = struct.unpack(
+                    'BB', bytes(data[17:19]))
+                clientseq = clientlun >> 2
+                clientlun &= 0b11  # Lun is only the least significant bits
+                level &= 0b1111
+                self.send_auth_cap(myaddr, mylun, clientaddr, clientlun,
+                                   clientseq, sockaddr)
+            elif data[19] == 0x54:
+                clientaddr, clientlun = data[17:19]
+                clientseq = clientlun >> 2
+                clientlun &= 0b11
+                self.send_cipher_suites(myaddr, mylun, clientaddr, clientlun,
+                                        clientseq, data, sockaddr)
+
+    def set_kg(self, kg):
+        """Sets the Kg for the BMC to use
+
+        In RAKP, Kg is a BMC-specific integrity key that can be set.  If not
+        set, Kuid is used for the integrity key
+        """
+        try:
+            self.kg = kg.encode('utf-8')
+        except AttributeError:
+            self.kg = kg
+
+    def send_device_id(self, session):
+        response = [self.deviceid, self.revision, self.firmwaremajor,
+                    self.firmwareminor, self.ipmiversion,
+                    self.additionaldevices]
+        response += struct.unpack('4B', struct.pack('<I', self.mfgid))
+        response += struct.unpack('4B', struct.pack('<I', self.prodid))
+        session.send_ipmi_response(data=response)
+
+    def handle_raw_request(self, request, session):
+        # per table 5-2, completion code 0xc1 is 'unrecognized'
+        session.send_ipmi_response(code=0xc1)
+
+    def logout(self):
+        pass
diff --git a/confluent_server/aiohmi/ipmi/private/session.py b/confluent_server/aiohmi/ipmi/private/session.py
new file mode 100644
index 00000000..23e15db6
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/session.py
@@ -0,0 +1,1975 @@
+# Copyright 2013 IBM Corporation
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This represents the low layer message framing portion of IPMI"""
+
+import collections
+import hashlib
+import hmac
+import operator
+import os
+import random
+import select
+import socket
+import struct
+#import threading
+import asyncio
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.ciphers import algorithms
+from cryptography.hazmat.primitives.ciphers import Cipher
+from cryptography.hazmat.primitives.ciphers import modes
+
+import aiohmi.exceptions as exc
+from aiohmi.ipmi.private import constants
+from aiohmi.ipmi.private import util
+from aiohmi.ipmi.private.util import _monotonic_time
+from aiohmi.ipmi.private.util import get_ipmi_error
+
+
+KEEPALIVE_SESSIONS = asyncio.Lock()
+WAITING_SESSIONS = asyncio.Lock()
+
+
+try:
+    dict.iteritems
+
+    def dictitems(d):
+        return d.iteritems()
+except AttributeError:
+    def dictitems(d):
+        return d.items()
+
+# minimum timeout for first packet to retry in any given
+# session.  This will be randomized to stagger out retries
+# in case of congestion
+initialtimeout = 0.5
+# the thread in which all IO will be performed
+# While the model as-is works fine for it's own coroutine
+# structure, when combined with threading or something like
+# eventlet, it becomes difficult for the calling code to cope
+# This thread will tuck away the threading situation such that
+# calling code doesn't have to do any gymnastics to cope with
+# the nature of things.
+iothread = None
+# whether io thread is yet ready to work
+iothreadready = False
+# threads waiting for iothreadready
+iothreadwaiters = []
+ioqueue = collections.deque([])
+myself = None
+ipv6support = None
+selectdeadline = 0
+running = True
+# set of iosockets that will be shared amongst Session objects
+iosockets = []
+# no more than this many BMCs will share a socket
+# this could be adjusted based on rmem_max
+# value, leading to fewer filehandles
+MAX_BMCS_PER_SOCKET = 64
+
+# maximum time to allow idle, more than this and BMC may assume
+MAX_IDLE = 29
+# incorrect idle
+
+
+def unmatched(response, netfn, cmd):
+    if not response:
+        return True
+    return response['command'] != cmd or response['netfn'] != netfn
+
+sockwatching = True
+
+async def terminate():
+    global sockwatching
+    await Session._cleanup()
+    sockwatching = False
+    iosockets[0].sendto(
+                b'\x01', (myself, iosockets[0].getsockname()[1]))
+
+def sock_completion(cloop, currsock, fut):
+    cloop.remove_reader(currsock)
+    fut.set_result(None)
+
+async def watchsockets():
+    global sockwatching
+    sockwatching = True
+    global iothreadready
+    global selectdeadline
+    iowaiters = []
+    directediowaiters = {}
+    timeout = 300
+    iothreadready = True
+    while iothreadwaiters:
+        waiter = iothreadwaiters.pop()
+        waiter.set()
+    while sockwatching:
+        if timeout < 0:
+            timeout = 0
+        selectdeadline = _monotonic_time() + timeout
+        currfutures = []
+        for currsock in iosockets:
+            currfut = asyncio.Future()
+            asyncio.get_event_loop().add_reader(currsock, sock_completion, asyncio.get_event_loop(), currsock, currfut)
+            currfutures.append(currfut)
+        #select.select(iosockets, (), (), timeout)
+        done, futures = await asyncio.wait(currfutures, timeout=timeout, return_when=asyncio.FIRST_COMPLETED)
+        for currfut in done:
+            await currfut
+        # pessimistically move out the deadline
+        # doing it this early (before ioqueue is evaluated)
+        # this avoids other threads making a bad assumption
+        # about not having to break into the select
+        selectdeadline = _monotonic_time() + 300
+        timeout = 300
+        sockaddrs = _io_graball(iosockets, directediowaiters)
+        for w in iowaiters:
+            w[1].set()
+        iowaiters = []
+        for d in list(directediowaiters):
+            # these are the existing waiters that didn't get
+            # satisfied last graball, allow them to set a new
+            # deadline if they still have time waiting, or
+            # if they have expired, wake them now to let them
+            # process their timeout
+            rightnow = _monotonic_time()
+            for idx, w in reversed(list(
+                    enumerate(directediowaiters[d]))):
+                ltimeout = w[0] - rightnow
+                if ltimeout < 0:
+                    w[1].set()  # time is up, wake the caller
+                    del directediowaiters[d][idx]
+                elif ltimeout < timeout:
+                    timeout = ltimeout
+            if not directediowaiters[d]:
+                del directediowaiters[d]
+        while ioqueue:
+            workitem = ioqueue.popleft()
+            # order: function, args, list to append to , event to set
+            if workitem[2] is None and sockaddrs:
+                workitem[1].set()
+            elif workitem[2] in sockaddrs:
+                workitem[1].set()
+            else:
+                ltimeout = workitem[0] - _monotonic_time()
+                if ltimeout < timeout:
+                    timeout = ltimeout
+                if workitem[2] is None:
+                    iowaiters.append(workitem)
+                else:
+                    if workitem[2] in directediowaiters:
+                        directediowaiters[workitem[2]].append(workitem)
+                    else:
+                        directediowaiters[workitem[2]] = [workitem]
+
+
+
+
+sessionqueue = collections.deque([])
+
+
+async def _io_wait(timeout, myaddr=None, evq=None):
+    evt = asyncio.Event()
+    if evq is not None:
+        evq.append(evt)
+    deadline = timeout + _monotonic_time()
+    ioqueue.append((deadline, evt, myaddr))
+    # Unfortunately, at least with eventlet patched threading, the wait()
+    # is a somewhat busy wait if given a deadline.  Workaround by having
+    # it piggy back on the select() in the io thread, which is a truly
+    # lazy wait even with eventlet involvement
+    if deadline < selectdeadline:
+        intsock = iosockets[0]
+        if hasattr(intsock, 'fd'):
+            # if in eventlet, go for the true sendto, which is less glitchy
+            intsock = intsock.fd
+        intsock.sendto(b'\x01', (myself, iosockets[0].getsockname()[1]))
+    await evt.wait()
+
+
+def _io_sendto(mysocket, packet, sockaddr):
+    # Want sendto to act reasonably sane..
+    mysocket.setblocking(1)
+    if hasattr(mysocket, 'fd'):
+        mysocket = mysocket.fd
+    try:
+        mysocket.sendto(packet, sockaddr)
+    except Exception:
+        pass
+
+
+def _io_graball(mysockets, iowaiters):
+    sockaddrs = []
+    for mysocket in mysockets:
+        while True:
+            rdata = _io_recvfrom(mysocket, 3000)
+            if rdata is None:
+                break
+            # If the payload is shorter than 4 bytes, it cannot
+            # be a useful packet.  Skip it entirely.
+            # This applies to the packet sent to self to break
+            # into the select
+            if len(rdata[0]) < 4:
+                continue
+            myport = mysocket.getsockname()[1]
+            rdata = rdata + (mysocket,)
+            relsession = None
+            if (rdata[1] in Session.bmc_handlers
+                    and myport in Session.bmc_handlers[rdata[1]]):
+                # session data
+                rdata = rdata + (True,)
+                relsession = Session.bmc_handlers[rdata[1]][myport]
+            elif rdata[2] in Session.bmc_handlers:
+                # aiohmi is the bmc, and we have sessionless data
+                rdata = rdata + (False,)
+                relsession = Session.bmc_handlers[rdata[2]][0]
+            if relsession is not None:
+                relsession.pktqueue.append(rdata)
+                sessionqueue.append(relsession)
+            if rdata[1] in iowaiters:
+                for w in iowaiters[rdata[1]]:
+                    w[1].set()
+                del iowaiters[rdata[1]]
+            sockaddrs.append(rdata[1])
+    return sockaddrs
+
+
+def _io_recvfrom(mysocket, size):
+    mysocket.setblocking(0)
+    try:
+        return mysocket.recvfrom(size)
+    except socket.error:
+        return None
+
+
+try:
+    IPPROTO_IPV6 = socket.IPPROTO_IPV6
+except AttributeError:
+    IPPROTO_IPV6 = 41  # This is the Win32 version of IPPROTO_IPV6, the only
+    # platform where python *doesn't* have this in socket that aiohmi is
+    # targetting.
+
+
+async def _poller(timeout=0):
+    if sessionqueue:
+        return True
+    await _io_wait(timeout)
+    return sessionqueue
+
+
+def _aespad(data):
+    """ipmi demands a certain pad scheme, per table 13-20 AES-CBC encrypted
+
+    payload fields.
+    """
+    currlen = len(data) + 1  # need to count the pad length field as well
+    neededpad = currlen % 16
+    if neededpad:  # if it happens to be zero, hurray, but otherwise invert the
+        # sense of the padding
+        neededpad = 16 - neededpad
+    padval = 1
+    pad = bytearray(neededpad)
+    while padval <= neededpad:
+        pad[padval - 1] = padval
+        padval += 1
+    pad.append(neededpad)
+    return pad
+
+
+def _checksum(*data):  # Two's complement over the data
+    csum = sum(data)
+    csum ^= 0xff
+    csum += 1
+    csum &= 0xff
+    return csum
+
+
+class Session(object):
+    """A class to manage common IPMI session logistics
+
+    Almost all developers should not worry about this class and instead be
+    looking toward ipmi.Command and ipmi.Console.
+
+    For those that do have to worry, the main interesting thing is that the
+    event loop can go one of two ways.  Either a larger manager can query using
+    class methods
+    the soonest timeout deadline and the filehandles to poll and assume
+    responsibility for the polling, or it can register filehandles to be
+    watched.  This is primarily of interest to Console class, which may have an
+    input filehandle to watch and can pass it to Session.
+
+    :param bmc: hostname or ip address of the BMC
+    :param userid: username to use to connect
+    :param password: password to connect to the BMC
+    :param kg: optional parameter if BMC requires Kg be set
+    :param port: UDP port to communicate with, pretty much always 623
+    :param onlogon: callback to receive notification of login completion
+    """
+    bmc_handlers = {}
+    waiting_sessions = {}
+    initting_sessions = {}
+    keepalive_sessions = {}
+    peeraddr_to_nodes = {}
+    iterwaiters = []
+    # NOTE(jbjohnso):
+    # socketpool is a mapping of sockets to usage count
+    socketpool = {}
+    # this will be a lock.  Delay the assignment so that a calling framework
+    # can do something like reassign our threading and select modules
+    socketchecking = None
+
+    # Maintain single Cryptography backend for all IPMI sessions (seems to be
+    # thread-safe)
+    _crypto_backend = default_backend()
+
+    @classmethod
+    async def _cleanup(cls):
+        for sesskey in list(cls.bmc_handlers):
+            for portent in list(cls.bmc_handlers[sesskey]):
+                session = cls.bmc_handlers[sesskey][portent]
+                session.cleaningup = True
+                await session.logout(False)
+
+    @classmethod
+    async def _assignsocket(cls, server=None, forbiddensockets=()):
+        global iothread
+        global iothreadready
+        global iosockets
+        global ipv6support
+        global myself
+
+        # seek for the least used socket.  As sessions close, they may free
+        # up slots in seemingly 'full' sockets.  This scheme allows those
+        # slots to be recycled
+        sorted_candidates = None
+        if server is None:
+            sorted_candidates = sorted(dictitems(cls.socketpool),
+                                       key=operator.itemgetter(1))
+        if sorted_candidates is None:
+            sorted_candidates = []
+        for candidate in sorted_candidates:
+            if candidate[1] >= MAX_BMCS_PER_SOCKET:
+                break
+            if candidate[0] in forbiddensockets:
+                continue
+            cls.socketpool[candidate[0]] += 1
+            return candidate[0]
+        # we need a new socket
+        if server:
+            # Regardless of whether ipv6 is supported or not, we
+            # must try to honor the address format of the given
+            # server, rather than trying to create an automatic one
+            tmpsocket = socket.socket(server[0], socket.SOCK_DGRAM)
+            if server[0] == socket.AF_INET6:
+                tmpsocket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+        elif ipv6support:
+            tmpsocket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+            tmpsocket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+        elif ipv6support is None:  # we need to determine ipv6 support now
+            try:
+                tmpsocket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+                tmpsocket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+                ipv6support = True
+            except socket.error:
+                ipv6support = False
+                myself = '127.0.0.1'
+                tmpsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        else:
+            tmpsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            tmpsocket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 16777216)
+        except Exception:
+            pass        
+        if server is None:
+            # Rather than wait until send() to bind, bind now so that we have
+            # a port number allocated no matter what
+            tmpsocket.bind(('', 0))
+            cls.socketpool[tmpsocket] = 1
+        else:
+            tmpsocket.bind(server[4])
+        iosockets.append(tmpsocket)
+        if myself is None:
+            # we have confirmed kernel IPv6 support, but ::1 may still not
+            # be there
+            try:
+                iosockets[0].sendto(
+                    b'\x01', ('::1', iosockets[0].getsockname()[1]))
+                myself = '::1'
+            except socket.error:
+                # AF_INET6, but no '::1', try the AF_INET6 version of 127
+                myself = '::ffff:127.0.0.1'
+        if iothread is None:
+            initevt = asyncio.Event()
+            iothreadwaiters.append(initevt)
+            iothread = asyncio.get_event_loop().create_task(watchsockets())
+            await initevt.wait()
+        elif not iothreadready:
+            initevt = asyncio.Event()
+            iothreadwaiters.append(initevt)
+            await initevt.wait()
+        return tmpsocket
+
+    def _sync_login(self, response):
+        """Handle synchronous callers in lieu of a client-provided callback"""
+        # Be a stub, the __init__ will catch and respond to ensure response
+        # is given in the same thread as was called
+        return
+
+    @classmethod
+    async def _is_session_valid(cls, session):
+        await KEEPALIVE_SESSIONS.acquire()
+        try:
+            sess = cls.keepalive_sessions.get(session, None)
+            if sess is not None and 'timeout' in sess:
+                if sess['timeout'] < _monotonic_time() - 15:
+                    # session would have timed out by now, don't use it
+                    return False
+        finally:
+            KEEPALIVE_SESSIONS.release()
+        return not session.broken
+
+    async def __new__(cls,
+                bmc,
+                userid,
+                password,
+                port=623,
+                kg=None,
+                privlevel=None,
+                keepalive=True):
+        trueself = None
+        forbidsock = []
+        for res in socket.getaddrinfo(bmc, port, 0, socket.SOCK_DGRAM):
+            sockaddr = res[4]
+            if ipv6support and res[0] == socket.AF_INET:
+                # convert the sockaddr to AF_INET6
+                newhost = '::ffff:' + sockaddr[0]
+                sockaddr = (newhost, sockaddr[1], 0, 0)
+            if sockaddr in cls.bmc_handlers:
+                for portself in list(dictitems(cls.bmc_handlers[sockaddr])):
+                    self = portself[1]
+                    if not ((self.logged or self.logging)
+                            and await cls._is_session_valid(self)):
+                        # we have encountered a leftover broken session
+                        del cls.bmc_handlers[sockaddr][portself[0]]
+                        continue
+                    if (self.bmc == bmc
+                            and self.userid == userid
+                            and self.password == password
+                            and self.kgo == kg):
+                        trueself = self
+                        break
+                    # ok, the candidate seems to be working, but does not match
+                    # will need to allow creation of a new session, but
+                    # must forbid use of this socket so that the socket
+                    # share routing code does not get confused.
+                    # in principle, should be able to distinguish by session
+                    # id, however it's easier this way
+                    forbidsock.append(self.socket)
+            if trueself:
+                return trueself
+            i = cls.initting_sessions.get(
+                (bmc, userid, password, port, kg), False)
+            if i:
+                i.initialized = True
+                i.logging = True
+                return i
+            self = super().__new__(cls)
+            self.forbidsock = forbidsock
+            await self.__init__(
+                bmc, userid, password, port, kg, privlevel, keepalive)
+            cls.initting_sessions[(bmc, userid, password, port, kg)] = self
+            return self
+
+    async def __init__(self,
+                 bmc,
+                 userid,
+                 password,
+                 port=623,
+                 kg=None,
+                 privlevel=None,
+                 keepalive=True):
+        if hasattr(self, 'initialized'):
+            # new found an existing session, do not corrupt it
+            while self.logging and not self.broken:
+                await Session.wait_for_rsp()
+        self.awaitingresponse = False
+        self.lastresponse = None
+        self.atomicop = asyncio.Lock()
+        self.broken = False
+        self.socket = None
+        self.logged = 0
+        if privlevel is not None:
+            self.privlevel = privlevel
+            self.autopriv = False
+        else:
+            self.privlevel = 4
+            self.autopriv = True
+        self.onlogpayload = None
+        self.onlogpayloadtype = None
+        self.logoutexpiry = None
+        self.autokeepalive = keepalive
+        self.maxtimeout = 2  # be aggressive about giving up on initial packet
+        self.incommand = False
+        self.nameonly = 16  # default to name only lookups in RAKP exchange
+        self.servermode = False
+        self.initialized = True
+        self.cleaningup = False
+        self.lastpayload = None
+        self._customkeepalives = None
+        # queue of events denoting line to run a cmd
+        self.evq = collections.deque([])
+        self.bmc = bmc
+        # a private queue for packets for which this session handler
+        # is destined to receive
+        self.pktqueue = collections.deque([])
+
+        try:
+            self.userid = userid.encode('utf-8')
+            self.password = password.encode('utf-8')
+        except AttributeError:
+            self.userid = userid
+            self.password = password
+        self.nowait = False
+        self.pendingpayloads = collections.deque([])
+        self.request_entry = []
+        self.kgo = kg
+        if kg is not None:
+            try:
+                kg = kg.encode('utf-8')
+            except AttributeError:
+                pass
+            self.kg = kg
+        else:
+            self.kg = self.password
+        self.port = port
+        self.async_ = False
+        self.logonwaiters = [self._sync_login]
+        if self.__class__.socketchecking is None:
+            self.__class__.socketchecking = asyncio.Lock()
+        await self.socketchecking.acquire()
+        try:
+            self.socket = await self._assignsocket(forbiddensockets=self.forbidsock)
+        finally:
+            self.socketchecking.release()
+        await self.login()
+        if not self.async_:
+            while self.logging:
+                await Session.wait_for_rsp()
+        if self.broken:
+            raise exc.IpmiException(self.errormsg)
+
+    async def _mark_broken(self, error=None):
+        # since our connection has failed retries
+        # deregister our keepalive facility
+        self.lastpayload = None
+        self.onlogpayload = None
+        await KEEPALIVE_SESSIONS.acquire()
+        try:
+            Session.keepalive_sessions.pop(self, None)
+        finally:
+            KEEPALIVE_SESSIONS.release()
+        await WAITING_SESSIONS.acquire()
+        try:
+            Session.waiting_sessions.pop(self, None)
+        finally:
+            WAITING_SESSIONS.release()
+        try:
+            del Session.initting_sessions[(self.bmc, self.userid,
+                                           self.password, self.port,
+                                           self.kgo)]
+        except KeyError:
+            pass
+        await self.logout(False)
+        # self.logging = False
+        self.errormsg = error
+        if not self.broken:
+            self.broken = True
+            if self.socket:
+                self.socketpool[self.socket] -= 1
+        while self.logonwaiters:
+            waiter = self.logonwaiters.pop()
+            try:
+                waiter({'error': 'Session failed to initialize'})
+            except Exception:
+                pass
+
+    async def onlogon(self, parameter):
+        if 'error' in parameter:
+            while self.logonwaiters:
+                waiter = self.logonwaiters.pop()
+                waiter(parameter)
+            await self._mark_broken(parameter['error'])
+        elif self.onlogpayload:
+            await self._cmdwait()
+            payload = self.onlogpayload
+            payload_type = self.onlogpayloadtype
+            self.incommand = _monotonic_time() + self._getmaxtimeout()
+            self.onlogpayload = None
+            await self.send_payload(payload, payload_type)
+        while self.logonwaiters:
+            waiter = self.logonwaiters.pop()
+            waiter(parameter)
+
+    def _initsession(self):
+        # NOTE(jbjohnso): this number can be whatever we want.
+        #                 I picked 'xCAT' minus 1 so that a hexdump of packet
+        #                 would show xCAT
+        self.localsid = 2017673555
+        self.remseqnumber = None
+        self.confalgo = 0
+        self.aeskey = None
+        self.integrityalgo = 0
+        self.attemptedhash = 256
+        self.currhashlib = None
+        self.currhashlen = 0
+        self.k1 = None
+        self.rmcptag = 1
+        self.lastpayload = None
+        self.ipmicallback = None
+        self.sessioncontext = None
+        self.sequencenumber = 0
+        self.sessionid = 0
+        self.authtype = 0
+        self.ipmiversion = 1.5
+        self.timeout = initialtimeout + (0.5 * random.random())
+        self.logoutexpiry = _monotonic_time() + self._getmaxtimeout()
+        self.rqlun = 0
+        self.seqlun = 0
+        # NOTE(jbjohnso): per IPMI table 5-4, software ids in the ipmi spec may
+        #                 be 0x81 through 0x8d.  We'll stick with 0x81 for now,
+        #                 do not forsee a reason to adjust
+        self.rqaddr = 0x81
+
+        self.logging = True
+        self.logged = 0
+        # NOTE(jbjohnso): when we confirm a working sockaddr, put it here to
+        #                 skip getaddrinfo
+        self.sockaddr = None
+        # NOTE(jbjohnso): this tracks netfn,command,seqlun combinations that
+        #                 were retried so that we don't loop around and reuse
+        #                 the same request data and cause potential ambiguity
+        #                 in return
+        self.tabooseq = {}
+        # NOTE(jbjohnso): default to supporting ipmi 2.0.  Strictly by spec,
+        #                 this should gracefully be backwards compat, but some
+        #                 1.5 implementations checked reserved bits
+        self.ipmi15only = 0
+        self.sol_handler = None
+        # NOTE(jbjohnso): This is the callback handler for any SOL payload
+
+    def _make_bridge_request_msg(self, channel, netfn, command):
+        """This function generate message for bridge request. It is a
+
+        part of ipmi payload.
+        """
+        # NOTE(puwen): need to pay attention for this function because the
+        # structure does not seem to match the specifications.
+        head = bytearray((constants.IPMI_BMC_ADDRESS,
+                          constants.netfn_codes['application'] << 2))
+        check_sum = _checksum(*head)
+        # NOTE(fengqian): according IPMI Figure 14-11, rqSWID is set to 81h
+        boday = bytearray((0x81, (self.seqlun << 2) | self.rqlun,
+                           constants.IPMI_SEND_MESSAGE_CMD, 0x40 | channel))
+        # NOTE(fengqian): Track request
+        self._add_request_entry((constants.netfn_codes['application'] + 1,
+                                 self.seqlun, constants.IPMI_SEND_MESSAGE_CMD))
+        return head + bytearray((check_sum,)) + boday
+
+    def _add_request_entry(self, entry=()):
+        """This function record the request with netfn, sequence number and
+
+        command, which will be used in parse_ipmi_payload.
+        :param entry: a set of netfn, sequence number and command.
+        """
+        if not self._lookup_request_entry(entry):
+            self.request_entry.append(entry)
+
+    def _lookup_request_entry(self, entry=()):
+        return entry in self.request_entry
+
+    def _remove_request_entry(self, entry=()):
+        if self._lookup_request_entry(entry):
+            self.request_entry.remove(entry)
+
+    def _make_ipmi_payload(self, netfn, command, bridge_request=None, data=(),
+                           rslun=0):
+        """This function generates the core ipmi payload that would be
+
+        applicable for any channel (including KCS)
+        """
+        bridge_msg = []
+        self.expectedcmd = command
+        # in ipmi, the response netfn is always one
+        self.expectednetfn = netfn + 1
+        # higher than the request payload, we assume
+        # we are always the requestor for now
+        seqincrement = 7  # IPMI spec forbids gaps bigger then 7 in seq number.
+        # Risk the taboo rather than violate the rules
+        while (not self.servermode
+               and (netfn, command, self.seqlun) in self.tabooseq
+               and self.tabooseq[(netfn, command, self.seqlun)]
+               and seqincrement):
+            self.tabooseq[(self.expectednetfn, command, self.seqlun)] -= 1
+            # Allow taboo to eventually expire after a few rounds
+            self.seqlun += 1  # the last two bits are lun, so add 4 to add 1
+            self.seqlun &= 0x3f  # we only have one byte, wrap when exceeded
+            seqincrement -= 1
+
+        if bridge_request:
+            addr = bridge_request.get('addr', 0x0)
+            channel = bridge_request.get('channel', 0x0)
+            bridge_msg = self._make_bridge_request_msg(channel, netfn, command)
+            # NOTE(fengqian): For bridge request, rsaddr is specified and
+            # rqaddr is BMC address.
+            rqaddr = constants.IPMI_BMC_ADDRESS
+            rsaddr = addr
+        else:
+            rqaddr = self.rqaddr
+            rsaddr = constants.IPMI_BMC_ADDRESS
+        if self.servermode:
+            rsaddr = self.clientaddr
+        # figure 13-4, first two bytes are rsaddr and
+        # netfn, for non-bridge request, rsaddr is always 0x20 since we are
+        # addressing BMC while rsaddr is specified forbridge request
+        header = bytearray((rsaddr, (netfn << 2) | rslun))
+        reqbody = bytearray(
+            (rqaddr, (self.seqlun << 2) | self.rqlun, command)) + data
+        headsum = bytearray((_checksum(*header),))
+        bodysum = bytearray((_checksum(*reqbody),))
+        payload = header + headsum + reqbody + bodysum
+        if bridge_request:
+            payload = bridge_msg + payload
+            # NOTE(fengqian): For bridge request, another check sum is needed.
+            tail_csum = _checksum(*payload[3:])
+            payload.append(tail_csum)
+
+        if not self.servermode:
+            self._add_request_entry((self.expectednetfn, self.seqlun, command))
+        return payload
+
+    async def _generic_callback(self, response):
+        errorstr = get_ipmi_error(response)
+        if errorstr:
+            response['error'] = errorstr
+        self.lastresponse = response
+
+    def _isincommand(self):
+        if self.incommand:
+            stillin = self.incommand - _monotonic_time()
+            if stillin > 0:
+                return stillin
+            else:
+                self.lastpayload = None
+        return 0
+
+    def _getmaxtimeout(self):
+        cumulativetime = 0
+        incrementtime = self.timeout
+        while incrementtime < self.maxtimeout:
+            cumulativetime += incrementtime
+            incrementtime += 1
+        return (cumulativetime + 1) * (self.logontries + 1)
+
+    async def _cmdwait(self):
+        while self._isincommand():
+            await _io_wait(self._isincommand(), self.sockaddr, self.evq)
+
+    async def awaitresponse(self, retry, netfn, command):
+        self.awaitingresponse = True
+        try:
+            alltimeout = _monotonic_time() + (self._getmaxtimeout() * 2)
+            while (retry and unmatched(self.lastresponse, netfn, command)
+                    and (self.logging or self.logged or self.onlogpayload)):
+                timeout = self.expiration - _monotonic_time()
+                await _io_wait(timeout, self.sockaddr)
+                while self.iterwaiters:
+                    waiter = self.iterwaiters.pop()
+                    waiter({'success': True})
+                await self.process_pktqueue()
+                if _monotonic_time() > alltimeout:
+                    await self._mark_broken()
+                    raise exc.IpmiException('Session no longer connected')
+                await WAITING_SESSIONS.acquire()
+                try:
+                    if (self in self.waiting_sessions
+                            and self.expiration < _monotonic_time()):
+                        self.waiting_sessions.pop(self, None)
+                        if not self.lastpayload and not self.logging:
+                            return
+                        await self._timedout()
+                finally:
+                    WAITING_SESSIONS.release()
+        finally:
+            self.awaitingresponse = False
+
+
+
+    async def raw_command(self,
+                    netfn,
+                    command,
+                    bridge_request=None,
+                    data=(),
+                    retry=True,
+                    timeout=None,
+                    callback=None,
+                    rslun=0):
+        while (self.logging and not self.logged
+                and _monotonic_time() < self.logoutexpiry):
+            await self.pause(1)
+        if not self.logged:
+            if (self.logoutexpiry is not None
+                    and _monotonic_time() > self.logoutexpiry):
+                await self._mark_broken()
+            raise exc.IpmiException('Session no longer connected')
+        await self.atomicop.acquire()
+        try:
+            await self._cmdwait()
+            if not self.logged:
+                raise exc.IpmiException('Session no longer connected')
+            self.incommand = _monotonic_time() + self._getmaxtimeout()
+        finally:
+            self.atomicop.release()
+        self.lastresponse = None
+        if callback is None:
+            self.ipmicallback = self._generic_callback
+        else:
+            self.ipmicallback = callback
+        await self._send_ipmi_net_payload(netfn, command, data,
+                                    bridge_request=bridge_request,
+                                    retry=retry,
+                                    timeout=timeout, rslun=rslun)
+
+        if retry:  # in retry case, let the retry timers indicate wait time
+            timeout = None
+        else:  # if not retry, give it a second before surrending
+            timeout = 1
+        if callback:
+            # caller *must* clean up self.incommand and self.evq
+            return
+        # The event loop is shared amongst aiohmi session instances
+        # within a process.  In this way, synchronous usage of the interface
+        # plays well with asynchronous use.  In fact, this produces the
+        # behavior of only the constructor needing a callback.  From then on,
+        # synchronous usage of the class acts in a greenthread style governed
+        # by order of data on the network
+        await self.awaitresponse(retry, netfn + 1, command)
+        lastresponse = self.lastresponse
+        self.lastresponse = None
+        self.incommand = False
+        while self.evq:
+            self.evq.popleft().set()
+        if retry and lastresponse is None:
+            raise exc.IpmiException('Session no longer connected')
+        return lastresponse
+
+    async def _send_ipmi_net_payload(self, netfn=None, command=None, data=(), code=0,
+                               bridge_request=None,
+                               retry=None, timeout=None,
+                               rslun=0):
+        if retry is None:
+            retry = not self.servermode
+        if self.servermode:
+            data = bytearray((code,)) + bytearray(data)
+            if netfn is None:
+                netfn = self.clientnetfn
+            if command is None:
+                command = self.clientcommand
+        else:
+            data = bytearray(data)
+        ipmipayload = self._make_ipmi_payload(netfn, command, bridge_request,
+                                              data, rslun)
+        payload_type = constants.payload_types['ipmi']
+        await self.send_payload(payload=ipmipayload, payload_type=payload_type,
+                                retry=retry, timeout=timeout)
+
+    async def send_payload(self, payload=(), payload_type=None, retry=True,
+                     needskeepalive=False, timeout=None):
+        """Send payload over the IPMI Session
+
+        :param needskeepalive: If the payload is expected not to count as
+                               'active' by the BMC, set this to True
+                               to avoid Session considering the
+                               job done because of this payload.
+                               Notably, 0-length SOL packets
+                               are prone to confusion.
+        :param timeout: Specify a custom timeout for long-running request
+        """
+        if payload and self.lastpayload:
+            # we already have a packet outgoing, make this
+            # a pending payload
+            # this way a simplistic BMC won't get confused
+            # and we also avoid having to do more complicated
+            # retry mechanism where each payload is
+            # retried separately
+            self.pendingpayloads.append((payload, payload_type, retry))
+            return
+        if payload_type is None:
+            payload_type = self.last_payload_type
+        if not payload:
+            payload = self.lastpayload
+        message = bytearray(b'\x06\x00\xff\x07')  # constant IPMI RMCP header
+        if retry:
+            self.lastpayload = payload
+            self.last_payload_type = payload_type
+        if not isinstance(payload, bytearray):
+            payload = bytearray(payload)
+        message.append(self.authtype)
+        baretype = payload_type
+        if self.integrityalgo:
+            payload_type |= 0b01000000
+        if self.confalgo:
+            payload_type |= 0b10000000
+        if self.ipmiversion == 2.0:
+            message.append(payload_type)
+            if baretype == 2:
+                # TODO(jbjohnso): OEM payload types
+                raise NotImplementedError("OEM Payloads")
+            elif baretype not in constants.payload_types.values():
+                raise NotImplementedError(
+                    "Unrecognized payload type %d" % baretype)
+            message += struct.pack("<I", self.sessionid)
+        message += struct.pack("<I", self.sequencenumber)
+        if self.ipmiversion == 1.5:
+            message += struct.pack("<I", self.sessionid)
+            if not self.authtype == 0:
+                message += self._ipmi15authcode(payload)
+            message.append(len(payload))
+            message += payload
+            # Guessing the ipmi spec means the whole
+            totlen = 34 + len(message)
+            # packet and assume no tag in old 1.5 world
+            if totlen in (56, 84, 112, 128, 156):
+                message.append(0)  # Legacy pad as mandated by ipmi spec
+        elif self.ipmiversion == 2.0:
+            psize = len(payload)
+            if self.confalgo:
+                pad = (psize + 1) % 16  # pad has to cope with one byte
+                # field like the _aespad function
+                if pad:  # if no pad needed, then we take no more action
+                    pad = 16 - pad
+                # new payload size grew according to pad
+                newpsize = psize + pad + 17
+                # size, plus pad length, plus 16 byte IV
+                # (Table 13-20)
+                message.append(newpsize & 0xff)
+                message.append(newpsize >> 8)
+                iv = os.urandom(16)
+                message += iv
+                payloadtocrypt = bytes(payload + _aespad(payload))
+                crypter = Cipher(
+                    algorithm=algorithms.AES(self.aeskey),
+                    mode=modes.CBC(iv),
+                    backend=self._crypto_backend
+                )
+                encryptor = crypter.encryptor()
+                message += encryptor.update(payloadtocrypt
+                                            ) + encryptor.finalize()
+            else:  # no confidetiality algorithm
+                message.append(psize & 0xff)
+                message.append(psize >> 8)
+                message += payload
+            if self.integrityalgo:  # see table 13-8,
+                # RMCP+ packet format
+                # TODO(jbjohnso): SHA256 which is now
+                # allowed
+                neededpad = (len(message) - 2) % 4
+                if neededpad:
+                    neededpad = 4 - neededpad
+                message += b'\xff' * neededpad
+                message.append(neededpad)
+                message.append(7)  # reserved, 7 is the required value for the
+                # specification followed
+                message += hmac.new(
+                    self.k1, bytes(message[4:]),
+                    self.currhashlib).digest()[:self.currhashlen]
+                # per RFC2404 truncates to 96 bits
+        self.netpacket = message
+        # advance idle timer since we don't need keepalive while sending
+        # packets out naturally
+        await KEEPALIVE_SESSIONS.acquire()
+        try:
+            if (self in Session.keepalive_sessions and not needskeepalive
+                    and not self._customkeepalives):
+                Session.keepalive_sessions[self]['timeout'] = \
+                    _monotonic_time() + MAX_IDLE - (random.random() * 4.9)
+            await self._xmit_packet(retry, timeout=timeout)
+        finally:
+            KEEPALIVE_SESSIONS.release()
+
+    def _ipmi15authcode(self, payload, checkremotecode=False):
+        # checkremotecode is used to verify remote code,
+        # otherwise this function is used to general authcode for local
+        if self.authtype == 0:
+            # Only for things before auth in ipmi 1.5, not
+            # like 2.0 cipher suite 0
+            return ()
+        password = self.password
+        padneeded = 16 - len(password)
+        if padneeded < 0:
+            raise exc.IpmiException("Password is too long for ipmi 1.5")
+        password += '\x00' * padneeded
+        if checkremotecode:
+            seqbytes = struct.pack("<I", self.remseqnumber)
+        else:
+            seqbytes = struct.pack("<I", self.sequencenumber)
+        sessdata = struct.pack("<I", self.sessionid)
+        bodydata = password + sessdata + payload + seqbytes + password
+        dgst = hashlib.md5(bodydata).digest()
+        return dgst
+
+    async def _got_channel_auth_cap(self, response):
+        if 'error' in response:
+            await self.onlogon(response)
+            return
+        if response['code'] == 0xcc and self.ipmi15only is not None:
+            # tried ipmi 2.0 against a 1.5 which should work, but some bmcs
+            # thought 'reserved' meant 'must be zero'
+            self.ipmi15only = 1
+            return self._get_channel_auth_cap()
+        mysuffix = " while trying to get channel authentication capabalities"
+        errstr = get_ipmi_error(response, suffix=mysuffix)
+        if errstr:
+            self.onlogon({'error': errstr})
+            return
+        data = response['data']
+        self.currentchannel = data[0]
+        if data[1] & 0b10000000 and data[3] & 0b10:  # ipmi 2.0 support
+            self.ipmiversion = 2.0
+        if self.ipmiversion == 1.5:
+            if not (data[1] & 0b100):
+                self.onlogon(
+                    {'error':
+                     "MD5 required but not enabled/available on target BMC"})
+                return
+            await self._get_session_challenge()
+        elif self.ipmiversion == 2.0:
+            await self._open_rmcpplus_request()
+
+    def _got_session_challenge(self, response):
+        errstr = get_ipmi_error(response,
+                                suffix=" while getting session challenge")
+        if errstr:
+            self.onlogon({'error': errstr})
+            return
+        data = response['data']
+        self.sessionid = struct.unpack("<I", bytes(data[0:4]))[0]
+        self.authtype = 2
+        self._activate_session(data[4:])
+
+    # NOTE(jbjohnso):
+    # This sends the activate session payload.  We pick '1' as the requested
+    # sequence number without perturbing our real sequence number
+
+    async def _activate_session(self, data):
+        rqdata = [2, 4] + list(data) + [1, 0, 0, 0]
+        # TODO(jbjohnso): this always requests admin level (1.5)
+        self.ipmicallback = self._activated_session
+        await self._send_ipmi_net_payload(netfn=0x6, command=0x3a, data=rqdata)
+
+    async def _activated_session(self, response):
+        errstr = get_ipmi_error(response)
+        if errstr:
+            self.onlogon({'error': errstr})
+            return
+        data = response['data']
+        self.sessionid = struct.unpack("<I", bytes(data[1:5]))[0]
+        self.sequencenumber = struct.unpack("<I", bytes(data[5:9]))[0]
+        await self._req_priv_level()
+
+    async def _req_priv_level(self):
+        self.logged = 1
+        self.maxtimeout = 4  # Switch quickly to the relogin recovery
+        self.logontries = 1  # have one relogin waiting to heal
+        response = await self.raw_command(netfn=0x6, command=0x3b,
+                                    data=[self.privlevel])
+        if response['code']:
+            if response['code'] in (0x80, 0x81) and self.privlevel == 4:
+                # some implementations will let us get this far,
+                # but suddenly get skiddish.  Try again in such a case
+                self.privlevel = 3
+                response = self.raw_command(netfn=0x6, command=0x3b,
+                                            data=[self.privlevel])
+            if response['code']:
+                self.logged = 0
+                self.onlogpayload = None
+                self.logging = False
+                self.logoutexpiry = None
+
+                mysuffix = " while requesting privelege level %d for %s" % (
+                    self.privlevel, self.userid)
+                errstr = get_ipmi_error(response, suffix=mysuffix)
+                if errstr:
+                    self.onlogon({'error': errstr})
+                    return
+        self.logging = False
+        self.logoutexpiry = None
+        await KEEPALIVE_SESSIONS.acquire()
+        try:
+            Session.keepalive_sessions[self] = {}
+            Session.keepalive_sessions[self]['ipmisession'] = self
+            Session.keepalive_sessions[self]['timeout'] = _monotonic_time() + \
+                MAX_IDLE - (random.random() * 4.9)
+        finally:
+            KEEPALIVE_SESSIONS.release()
+        await self.onlogon({'success': True})
+
+    async def _get_session_challenge(self):
+        reqdata = bytearray([2])
+        if len(self.userid) > 16:
+            raise exc.IpmiException(
+                "Username too long for IPMI, must not exceed 16")
+        padneeded = 16 - len(self.userid)
+        userid = self.userid + ('\x00' * padneeded)
+        reqdata += userid
+        self.ipmicallback = self._got_session_challenge
+        await self._send_ipmi_net_payload(netfn=0x6, command=0x39, data=reqdata)
+
+    async def _open_rmcpplus_request(self):
+        self.authtype = 6
+        # have unique local session ids to ignore aborted
+        # login attempts from the past
+        self.localsid += 1
+        self.rmcptag += 1
+        data = bytearray([
+            self.rmcptag,
+            0,  # request as much privilege as the channel will give us
+            0, 0,  # reserved
+        ])
+        data += struct.pack("<I", self.localsid)
+        # auth 3 sha256
+        # integrity... 4 = sha256
+        if self.attemptedhash == 1:
+            data += bytearray([
+                0, 0, 0, 8, 1, 0, 0, 0,  # table 13-17, SHA-1
+                1, 0, 0, 8, 1, 0, 0, 0,  # SHA-1 integrity
+                2, 0, 0, 8, 1, 0, 0, 0,  # AES privacy
+                # 2,0,0,8,0,0,0,0, #no privacy confalgo
+            ])
+            self.currhashlib = hashlib.sha1
+            self.currhashlen = 12
+        else:
+            data += bytearray([
+                0, 0, 0, 8, 3, 0, 0, 0,  # table 13-17, SHA-256
+                1, 0, 0, 8, 4, 0, 0, 0,  # SHA-256-128 integrity
+                2, 0, 0, 8, 1, 0, 0, 0,  # AES privacy
+                # 2,0,0,8,0,0,0,0, #no privacy confalgo
+            ])
+            self.currhashlib = hashlib.sha256
+            self.currhashlen = 16
+        self.sessioncontext = 'OPENSESSION'
+        self.lastpayload = None
+        await self.send_payload(
+            payload=data,
+            payload_type=constants.payload_types['rmcpplusopenreq'])
+
+    async def _get_channel_auth_cap(self):
+        self.ipmicallback = self._got_channel_auth_cap
+        if self.ipmi15only:
+            await self._send_ipmi_net_payload(netfn=0x6,
+                                        command=0x38,
+                                        data=[0x0e, self.privlevel])
+        else:
+            await self._send_ipmi_net_payload(netfn=0x6,
+                                        command=0x38,
+                                        data=[0x8e, self.privlevel])
+
+    async def login(self):
+        self.logontries = 1
+        self._initsession()
+        await self._get_channel_auth_cap()
+
+    @classmethod
+    async def pause(cls, timeout):
+        try:
+            starttime = _monotonic_time()
+            while _monotonic_time() - starttime < timeout:
+                await cls.wait_for_rsp(timeout - (_monotonic_time() - starttime))
+        except Exception as e:
+            print(repr(e))
+
+    @classmethod
+    async def wait_for_rsp(cls, timeout=None, callout=True):
+        """IPMI Session Event loop iteration
+
+        This watches for any activity on IPMI handles and handles registered
+        by register_handle_callback.  Callers are satisfied in the order that
+        packets return from network, not in the order of calling.
+
+        :param timeout: Maximum time to wait for data to come across.  If
+                        unspecified, will autodetect based on earliest timeout
+        """
+        global iosockets
+        # Assume:
+        # Instance A sends request to packet B
+        # Then Instance C sends request to BMC D
+        # BMC D was faster, so data comes back before BMC B
+        # Instance C gets to go ahead of Instance A, because
+        # Instance C can get work done, but instance A cannot
+
+        curtime = _monotonic_time()
+        # There ar a number of parties that each has their own timeout
+        # The caller can specify a deadline in timeout argument
+        # each session with active outbound payload has callback to
+        # handle retry/timout error
+        # each session that is 'alive' wants to send a keepalive ever so often.
+        # We want to make sure the most strict request is honored and block for
+        # no more time than that, so that whatever part(ies) need to service in
+        # a deadline, will be honored
+        if timeout != 0:
+            await WAITING_SESSIONS.acquire()
+            try:
+                for session, parms in dictitems(cls.waiting_sessions):
+                    if parms['timeout'] <= curtime:
+                        timeout = 0  # exit after one guaranteed pass
+                        break
+                    if (timeout is not None
+                            and timeout < parms['timeout'] - curtime):
+                        continue  # timeout smaller than the current session
+                        # needs
+                    timeout = parms['timeout'] - curtime  # set new timeout
+                    # value
+            finally:
+                WAITING_SESSIONS.release()
+            await KEEPALIVE_SESSIONS.acquire()
+            try:
+                for session, parms in dictitems(cls.keepalive_sessions):
+                    if parms['timeout'] <= curtime:
+                        timeout = 0
+                        break
+                    if (timeout is not None
+                            and timeout < parms['timeout'] - curtime):
+                        continue
+                    timeout = parms['timeout'] - curtime
+            finally:
+                KEEPALIVE_SESSIONS.release()
+        # If the loop above found no sessions wanting *and* the caller had no
+        # timeout, exit function. In this case there is no way a session
+        # could be waiting so we can always return 0
+        while cls.iterwaiters:
+            waiter = cls.iterwaiters.pop()
+            waiter({'success': True})
+            # cause a quick exit from the event loop iteration for calling code
+            # to be able to reasonably set up for the next iteration before
+            # a long select comes along
+            if timeout is not None:
+                timeout = 0
+        if timeout is None:
+            return 0
+        if await _poller(timeout=timeout):
+            while sessionqueue:
+                relsession = sessionqueue.popleft()
+                await relsession.process_pktqueue()
+        sessionstodel = []
+        sessionstokeepalive = []
+        await KEEPALIVE_SESSIONS.acquire()
+        try:
+            for session, parms in dictitems(cls.keepalive_sessions):
+                # if the session is busy inside a command, defer invoking
+                # keepalive until incommand is no longer the case
+                if parms['timeout'] < curtime and not session._isincommand():
+                    cls.keepalive_sessions[session]['timeout'] = \
+                        _monotonic_time() + MAX_IDLE - (random.random() * 4.9)
+                    sessionstokeepalive.append(session)
+        finally:
+            KEEPALIVE_SESSIONS.release()
+        for session in sessionstokeepalive:
+            await session._keepalive()
+        await WAITING_SESSIONS.acquire()
+        try:
+            for session, parms in dictitems(cls.waiting_sessions):
+                if parms['timeout'] < curtime:  # timeout has expired, time to
+                    # give up on it and trigger timeout
+                    # response in the respective session
+                    # defer deletion until after loop
+                    sessionstodel.append(session)
+                    # to avoid confusing the for loop
+            for session in sessionstodel:
+                cls.waiting_sessions.pop(session, None)
+            # one loop iteration to make sure recursion doesn't induce
+            # redundant timeouts
+        finally:
+            WAITING_SESSIONS.release()
+        for session in sessionstodel:
+            await session._timedout()
+        return len(cls.waiting_sessions)
+
+
+    def register_keepalive(self, cmd, callback):
+        """Register  custom keepalive IPMI command
+
+        This is mostly intended for use by the console code.
+        calling code would have an easier time just scheduling in their
+        own threading scheme.  Such a behavior would naturally cause
+        the default keepalive to not occur anyway if the calling code
+        is at least as aggressive about timing as aiohmi
+        :param cmd: A dict of arguments to be passed into raw_command
+        :param callback: A function to be called with results of the keepalive
+
+        :returns: value to identify registration for unregister_keepalive
+        """
+        regid = random.random()
+        if self._customkeepalives is None:
+            self._customkeepalives = {regid: (cmd, callback)}
+        else:
+            while regid in self._customkeepalives:
+                regid = random.random()
+            self._customkeepalives[regid] = (cmd, callback)
+        return regid
+
+    def unregister_keepalive(self, regid):
+        if self._customkeepalives is None:
+            return
+        try:
+            del self._customkeepalives[regid]
+        except KeyError:
+            pass
+
+    def _keepalive_wrapper(self, callback):
+        # generates a wrapped keepalive to cleanup session state
+        # and call callback if appropriate
+        async def _keptalive(response):
+            await self._generic_callback(response)
+            response = self.lastresponse
+            self.lastresponse = None
+            self.incommand = False
+            while self.evq:
+                self.evq.popleft().set()
+            if callback:
+                await callback(response)
+
+        return _keptalive
+
+    async def _keepalive(self):
+        """Performs a keepalive to avoid idle disconnect"""
+        if self.awaitingresponse:
+            return
+        try:
+            keptalive = False
+            if self._customkeepalives:
+                kaids = list(self._customkeepalives.keys())
+                for keepalive in kaids:
+                    try:
+                        cmd, callback = self._customkeepalives[keepalive]
+                    except TypeError:
+                        # raw_command made customkeepalives None
+                        break
+                    except KeyError:
+                        # raw command ultimately caused a keepalive to
+                        # deregister
+                        continue
+                    if callable(cmd):
+                        await cmd()
+                        continue
+                    keptalive = True
+                    cmd['callback'] = self._keepalive_wrapper(callback)
+                    await self.raw_command(**cmd)
+            if not keptalive:
+                if self.incommand:
+                    # if currently in command, no cause to keepalive
+                    return
+                if self.autokeepalive:
+                    await self.raw_command(netfn=6, command=1,
+                                           callback=self._keepalive_wrapper(None))
+                else:
+                    await self.logout()
+        except exc.IpmiException:
+            await self._mark_broken()
+
+    async def process_pktqueue(self):
+        while self.pktqueue:
+            pkt = list(self.pktqueue.popleft())
+            pkt[0] = bytearray(pkt[0])
+            if not (pkt[0][0] == 6 and pkt[0][2:4] == b'\xff\x07'):
+                continue
+            # this should be in specific context, no need to check port
+            # since recvfrom result was already routed to this object
+            # specifically
+            if pkt[1] in self.bmc_handlers:
+                await self._handle_ipmi_packet(pkt[0], sockaddr=pkt[1], qent=pkt)
+            elif pkt[2] in self.bmc_handlers:
+                self.sessionless_data(pkt[0], pkt[1])
+
+    async def _handle_ipmi_packet(self, data, sockaddr=None, qent=None):
+        if self.sockaddr is None and sockaddr is not None:
+            self.sockaddr = sockaddr
+        elif (self.sockaddr is not None
+              and sockaddr is not None
+              and self.sockaddr != sockaddr):
+            return  # here, we might have sent an ipv4 and ipv6 packet to kick
+            # things off ignore the second reply since we have one
+            # satisfactory answer
+        if data[4] in (0, 2):  # This is an ipmi 1.5 paylod
+            remseqnumber = struct.unpack('<I', bytes(data[5:9]))[0]
+            remsessid = struct.unpack("<I", bytes(data[9:13]))[0]
+            if (remseqnumber == 0 and remsessid == 0
+                    and qent[2] in Session.bmc_handlers):
+                # So a new ipmi client happens to get a previously seen and
+                # still active UDP source port.  Clear ourselves out and punt
+                # to IpmiServer
+                del Session.bmc_handlers[sockaddr]
+                iserver = Session.bmc_handlers[qent[2]][0]
+                iserver.pktqueue.append(qent)
+                await iserver.process_pktqueue()
+                return
+            if (hasattr(self, 'remseqnumber') and self.remseqnumber is not None
+                    and remseqnumber < self.remseqnumber):
+                return -5  # remote sequence number is too low, reject it
+            self.remseqnumber = remseqnumber
+            if data[4] != self.authtype:
+                # BMC responded with mismatch authtype, for
+                # mutual authentication reject it. If this causes
+                # legitimate issues, it's the vendor's fault
+                return -2
+
+            if remsessid != self.sessionid:
+                return -1  # does not match our session id, drop it
+            authcode = False
+            if data[4] == 2:  # we have authcode in this ipmi 1.5 packet
+                authcode = data[13:29]
+                del data[13:29]
+                # this is why we needed a mutable representation
+            payload = data[14:14 + data[13]]
+            if authcode:
+                expectedauthcode = self._ipmi15authcode(payload,
+                                                        checkremotecode=True)
+                if expectedauthcode != authcode:
+                    return
+            await self._parse_ipmi_payload(payload)
+        elif data[4] == 6:
+            await self._handle_ipmi2_packet(data)
+        else:
+            return  # unrecognized data, assume evil
+
+    async def _got_rakp1(self, data):
+        # stub, client sessions ignore rakp2
+        pass
+
+    async def _got_rakp3(self, data):
+        # stub, client sessions ignore rakp3
+        pass
+
+    async def _got_rmcp_openrequest(self, data):
+        pass
+
+    async def _handle_ipmi2_packet(self, data):
+        ptype = data[5] & 0b00111111
+        # the first 16 bytes are header information as can be seen in 13-8 that
+        # we will toss out
+        if ptype == 0x10:
+            return await self._got_rmcp_openrequest(data[16:])
+        elif ptype == 0x11:  # rmcp+ response
+            return await self._got_rmcp_response(data[16:])
+        elif ptype == 0x12:
+            return await self._got_rakp1(data[16:])
+        elif ptype == 0x13:
+            return await self._got_rakp2(data[16:])
+        elif ptype == 0x14:
+            return await self._got_rakp3(data[16:])
+        elif ptype == 0x15:
+            return await self._got_rakp4(data[16:])
+        elif ptype == 0 or ptype == 1:  # good old ipmi payload or sol
+            # If endorsing a shared secret scheme, then at the very least it
+            # needs to do mutual assurance
+            if not (data[5] & 0b01000000):  # This would be the line that might
+                # trip up some insecure BMC
+                # implementation
+                return
+            encrypted = 0
+            if data[5] & 0b10000000:
+                encrypted = 1
+            authcode = data[-self.currhashlen:]
+            if self.k1 is None:  # we are in no shape to process a packet now
+                return
+            expectedauthcode = hmac.new(
+                self.k1, data[4:-self.currhashlen],
+                self.currhashlib).digest()[:self.currhashlen]
+            if authcode != expectedauthcode:
+                return  # BMC failed to assure integrity to us, drop it
+            sid = struct.unpack("<I", bytes(data[6:10]))[0]
+            if sid != self.localsid:  # session id mismatch, drop it
+                return
+            remseqnumber = struct.unpack("<I", bytes(data[10:14]))[0]
+            if (hasattr(self, 'remseqnumber') and self.remseqnumber is not None
+                    and (remseqnumber < self.remseqnumber)
+                    and (self.remseqnumber != 0xffffffff)):
+                return
+            self.remseqnumber = remseqnumber
+            psize = data[14] + (data[15] << 8)
+            payload = data[16:16 + psize]
+            if encrypted:
+                iv = data[16:32]
+                crypter = Cipher(
+                    algorithm=algorithms.AES(self.aeskey),
+                    mode=modes.CBC(bytes(iv)),
+                    backend=self._crypto_backend
+                )
+                decryptor = crypter.decryptor()
+                payload = bytearray(decryptor.update(bytes(payload[16:])
+                                                     ) + decryptor.finalize())
+                padsize = payload[-1] + 1
+                payload = payload[:-padsize]
+            if ptype == 0:
+                await self._parse_ipmi_payload(payload)
+            elif ptype == 1:  # There should be no other option
+                if (payload[1] & 0b1111) and self.last_payload_type == 1:
+                    # for ptype 1, the 4 least significant bits of 2nd byte
+                    # is  the ACK number.
+                    # if it isn't an ACK at all, we'll keep retrying, however
+                    # if it's a subtle SOL situation (partial ACK, wrong ACK)
+                    # then sol_handler will have to resubmit and we will
+                    # stop the generic retry behavior here
+                    self.lastpayload = None
+                    self.last_payload_type = None
+                    await WAITING_SESSIONS.acquire()
+                    try:
+                        Session.waiting_sessions.pop(self, None)
+                    finally:
+                        WAITING_SESSIONS.release()
+                    if len(self.pendingpayloads) > 0:
+                        (nextpayload, nextpayloadtype, retry) = \
+                            self.pendingpayloads.popleft()
+                        await self.send_payload(payload=nextpayload,
+                                          payload_type=nextpayloadtype,
+                                          retry=retry)
+                if self.sol_handler:
+                    await self.sol_handler(payload)
+
+    async def _got_rmcp_response(self, data):
+        # see RMCP+ open session response table
+        if not (self.sessioncontext and self.sessioncontext != "ESTABLISHED"):
+            return -9
+            # ignore payload as we are not in a state valid it
+        if data[0] != self.rmcptag:
+            return -9  # use rmcp tag to track and reject stale responses
+        if data[1] != 0:  # response code...
+            if self.attemptedhash == 256:
+                self.attemptedhash = 1
+                await self._open_rmcpplus_request()
+                return
+            if data[1] in constants.rmcp_codes:
+                errstr = constants.rmcp_codes[data[1]]
+            else:
+                errstr = "Unrecognized RMCP code %d" % data[1]
+            self.onlogon({'error': errstr})
+            return -9
+        self.allowedpriv = data[2]
+        # NOTE(jbjohnso): At this point, the BMC has no idea about what user
+        # shall be used.  As such, the allowedpriv field is actually
+        # not particularly useful.  got_rakp2 is a good place to
+        # gracefully detect and downgrade privilege for retry
+        localsid = struct.unpack("<I", bytes(data[4:8]))[0]
+        if self.localsid != localsid:
+            return -9
+        self.pendingsessionid = struct.unpack("<I", bytes(data[8:12]))[0]
+        # TODO(jbjohnso): currently, we take it for granted that the responder
+        # accepted our integrity/auth/confidentiality proposal
+        self.lastpayload = None
+        await self._send_rakp1()
+
+    async def _send_rakp1(self):
+        self.rmcptag += 1
+        self.randombytes = os.urandom(16)
+        userlen = len(self.userid)
+        payload = bytearray([self.rmcptag, 0, 0, 0]) + \
+            struct.pack("<I", self.pendingsessionid) + \
+            self.randombytes +\
+            bytearray([self.nameonly | self.privlevel, 0, 0, userlen]) + \
+            self.userid
+        self.sessioncontext = "EXPECTINGRAKP2"
+        await self.send_payload(
+            payload=payload, payload_type=constants.payload_types['rakp1'])
+
+    async def _got_rakp2(self, data):
+        if not (self.sessioncontext in ('EXPECTINGRAKP2', 'EXPECTINGRAKP4')):
+            # if we are not expecting rakp2, ignore. In a retry
+            # scenario, replying from stale RAKP2 after sending
+            # RAKP3 seems to be best
+            return -9
+        if data[0] != self.rmcptag:  # ignore mismatched tags for retry logic
+            return -9
+        if data[1] != 0:  # if not successful, consider next move
+            if data[1] in (9, 0xd) and self.privlevel == 4 and self.autopriv:
+                # Here the situation is likely that the peer didn't want
+                # us to use admin.  Degrade to operator and try again
+                self.privlevel = 3
+                await self.login()
+                return
+            # invalid sessionid 99% of the time means a retry
+            # scenario invalidated an in-flight transaction
+            if data[1] == 2:
+                return
+            if data[1] in constants.rmcp_codes:
+                errstr = constants.rmcp_codes[data[1]]
+            else:
+                errstr = "Unrecognized RMCP code %d" % data[1]
+            await self.onlogon({'error': errstr + " in RAKP2"})
+            return -9
+        localsid = struct.unpack("<I", bytes(data[4:8]))[0]
+        if localsid != self.localsid:
+            return -9  # discard mismatch in the session identifier
+        self.remoterandombytes = bytes(data[8:24])
+        self.remoteguid = bytes(data[24:40])
+        userlen = len(self.userid)
+        hmacdata = (struct.pack("<II", localsid, self.pendingsessionid)
+                    + self.randombytes + self.remoterandombytes
+                    + self.remoteguid + struct.pack(
+                    "2B", self.nameonly | self.privlevel, userlen)
+                    + self.userid)
+        try:
+            expectedhash = hmac.new(self.password, hmacdata,
+                                    self.currhashlib).digest()
+        except TypeError:
+            print('Password for {0} is somehow malformed'.format(self.bmc))
+            return -9
+        hashlen = len(expectedhash)
+        givenhash = struct.pack("%dB" % hashlen, *data[40:hashlen + 40])
+        if givenhash != expectedhash:
+            self.sessioncontext = "FAILED"
+            self.onlogon({'error': "Incorrect password provided"})
+            return -9
+        # We have now validated that the BMC and client agree on password, time
+        # to store the keys
+        self.sik = hmac.new(self.kg,
+                            self.randombytes + self.remoterandombytes
+                            + struct.pack(
+                                "2B", self.nameonly | self.privlevel, userlen)
+                            + self.userid, self.currhashlib).digest()
+        self.k1 = hmac.new(self.sik, b'\x01' * 20, self.currhashlib).digest()
+        self.k2 = hmac.new(self.sik, b'\x02' * 20, self.currhashlib).digest()
+        self.aeskey = self.k2[0:16]
+        self.sessioncontext = "EXPECTINGRAKP4"
+        self.lastpayload = None
+        await self._send_rakp3()
+
+    async def _send_rakp3(self):  # rakp message 3
+        self.rmcptag += 1
+        # rmcptag, then status 0, then two reserved 0s
+        payload = [self.rmcptag, 0, 0, 0] +\
+            list(struct.unpack("4B", struct.pack("<I", self.pendingsessionid)))
+        hmacdata = self.remoterandombytes +\
+            struct.pack("<I", self.localsid) +\
+            struct.pack("2B", self.nameonly | self.privlevel,
+                        len(self.userid)) +\
+            self.userid
+
+        authcode = hmac.new(self.password, hmacdata, self.currhashlib).digest()
+        payload += list(struct.unpack("%dB" % len(authcode), authcode))
+        await self.send_payload(
+            payload=payload, payload_type=constants.payload_types['rakp3'])
+
+    async def _relog(self):
+        self.logging = True
+        self._initsession()
+        self.logontries -= 1
+        return await self._get_channel_auth_cap()
+
+    async def _got_rakp4(self, data):
+        if self.sessioncontext != "EXPECTINGRAKP4" or data[0] != self.rmcptag:
+            return -9
+        if data[1] != 0:
+            if data[1] == 2 and self.logontries:  # if we retried RAKP3 because
+                # RAKP4 got dropped, BMC can consider it done and we must
+                # restart
+                self._relog()
+                return
+            # ignore 15 value if we are retrying.
+            # xCAT did but I can't recall why exactly
+            if data[1] == 15 and self.logontries:
+                # TODO(jbjohnso) jog my memory to update the comment
+                return
+            if data[1] in constants.rmcp_codes:
+                errstr = constants.rmcp_codes[data[1]]
+            else:
+                errstr = "Unrecognized RMCP code %d" % data[1]
+            await self.onlogon({'error': errstr + " reported in RAKP4"})
+            return -9
+        localsid = struct.unpack("<I", bytes(data[4:8]))[0]
+        if localsid != self.localsid:  # ignore if wrong session id indicated
+            return -9
+        hmacdata = self.randombytes +\
+            struct.pack("<I", self.pendingsessionid) +\
+            self.remoteguid
+        expectedauthcode = hmac.new(
+            self.sik, hmacdata, self.currhashlib).digest()[:self.currhashlen]
+        aclen = len(expectedauthcode)
+        authcode = struct.pack("%dB" % aclen, *data[8:aclen + 8])
+        if authcode != expectedauthcode:
+            self.onlogon({'error': "Invalid RAKP4 integrity code (wrong Kg?)"})
+            return
+        self.sessionid = self.pendingsessionid
+        self.integrityalgo = self.attemptedhash
+        self.confalgo = 'aes'
+        self.sequencenumber = 1
+        self.sessioncontext = 'ESTABLISHED'
+        self.lastpayload = None
+        await self._req_priv_level()
+
+    # Internal function to parse IPMI nugget once extracted from its framing
+    async def _parse_ipmi_payload(self, payload):
+        # For now, skip the checksums since we are in LAN only,
+        # TODO(jbjohnso): if implementing other channels, add checksum checks
+        # here
+        if len(payload) < 7:
+            # This cannot possibly be a valid IPMI packet.  Note this is after
+            # the integrity checks, so this must be a buggy BMC packet
+            # One example was a BMC that if receiving an SOL deactivate
+            # from another party would emit what looks to be an attempt
+            # at SOL deactivation payload, but with the wrong payload type
+            # since we can't do anything remotely sane with such a packet,
+            # drop it and carry about our business.
+            return
+        if self.servermode:
+            self.seqlun = payload[4] >> 2
+            self.clientaddr = payload[3]
+            self.clientnetfn = (payload[1] >> 2) + 1
+            self.rqlun = payload[4] & 0b11
+            self.clientcommand = payload[5]
+            await self._parse_payload(payload)
+            return
+        # payload[4] is rqSeq + rsLUN, we only need the rqSeq
+        entry = (payload[1] >> 2, payload[4] >> 2, payload[5])
+        if self._lookup_request_entry(entry):
+            self._remove_request_entry(entry)
+
+            # NOTE(fengqian): for bridge request, we need to handle the
+            # response twice. First response shows if message send correctly,
+            # second response is the real response.
+            # If the message is send crrectly, we will discard the first
+            # response or else error message will be parsed and return.
+            if ((entry[0] in [0x06, 0x07]) and (entry[2] == 0x34)
+                    and (payload[-2] == 0x0)):
+                return -1
+            else:
+                await self._parse_payload(payload)
+                # NOTE(fengqian): recheck if the certain entry is removed in
+                # case that bridge request failed.
+                if self.request_entry:
+                    self._remove_request_entry((self.expectednetfn,
+                                                self.seqlun, self.expectedcmd))
+        else:
+            # payload is not a match for our last packet
+            # it is also not a bridge request.
+            return -1
+
+    async def _parse_payload(self, payload):
+        if hasattr(self, 'hasretried') and self.hasretried:
+            self.hasretried = 0
+            # try to skip it for at most 16 cycles of overflow
+            self.tabooseq[
+                (self.expectednetfn, self.expectedcmd, self.seqlun)] = 16
+        # We want to now remember that we do not have an expected packet
+        # bigger than one byte means it can never match the one byte value
+        # by mistake
+        self.expectednetfn = 0x1ff
+        self.expectedcmd = 0x1ff
+        if not self.servermode:
+            self.seqlun += 1  # prepare seqlun for next transmit
+            self.seqlun &= 0x3f  # when overflowing, wrap around
+        await WAITING_SESSIONS.acquire()
+        try:
+            Session.waiting_sessions.pop(self, None)
+        finally:
+            WAITING_SESSIONS.release()
+        # render retry mechanism utterly incapable of
+        # doing anything, though it shouldn't matter
+        self.lastpayload = None
+        self.last_payload_type = None
+        response = {'netfn': payload[1] >> 2}
+        # ^^ remove header of rsaddr/netfn/lun/checksum/rq/seq/lun
+        del payload[0:5]
+        # remove the trailing checksum
+        del payload[-1]
+        response['command'] = payload[0]
+        if self.servermode:
+            del payload[0:1]
+            response['data'] = payload
+        else:
+            response['code'] = payload[1]
+            del payload[0:2]
+            response['data'] = payload
+        self.timeout = initialtimeout + (0.5 * random.random())
+        if not self.servermode and len(self.pendingpayloads) > 0:
+            (nextpayload, nextpayloadtype, retry) = \
+                self.pendingpayloads.popleft()
+            await self.send_payload(payload=nextpayload,
+                              payload_type=nextpayloadtype,
+                              retry=retry)
+        if self.ipmicallback:
+            rsp = self.ipmicallback(response)
+            if rsp:
+                await rsp
+
+
+    async def _timedout(self):
+        if not self.lastpayload:
+            return
+        self.nowait = True
+        self.timeout += 1
+        if self.timeout > self.maxtimeout:
+            if not self.logontries:
+                response = {'error': 'timeout', 'code': 0xffff}
+                if self.ipmicallback:
+                    await self.ipmicallback(response)
+                self.nowait = False
+                await self._mark_broken()
+                return
+            else:
+                self.maxtimeout = 2
+                if self.sessioncontext == 'ESTABLISHED':
+                    self.onlogpayload = self.lastpayload
+                    self.onlogpayloadtype = self.last_payload_type
+                    self.maxtimeout = 6
+                await self._relog()
+                return
+        elif self.sessioncontext == 'FAILED':
+            self.lastpayload = None
+            self.onlogpayload = None
+            self.nowait = False
+            return
+        if self.sessioncontext == 'OPENSESSION':
+            # In this case, we want to craft a new session request to have
+            # unambiguous session id regardless of how packet was dropped or
+            # delayed in this case, it's safe to just redo the request
+            self.lastpayload = None
+            await self._open_rmcpplus_request()
+        elif (self.sessioncontext == 'EXPECTINGRAKP2'
+              or self.sessioncontext == 'EXPECTINGRAKP4'):
+            # If we can't be sure which RAKP was dropped or if RAKP3/4 was just
+            # delayed, the most reliable thing to do is rewind and start over
+            # bmcs do not take kindly to receiving RAKP1 or RAKP3 twice
+            await self._relog()
+        else:  # in IPMI case, the only recourse is to act as if the packet is
+            # idempotent.  SOL has more sophisticated retry handling
+            # the biggest risks are reset sp which is often fruitless to retry
+            # and chassis reset, which sometimes will shoot itself
+            # systematically in the head in a shared port case making replies
+            # impossible
+            self.hasretried = 1  # remember so that we can track taboo
+            # combinations
+            # of sequence number, netfn, and lun due to
+            # ambiguity on the wire
+            await self.send_payload()
+        self.nowait = False
+
+    async def _xmit_packet(self, retry=True, timeout=None):
+        if self.sequencenumber:  # seq number of zero will be left alone, it is
+            # special, otherwise increment
+            self.sequencenumber += 1
+        if self.sockaddr:
+            _io_sendto(self.socket, self.netpacket, self.sockaddr)
+        else:
+            # he have not yet picked a working sockaddr for this connection,
+            # try all the candidates that getaddrinfo provides
+            self.allsockaddrs = []
+            myport = self.socket.getsockname()[1]
+            try:
+                for res in socket.getaddrinfo(self.bmc,
+                                              self.port,
+                                              0,
+                                              socket.SOCK_DGRAM):
+                    sockaddr = res[4]
+                    if ipv6support and res[0] == socket.AF_INET:
+                        # convert the sockaddr to AF_INET6
+                        newhost = '::ffff:' + sockaddr[0]
+                        sockaddr = (newhost, sockaddr[1], 0, 0)
+                    self.allsockaddrs.append(sockaddr)
+                    if sockaddr not in Session.bmc_handlers:
+                        Session.bmc_handlers[sockaddr] = {}
+                    Session.bmc_handlers[sockaddr][myport] = self
+                    _io_sendto(self.socket, self.netpacket, sockaddr)
+                try:
+                    del Session.initting_sessions[(self.bmc, self.userid,
+                                                   self.password, self.port,
+                                                   self.kgo)]
+                except KeyError:
+                    pass
+            except socket.gaierror:
+                raise exc.IpmiException(
+                    "Unable to transmit to specified address")
+        if retry:
+            await WAITING_SESSIONS.acquire()
+            try:
+                Session.waiting_sessions[self] = {}
+                Session.waiting_sessions[self]['ipmisession'] = self
+                if timeout is not None:
+                    self.expiration = timeout + _monotonic_time()
+                else:
+                    self.expiration = self.timeout + _monotonic_time()
+                Session.waiting_sessions[self]['timeout'] = self.expiration
+            finally:
+                WAITING_SESSIONS.release()
+
+    async def logout(self, sessionok=True):
+
+        if self.cleaningup:
+            self.nowait = True
+        if self.logged:
+            if self.sol_handler:
+                await self.raw_command(
+                    netfn=6, command=0x49, data=(1, 1, 0, 0, 0, 0),
+                    retry=sessionok)
+            await self.raw_command(
+                command=0x3c, netfn=6,
+                data=struct.unpack(
+                    "4B", struct.pack("I", self.sessionid)),
+                retry=False)
+        # stop trying for a keepalive,
+        self.lastpayload = None
+        await KEEPALIVE_SESSIONS.acquire()
+        try:
+            Session.keepalive_sessions.pop(self, None)
+        finally:
+            KEEPALIVE_SESSIONS.release()
+        self.logged = 0
+        self.onlogpayload = None
+        self.logging = False
+        if self._customkeepalives:
+            for ka in list(self._customkeepalives):
+                # Be thorough and notify parties through their custom
+                # keepalives.  In practice, this *should* be the same, but
+                # if a code somehow makes duplicate SOL handlers,
+                # this would notify all the handlers rather than just the
+                # last one to take ownership
+                if self._customkeepalives[ka][1] is None:
+                    continue
+                await self._customkeepalives[ka][1](
+                    {'error': 'Session Disconnected'})
+        self._customkeepalives = None
+        if not self.broken:
+            self.socketpool[self.socket] -= 1
+            self.broken = True
+            # since this session is broken, remove it from the handler list
+            # This allows constructor to create a new, functional object to
+            # replace this one
+            myport = self.socket.getsockname()[1]
+            for sockaddr in self.allsockaddrs:
+                if (sockaddr in Session.bmc_handlers
+                        and myport in Session.bmc_handlers[sockaddr]):
+                    del Session.bmc_handlers[sockaddr][myport]
+                    if Session.bmc_handlers[sockaddr] == {}:
+                        del Session.bmc_handlers[sockaddr]
+        self.nowait = False
+        self.socketpool[self.socket] -= 1
+        return {'success': True}
+
+
+if __name__ == "__main__":
+    import sys
+
+    ipmis = Session(bmc=sys.argv[1],
+                    userid=sys.argv[2],
+                    password=os.environ['IPMIPASS'])
+    print(ipmis.raw_command(command=2, data=[1], netfn=0))
+    print(get_ipmi_error({'command': 8, 'code': 128, 'netfn': 1}))
diff --git a/confluent_server/aiohmi/ipmi/private/simplesession.py b/confluent_server/aiohmi/ipmi/private/simplesession.py
new file mode 100644
index 00000000..a4f01e95
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/simplesession.py
@@ -0,0 +1,1400 @@
+# Copyright 2013 IBM Corporation
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This represents the low layer message framing portion of IPMI"""
+
+import collections
+import hashlib
+import hmac
+import os
+import random
+import select
+import socket
+import struct
+import threading
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.ciphers import algorithms
+from cryptography.hazmat.primitives.ciphers import Cipher
+from cryptography.hazmat.primitives.ciphers import modes
+
+import aiohmi.exceptions as exc
+from aiohmi.ipmi.private import constants
+from aiohmi.ipmi.private import util
+from aiohmi.ipmi.private.util import _monotonic_time
+from aiohmi.ipmi.private.util import get_ipmi_error
+
+
+KEEPALIVE_SESSIONS = threading.RLock()
+WAITING_SESSIONS = threading.RLock()
+
+
+try:
+    dict.iteritems
+
+    def dictitems(d):
+        return d.iteritems()
+except AttributeError:
+    def dictitems(d):
+        return d.items()
+
+# minimum timeout for first packet to retry in any given
+# session.  This will be randomized to stagger out retries
+# in case of congestion
+initialtimeout = 0.5
+
+
+ioqueue = collections.deque([])
+ipv6support = None
+selectdeadline = 0
+running = True
+# no more than this many BMCs will share a socket
+# this could be adjusted based on rmem_max
+# value, leading to fewer filehandles
+MAX_BMCS_PER_SOCKET = 64
+
+# maximum time to allow idle, more than this and BMC may assume
+MAX_IDLE = 29
+# incorrect idle
+sessionqueue = collections.deque([])
+
+
+try:
+    IPPROTO_IPV6 = socket.IPPROTO_IPV6
+except AttributeError:
+    IPPROTO_IPV6 = 41  # This is the Win32 version of IPPROTO_IPV6, the only
+    # platform where python *doesn't* have this in socket that aiohmi is
+    # targetting.
+
+
+def _aespad(data):
+    """ipmi demands a certain pad scheme, per table 13-20 AES-CBC encrypted
+
+    payload fields.
+    """
+    currlen = len(data) + 1  # need to count the pad length field as well
+    neededpad = currlen % 16
+    if neededpad:  # if it happens to be zero, hurray, but otherwise invert the
+        # sense of the padding
+        neededpad = 16 - neededpad
+    padval = 1
+    pad = bytearray(neededpad)
+    while padval <= neededpad:
+        pad[padval - 1] = padval
+        padval += 1
+    pad.append(neededpad)
+    return pad
+
+
+def _checksum(*data):  # Two's complement over the data
+    csum = sum(data)
+    csum ^= 0xff
+    csum += 1
+    csum &= 0xff
+    return csum
+
+
+class Session(object):
+    """A class to manage common IPMI session logistics
+
+    Almost all developers should not worry about this class and instead be
+    looking toward ipmi.Command and ipmi.Console.
+
+    For those that do have to worry, the main interesting thing is that the
+    event loop can go one of two ways.  Either a larger manager can query using
+    class methods
+    the soonest timeout deadline and the filehandles to poll and assume
+    responsibility for the polling, or it can register filehandles to be
+    watched.  This is primarily of interest to Console class, which may have an
+    input filehandle to watch and can pass it to Session.
+
+    :param bmc: hostname or ip address of the BMC
+    :param userid: username to use to connect
+    :param password: password to connect to the BMC
+    :param kg: optional parameter if BMC requires Kg be set
+    :param port: UDP port to communicate with, pretty much always 623
+    :param onlogon: callback to receive notification of login completion
+    """
+    bmc_handlers = {}
+    waiting_sessions = {}
+    initting_sessions = {}
+    keepalive_sessions = {}
+    peeraddr_to_nodes = {}
+    iterwaiters = []
+    # NOTE(jbjohnso):
+    # socketpool is a mapping of sockets to usage count
+    socketpool = {}
+    # this will be a lock.  Delay the assignment so that a calling framework
+    # can do something like reassign our threading and select modules
+    socketchecking = None
+
+    # Maintain single Cryptography backend for all IPMI sessions (seems to be
+    # thread-safe)
+    _crypto_backend = default_backend()
+
+    @classmethod
+    def _cleanup(cls):
+        for sesskey in list(cls.bmc_handlers):
+            for portent in list(cls.bmc_handlers[sesskey]):
+                session = cls.bmc_handlers[sesskey][portent]
+                session.cleaningup = True
+                session.logout()
+
+    @classmethod
+    def _assignsocket(cls, server=None):
+        global ipv6support
+
+        if ipv6support:
+            tmpsocket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+            tmpsocket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+        elif ipv6support is None:  # we need to determine ipv6 support now
+            try:
+                tmpsocket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+                tmpsocket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+                ipv6support = True
+            except socket.error:
+                ipv6support = False
+                tmpsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        else:
+            tmpsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        tmpsocket.bind(('', 0))
+        return tmpsocket
+
+    def _sync_login(self, response):
+        """Handle synchronous callers in lieu of a client-provided callback"""
+        # Be a stub, the __init__ will catch and respond to ensure response
+        # is given in the same thread as was called
+        return
+
+    @classmethod
+    def _is_session_valid(cls, session):
+        with util.protect(KEEPALIVE_SESSIONS):
+            sess = cls.keepalive_sessions.get(session, None)
+            if sess is not None and 'timeout' in sess:
+                if sess['timeout'] < _monotonic_time() - 15:
+                    # session would have timed out by now, don't use it
+                    return False
+        return not session.broken
+
+    def __init__(self,
+                 bmc,
+                 userid,
+                 password,
+                 port=623,
+                 kg=None,
+                 onlogon=None,
+                 privlevel=None,
+                 keepalive=True):
+        self.broken = False
+        self.socket = None
+        self.logged = 0
+        if privlevel is not None:
+            self.privlevel = privlevel
+            self.autopriv = False
+        else:
+            self.privlevel = 4
+            self.autopriv = True
+        self.logoutexpiry = None
+        self.autokeepalive = keepalive
+        self.maxtimeout = 3  # be aggressive about giving up on initial packet
+        self.incommand = False
+        self.nameonly = 16  # default to name only lookups in RAKP exchange
+        self.servermode = False
+        self.initialized = True
+        self.cleaningup = False
+        self.lastpayload = None
+        self._customkeepalives = None
+        # queue of events denoting line to run a cmd
+        self.evq = collections.deque([])
+        self.bmc = bmc
+        # a private queue for packets for which this session handler
+        # is destined to receive
+        self.pktqueue = collections.deque([])
+
+        try:
+            self.userid = userid.encode('utf-8')
+            self.password = password.encode('utf-8')
+        except AttributeError:
+            self.userid = userid
+            self.password = password
+        self.nowait = False
+        self.pendingpayloads = collections.deque([])
+        self.request_entry = []
+        self.kgo = kg
+        if kg is not None:
+            try:
+                kg = kg.encode('utf-8')
+            except AttributeError:
+                pass
+            self.kg = kg
+        else:
+            self.kg = self.password
+        self.port = port
+        if onlogon is None:
+            self.async_ = False
+            self.logonwaiters = [self._sync_login]
+        else:
+            self.async_ = True
+            self.logonwaiters = [onlogon]
+        if self.__class__.socketchecking is None:
+            self.__class__.socketchecking = threading.Lock()
+        with self.socketchecking:
+            self.socket = self._assignsocket()
+        self.login()
+        while self.logging:
+            self.wait_for_rsp()
+        if self.broken:
+            raise exc.IpmiException(self.errormsg)
+
+    def _mark_broken(self, error=None):
+        # since our connection has failed retries
+        # deregister our keepalive facility
+        self.lastpayload = None
+        self.logout(False)
+        self.logging = False
+        self.errormsg = error
+        if not self.broken:
+            self.broken = True
+
+    def onlogon(self, parameter):
+        if 'error' in parameter:
+            self._mark_broken(parameter['error'])
+        while self.logonwaiters:
+            waiter = self.logonwaiters.pop()
+            waiter(parameter)
+
+    def _initsession(self):
+        # NOTE(jbjohnso): this number can be whatever we want.
+        #                 I picked 'xCAT' minus 1 so that a hexdump of packet
+        #                 would show xCAT
+        self.localsid = 2017673555
+        self.confalgo = 0
+        self.aeskey = None
+        self.integrityalgo = 0
+        self.attemptedhash = 256
+        self.currhashlib = None
+        self.currhashlen = 0
+        self.k1 = None
+        self.rmcptag = 1
+        self.lastpayload = None
+        self.ipmicallback = None
+        self.sessioncontext = None
+        self.sequencenumber = 0
+        self.sessionid = 0
+        self.authtype = 0
+        self.ipmiversion = 1.5
+        self.timeout = initialtimeout + (0.5 * random.random())
+        self.logoutexpiry = _monotonic_time() + self._getmaxtimeout()
+        self.rqlun = 0
+        self.seqlun = 0
+        # NOTE(jbjohnso): per IPMI table 5-4, software ids in the ipmi spec may
+        #                 be 0x81 through 0x8d.  We'll stick with 0x81 for now,
+        #                 do not forsee a reason to adjust
+        self.rqaddr = 0x81
+
+        self.logging = True
+        self.logged = 0
+        # NOTE(jbjohnso): when we confirm a working sockaddr, put it here to
+        #                 skip getaddrinfo
+        self.sockaddr = None
+        # NOTE(jbjohnso): this tracks netfn,command,seqlun combinations that
+        #                 were retried so that we don't loop around and reuse
+        #                 the same request data and cause potential ambiguity
+        #                 in return
+        self.tabooseq = {}
+        # NOTE(jbjohnso): default to supporting ipmi 2.0.  Strictly by spec,
+        #                 this should gracefully be backwards compat, but some
+        #                 1.5 implementations checked reserved bits
+        self.ipmi15only = 0
+        self.sol_handler = None
+        # NOTE(jbjohnso): This is the callback handler for any SOL payload
+
+    def _make_bridge_request_msg(self, channel, netfn, command):
+        """This function generate message for bridge request. It is a
+
+        part of ipmi payload.
+        """
+        head = bytearray((constants.IPMI_BMC_ADDRESS,
+                          constants.netfn_codes['application'] << 2))
+        check_sum = _checksum(*head)
+        # NOTE(fengqian): according IPMI Figure 14-11, rqSWID is set to 81h
+        boday = bytearray((0x81, (self.seqlun << 2) | self.rqlun,
+                           constants.IPMI_SEND_MESSAGE_CMD, 0x40 | channel))
+        # NOTE(fengqian): Track request
+        self._add_request_entry((constants.netfn_codes['application'] + 1,
+                                 self.seqlun, constants.IPMI_SEND_MESSAGE_CMD))
+        return head + bytearray((check_sum,)) + boday
+
+    def _add_request_entry(self, entry=()):
+        """This function record the request with netfn, sequence number and
+
+        command, which will be used in parse_ipmi_payload.
+        :param entry: a set of netfn, sequence number and command.
+        """
+        if not self._lookup_request_entry(entry):
+            self.request_entry.append(entry)
+
+    def _lookup_request_entry(self, entry=()):
+        return entry in self.request_entry
+
+    def _remove_request_entry(self, entry=()):
+        if self._lookup_request_entry(entry):
+            self.request_entry.remove(entry)
+
+    def _make_ipmi_payload(self, netfn, command, bridge_request=None, data=(),
+                           rslun=0):
+        """This function generates the core ipmi payload that would be
+
+        applicable for any channel (including KCS)
+        """
+        bridge_msg = []
+        self.expectedcmd = command
+        # in ipmi, the response netfn is always one
+        self.expectednetfn = netfn + 1
+        # higher than the request payload, we assume
+        # we are always the requestor for now
+        seqincrement = 7  # IPMI spec forbids gaps bigger then 7 in seq number.
+        # Risk the taboo rather than violate the rules
+        while (not self.servermode
+               and (netfn, command, self.seqlun) in self.tabooseq
+               and self.tabooseq[(netfn, command, self.seqlun)]
+               and seqincrement):
+            self.tabooseq[(self.expectednetfn, command, self.seqlun)] -= 1
+            # Allow taboo to eventually expire after a few rounds
+            self.seqlun += 1  # the last two bits are lun, so add 4 to add 1
+            self.seqlun &= 0x3f  # we only have one byte, wrap when exceeded
+            seqincrement -= 1
+
+        if bridge_request:
+            addr = bridge_request.get('addr', 0x0)
+            channel = bridge_request.get('channel', 0x0)
+            bridge_msg = self._make_bridge_request_msg(channel, netfn, command)
+            # NOTE(fengqian): For bridge request, rsaddr is specified and
+            # rqaddr is BMC address.
+            rqaddr = constants.IPMI_BMC_ADDRESS
+            rsaddr = addr
+        else:
+            rqaddr = self.rqaddr
+            rsaddr = constants.IPMI_BMC_ADDRESS
+        if self.servermode:
+            rsaddr = self.clientaddr
+        # figure 13-4, first two bytes are rsaddr and
+        # netfn, for non-bridge request, rsaddr is always 0x20 since we are
+        # addressing BMC while rsaddr is specified forbridge request
+        header = bytearray((rsaddr, (netfn << 2) | rslun))
+
+        reqbody = bytearray((
+            rqaddr, (self.seqlun << 2) | self.rqlun, command)) + data
+        headsum = bytearray((_checksum(*header),))
+        bodysum = bytearray((_checksum(*reqbody),))
+        payload = header + headsum + reqbody + bodysum
+        if bridge_request:
+            payload = bridge_msg + payload
+            # NOTE(fengqian): For bridge request, another check sum is needed.
+            tail_csum = _checksum(*payload[3:])
+            payload.append(tail_csum)
+
+        if not self.servermode:
+            self._add_request_entry((self.expectednetfn, self.seqlun, command))
+        return payload
+
+    def _generic_callback(self, response):
+        errorstr = get_ipmi_error(response)
+        if errorstr:
+            response['error'] = errorstr
+        self.lastresponse = response
+
+    def _isincommand(self):
+        if self.incommand:
+            stillin = self.incommand - _monotonic_time()
+            if stillin > 0:
+                return stillin
+            else:
+                self.lastpayload = None
+        return 0
+
+    def _getmaxtimeout(self):
+        cumulativetime = 0
+        incrementtime = self.timeout
+        while incrementtime < self.maxtimeout:
+            cumulativetime += incrementtime
+            incrementtime += 1
+        return cumulativetime + 1
+
+    def _cmdwait(self):
+        while self._isincommand():
+            self.wait_for_rsp()
+
+    def awaitresponse(self, retry):
+        while retry and self.lastresponse is None and self.logged:
+            timeout = 30.0  # self.expiration - _monotonic_time()
+            select.select([self.socket], [], [], timeout)
+            while self.iterwaiters:
+                waiter = self.iterwaiters.pop()
+                waiter({'success': True})
+            self.process_pktqueue()
+
+    def raw_command(self,
+                    netfn,
+                    command,
+                    bridge_request=None,
+                    data=(),
+                    retry=True,
+                    delay_xmit=None,
+                    timeout=None,
+                    callback=None,
+                    rslun=0):
+        if not self.logged:
+            if (self.logoutexpiry is not None
+                    and _monotonic_time() > self.logoutexpiry):
+                self._mark_broken()
+            raise exc.IpmiException('Session no longer connected')
+        self._cmdwait()
+        if not self.logged:
+            raise exc.IpmiException('Session no longer connected')
+        self.incommand = _monotonic_time() + self._getmaxtimeout()
+        self.lastresponse = None
+        if callback is None:
+            self.ipmicallback = self._generic_callback
+        else:
+            self.ipmicallback = callback
+        self._send_ipmi_net_payload(netfn, command, data,
+                                    bridge_request=bridge_request,
+                                    retry=retry, delay_xmit=delay_xmit,
+                                    timeout=timeout, rslun=rslun)
+
+        if retry:  # in retry case, let the retry timers indicate wait time
+            timeout = None
+        else:  # if not retry, give it a second before surrending
+            timeout = 1
+        if callback:
+            # caller *must* clean up self.incommand and self.evq
+            return
+        # The event loop is shared amongst aiohmi session instances
+        # within a process.  In this way, synchronous usage of the interface
+        # plays well with asynchronous use.  In fact, this produces the
+        # behavior of only the constructor needing a callback.  From then on,
+        # synchronous usage of the class acts in a greenthread style governed
+        # by order of data on the network
+        self.awaitresponse(retry)
+        lastresponse = self.lastresponse
+        self.incommand = False
+        while self.evq:
+            self.evq.popleft().set()
+        if retry and lastresponse is None:
+            raise exc.IpmiException('Session no longer connected')
+        return lastresponse
+
+    def _send_ipmi_net_payload(self, netfn=None, command=None, data=(), code=0,
+                               bridge_request=None,
+                               retry=None, delay_xmit=None, timeout=None,
+                               rslun=0):
+        if retry is None:
+            retry = not self.servermode
+        if self.servermode:
+            data = bytearray((code,)) + bytearray(data)
+            if netfn is None:
+                netfn = self.clientnetfn
+            if command is None:
+                command = self.clientcommand
+        else:
+            data = bytearray(data)
+        ipmipayload = self._make_ipmi_payload(netfn, command, bridge_request,
+                                              data, rslun)
+        payload_type = constants.payload_types['ipmi']
+        self.send_payload(payload=ipmipayload, payload_type=payload_type,
+                          retry=retry, delay_xmit=delay_xmit, timeout=timeout)
+
+    def send_payload(self, payload=(), payload_type=None, retry=True,
+                     delay_xmit=None, needskeepalive=False, timeout=None):
+        """Send payload over the IPMI Session
+
+        :param needskeepalive: If the payload is expected not to count as
+                               'active' by the BMC, set this to True
+                               to avoid Session considering the
+                               job done because of this payload.
+                               Notably, 0-length SOL packets
+                               are prone to confusion.
+        :param timeout: Specify a custom timeout for long-running request
+        """
+        if payload and self.lastpayload:
+            # we already have a packet outgoing, make this
+            # a pending payload
+            # this way a simplistic BMC won't get confused
+            # and we also avoid having to do more complicated
+            # retry mechanism where each payload is
+            # retried separately
+            self.pendingpayloads.append((payload, payload_type, retry))
+            return
+        if payload_type is None:
+            payload_type = self.last_payload_type
+        if not payload:
+            payload = self.lastpayload
+        message = bytearray(b'\x06\x00\xff\x07')  # constant IPMI RMCP header
+        if retry:
+            self.lastpayload = payload
+            self.last_payload_type = payload_type
+        if not isinstance(payload, bytearray):
+            payload = bytearray(payload)
+        message.append(self.authtype)
+        baretype = payload_type
+        if self.integrityalgo:
+            payload_type |= 0b01000000
+        if self.confalgo:
+            payload_type |= 0b10000000
+        if self.ipmiversion == 2.0:
+            message.append(payload_type)
+            if baretype == 2:
+                # TODO(jbjohnso): OEM payload types
+                raise NotImplementedError("OEM Payloads")
+            elif baretype not in constants.payload_types.values():
+                raise NotImplementedError(
+                    "Unrecognized payload type %d" % baretype)
+            message += struct.pack("<I", self.sessionid)
+        message += struct.pack("<I", self.sequencenumber)
+        if self.ipmiversion == 1.5:
+            message += struct.pack("<I", self.sessionid)
+            if not self.authtype == 0:
+                message += self._ipmi15authcode(payload)
+            message.append(len(payload))
+            message += payload
+            # Guessing the ipmi spec means the whole
+            totlen = 34 + len(message)
+            # packet and assume no tag in old 1.5 world
+            if totlen in (56, 84, 112, 128, 156):
+                message.append(0)  # Legacy pad as mandated by ipmi spec
+        elif self.ipmiversion == 2.0:
+            psize = len(payload)
+            if self.confalgo:
+                pad = (psize + 1) % 16  # pad has to cope with one byte
+                # field like the _aespad function
+                if pad:  # if no pad needed, then we take no more action
+                    pad = 16 - pad
+                # new payload size grew according to pad
+                newpsize = psize + pad + 17
+                # size, plus pad length, plus 16 byte IV
+                # (Table 13-20)
+                message.append(newpsize & 0xff)
+                message.append(newpsize >> 8)
+                iv = os.urandom(16)
+                message += iv
+                payloadtocrypt = bytes(payload + _aespad(payload))
+                crypter = Cipher(
+                    algorithm=algorithms.AES(self.aeskey),
+                    mode=modes.CBC(iv),
+                    backend=self._crypto_backend
+                )
+                encryptor = crypter.encryptor()
+                message += encryptor.update(payloadtocrypt
+                                            ) + encryptor.finalize()
+            else:  # no confidetiality algorithm
+                message.append(psize & 0xff)
+                message.append(psize >> 8)
+                message += payload
+            if self.integrityalgo:  # see table 13-8,
+                # RMCP+ packet format
+                # TODO(jbjohnso): SHA256 which is now
+                # allowed
+                neededpad = (len(message) - 2) % 4
+                if neededpad:
+                    neededpad = 4 - neededpad
+                message += b'\xff' * neededpad
+                message.append(neededpad)
+                message.append(7)  # reserved, 7 is the required value for the
+                # specification followed
+                message += hmac.new(
+                    self.k1, bytes(message[4:]),
+                    self.currhashlib).digest()[:self.currhashlen]
+                # per RFC2404 truncates to 96 bits
+        self.netpacket = message
+        # advance idle timer since we don't need keepalive while sending
+        # packets out naturally
+        self._xmit_packet(retry, delay_xmit=delay_xmit, timeout=timeout)
+
+    def _ipmi15authcode(self, payload, checkremotecode=False):
+        # checkremotecode is used to verify remote code,
+        # otherwise this function is used to general authcode for local
+        if self.authtype == 0:
+            # Only for things before auth in ipmi 1.5, not
+            # like 2.0 cipher suite 0
+            return ()
+        password = self.password
+        padneeded = 16 - len(password)
+        if padneeded < 0:
+            raise exc.IpmiException("Password is too long for ipmi 1.5")
+        password += '\x00' * padneeded
+        if checkremotecode:
+            seqbytes = struct.pack("<I", self.remseqnumber)
+        else:
+            seqbytes = struct.pack("<I", self.sequencenumber)
+        sessdata = struct.pack("<I", self.sessionid)
+        bodydata = password + sessdata + payload + seqbytes + password
+        dgst = hashlib.md5(bodydata).digest()
+        return dgst
+
+    def _got_channel_auth_cap(self, response):
+        if 'error' in response:
+            self.onlogon(response)
+            return
+        self.maxtimeout = 6  # we have a confirmed bmc, be more tenacious
+        if response['code'] == 0xcc and self.ipmi15only is not None:
+            # tried ipmi 2.0 against a 1.5 which should work, but some bmcs
+            # thought 'reserved' meant 'must be zero'
+            self.ipmi15only = 1
+            return self._get_channel_auth_cap()
+        mysuffix = " while trying to get channel authentication capabalities"
+        errstr = get_ipmi_error(response, suffix=mysuffix)
+        if errstr:
+            self.onlogon({'error': errstr})
+            return
+        data = response['data']
+        self.currentchannel = data[0]
+        if data[1] & 0b10000000 and data[3] & 0b10:  # ipmi 2.0 support
+            self.ipmiversion = 2.0
+        if self.ipmiversion == 1.5:
+            if not (data[1] & 0b100):
+                self.onlogon(
+                    {'error':
+                     "MD5 required but not enabled/available on target BMC"})
+                return
+            self._get_session_challenge()
+        elif self.ipmiversion == 2.0:
+            self._open_rmcpplus_request()
+
+    def _got_session_challenge(self, response):
+        errstr = get_ipmi_error(response,
+                                suffix=" while getting session challenge")
+        if errstr:
+            self.onlogon({'error': errstr})
+            return
+        data = response['data']
+        self.sessionid = struct.unpack("<I", bytes(data[0:4]))[0]
+        self.authtype = 2
+        self._activate_session(data[4:])
+
+    # NOTE(jbjohnso):
+    # This sends the activate session payload.  We pick '1' as the requested
+    # sequence number without perturbing our real sequence number
+
+    def _activate_session(self, data):
+        rqdata = [2, 4] + list(data) + [1, 0, 0, 0]
+        # TODO(jbjohnso): this always requests admin level (1.5)
+        self.ipmicallback = self._activated_session
+        self._send_ipmi_net_payload(netfn=0x6, command=0x3a, data=rqdata)
+
+    def _activated_session(self, response):
+        errstr = get_ipmi_error(response)
+        if errstr:
+            self.onlogon({'error': errstr})
+            return
+        data = response['data']
+        self.sessionid = struct.unpack("<I", bytes(data[1:5]))[0]
+        self.sequencenumber = struct.unpack("<I", bytes(data[5:9]))[0]
+        self._req_priv_level()
+
+    def _req_priv_level(self):
+        self.logged = 1
+        self.logoutexpiry = None
+        response = self.raw_command(netfn=0x6, command=0x3b,
+                                    data=[self.privlevel])
+        if response['code']:
+            if response['code'] in (0x80, 0x81) and self.privlevel == 4:
+                # some implementations will let us get this far,
+                # but suddenly get skiddish.  Try again in such a case
+                self.privlevel = 3
+                response = self.raw_command(netfn=0x6, command=0x3b,
+                                            data=[self.privlevel])
+            if response['code']:
+                self.logged = 0
+                self.logging = False
+                mysuffix = " while requesting privelege level %d for %s" % (
+                    self.privlevel, self.userid)
+                errstr = get_ipmi_error(response, suffix=mysuffix)
+                if errstr:
+                    self.onlogon({'error': errstr})
+                    return
+        self.logging = False
+        with util.protect(KEEPALIVE_SESSIONS):
+            Session.keepalive_sessions[self] = {}
+            Session.keepalive_sessions[self]['ipmisession'] = self
+            Session.keepalive_sessions[self]['timeout'] = _monotonic_time() + \
+                MAX_IDLE - (random.random() * 4.9)
+        self.onlogon({'success': True})
+
+    def _get_session_challenge(self):
+        reqdata = bytearray([2])
+        if len(self.userid) > 16:
+            raise exc.IpmiException(
+                "Username too long for IPMI, must not exceed 16")
+        padneeded = 16 - len(self.userid)
+        userid = self.userid + ('\x00' * padneeded)
+        reqdata += userid
+        self.ipmicallback = self._got_session_challenge
+        self._send_ipmi_net_payload(netfn=0x6, command=0x39, data=reqdata)
+
+    def _open_rmcpplus_request(self):
+        self.authtype = 6
+        # have unique local session ids to ignore aborted
+        # login attempts from the past
+        self.localsid += 1
+        self.rmcptag += 1
+        data = bytearray([
+            self.rmcptag,
+            0,  # request as much privilege as the channel will give us
+            0, 0,  # reserved
+        ])
+        data += struct.pack("<I", self.localsid)
+        # auth 3 sha256
+        # integrity... 4 = sha256
+        if self.attemptedhash == 1:
+            data += bytearray([
+                0, 0, 0, 8, 1, 0, 0, 0,  # table 13-17, SHA-1
+                1, 0, 0, 8, 1, 0, 0, 0,  # SHA-1 integrity
+                2, 0, 0, 8, 1, 0, 0, 0,  # AES privacy
+                # 2,0,0,8,0,0,0,0, #no privacy confalgo
+            ])
+            self.currhashlib = hashlib.sha1
+            self.currhashlen = 12
+        else:
+            data += bytearray([
+                0, 0, 0, 8, 3, 0, 0, 0,  # table 13-17, SHA-256
+                1, 0, 0, 8, 4, 0, 0, 0,  # SHA-256-128 integrity
+                2, 0, 0, 8, 1, 0, 0, 0,  # AES privacy
+                # 2,0,0,8,0,0,0,0, #no privacy confalgo
+            ])
+            self.currhashlib = hashlib.sha256
+            self.currhashlen = 16
+        self.sessioncontext = 'OPENSESSION'
+        self.lastpayload = None
+        self.send_payload(
+            payload=data,
+            payload_type=constants.payload_types['rmcpplusopenreq'])
+
+    def _get_channel_auth_cap(self):
+        self.ipmicallback = self._got_channel_auth_cap
+        if self.ipmi15only:
+            self._send_ipmi_net_payload(netfn=0x6,
+                                        command=0x38,
+                                        data=[0x0e, self.privlevel])
+        else:
+            self._send_ipmi_net_payload(netfn=0x6,
+                                        command=0x38,
+                                        data=[0x8e, self.privlevel])
+
+    def login(self):
+        self.logontries = 5
+        self._initsession()
+        self._get_channel_auth_cap()
+
+    @classmethod
+    def pause(cls, timeout):
+        starttime = _monotonic_time()
+        while _monotonic_time() - starttime < timeout:
+            cls.wait_for_rsp(timeout - (_monotonic_time() - starttime))
+
+    def wait_for_rsp(self, timeout=None, callout=True):
+        """IPMI Session Event loop iteration
+
+        This watches for any activity on IPMI handles and handles registered
+        by register_handle_callback.  Callers are satisfied in the order that
+        packets return from network, not in the order of calling.
+
+        :param timeout: Maximum time to wait for data to come across.  If
+                        unspecified, will autodetect based on earliest timeout
+        """
+        rdy = select.select([self.socket], [], [], timeout)[0]
+        if rdy:
+            self.process_pktqueue()
+
+    def register_keepalive(self, cmd, callback):
+        """Register  custom keepalive IPMI command
+
+        This is mostly intended for use by the console code.
+        calling code would have an easier time just scheduling in their
+        own threading scheme.  Such a behavior would naturally cause
+        the default keepalive to not occur anyway if the calling code
+        is at least as aggressive about timing as aiohmi
+        :param cmd: A dict of arguments to be passed into raw_command
+        :param callback: A function to be called with results of the keepalive
+
+        :returns: value to identify registration for unregister_keepalive
+        """
+        regid = random.random()
+        if self._customkeepalives is None:
+            self._customkeepalives = {regid: (cmd, callback)}
+        else:
+            while regid in self._customkeepalives:
+                regid = random.random()
+            self._customkeepalives[regid] = (cmd, callback)
+        return regid
+
+    def unregister_keepalive(self, regid):
+        if self._customkeepalives is None:
+            return
+        try:
+            del self._customkeepalives[regid]
+        except KeyError:
+            pass
+
+    def _keepalive_wrapper(self, callback):
+        # generates a wrapped keepalive to cleanup session state
+        # and call callback if appropriate
+        def _keptalive(response):
+            self._generic_callback(response)
+            response = self.lastresponse
+            self.incommand = False
+            while self.evq:
+                self.evq.popleft().set()
+            if callback:
+                callback(response)
+
+        return _keptalive
+
+    def _keepalive(self):
+        """Performs a keepalive to avoid idle disconnect"""
+
+        try:
+            keptalive = False
+            if self._customkeepalives:
+                kaids = list(self._customkeepalives.keys())
+                for keepalive in kaids:
+                    try:
+                        cmd, callback = self._customkeepalives[keepalive]
+                    except TypeError:
+                        # raw_command made customkeepalives None
+                        break
+                    except KeyError:
+                        # raw command ultimately caused a keepalive to
+                        # deregister
+                        continue
+                    if callable(cmd):
+                        cmd()
+                        continue
+                    keptalive = True
+                    cmd['callback'] = self._keepalive_wrapper(callback)
+                    self.raw_command(**cmd)
+            if not keptalive:
+                if self.incommand:
+                    # if currently in command, no cause to keepalive
+                    return
+                if self.autokeepalive:
+                    self.raw_command(netfn=6, command=1,
+                                     callback=self._keepalive_wrapper(None))
+                else:
+                    self.logout()
+        except exc.IpmiException:
+            self._mark_broken()
+
+    def process_pktqueue(self):
+        ready = select.select([self.socket], [], [], 0.0)[0]
+        while ready:
+            pkt = self.socket.recvfrom(3000)
+            ready = select.select([self.socket], [], [], 0.0)[0]
+            data = bytearray(pkt[0])
+            if not (data[0] == 6 and data[2:4] == b'\xff\x07'):
+                continue
+            # this should be in specific context, no need to check port
+            # since recvfrom result was already routed to this object
+            # specifically
+            self._handle_ipmi_packet(data, sockaddr=pkt[1], qent=pkt)
+
+    def _handle_ipmi_packet(self, data, sockaddr=None, qent=None):
+        if self.sockaddr is None and sockaddr is not None:
+            self.sockaddr = sockaddr
+        elif (self.sockaddr is not None
+              and sockaddr is not None
+              and self.sockaddr != sockaddr):
+            return  # here, we might have sent an ipv4 and ipv6 packet to kick
+            # things off ignore the second reply since we have one
+            # satisfactory answer
+        if data[4] in (0, 2):  # This is an ipmi 1.5 paylod
+            remseqnumber = struct.unpack('<I', bytes(data[5:9]))[0]
+            remsessid = struct.unpack("<I", bytes(data[9:13]))[0]
+            if (hasattr(self, 'remseqnumber')
+                    and remseqnumber < self.remseqnumber):
+                return -5  # remote sequence number is too low, reject it
+            self.remseqnumber = remseqnumber
+            if data[4] != self.authtype:
+                # BMC responded with mismatch authtype, for
+                # mutual authentication reject it. If this causes
+                # legitimate issues, it's the vendor's fault
+                return -2
+            if remsessid != self.sessionid:
+                return -1  # does not match our session id, drop it
+            authcode = False
+            if data[4] == 2:  # we have authcode in this ipmi 1.5 packet
+                authcode = data[13:29]
+                del data[13:29]
+                # this is why we needed a mutable representation
+            payload = data[14:14 + data[13]]
+            if authcode:
+                expectedauthcode = self._ipmi15authcode(payload,
+                                                        checkremotecode=True)
+                if expectedauthcode != authcode:
+                    return
+            self._parse_ipmi_payload(payload)
+        elif data[4] == 6:
+            self._handle_ipmi2_packet(data)
+        else:
+            return  # unrecognized data, assume evil
+
+    def _got_rakp1(self, data):
+        # stub, client sessions ignore rakp2
+        pass
+
+    def _got_rakp3(self, data):
+        # stub, client sessions ignore rakp3
+        pass
+
+    def _got_rmcp_openrequest(self, data):
+        pass
+
+    def _handle_ipmi2_packet(self, data):
+        ptype = data[5] & 0b00111111
+        # the first 16 bytes are header information as can be seen in 13-8 that
+        # we will toss out
+        if ptype == 0x10:
+            return self._got_rmcp_openrequest(data[16:])
+        elif ptype == 0x11:  # rmcp+ response
+            return self._got_rmcp_response(data[16:])
+        elif ptype == 0x12:
+            return self._got_rakp1(data[16:])
+        elif ptype == 0x13:
+            return self._got_rakp2(data[16:])
+        elif ptype == 0x14:
+            return self._got_rakp3(data[16:])
+        elif ptype == 0x15:
+            return self._got_rakp4(data[16:])
+        elif ptype == 0 or ptype == 1:  # good old ipmi payload or sol
+            # If endorsing a shared secret scheme, then at the very least it
+            # needs to do mutual assurance
+            if not (data[5] & 0b01000000):  # This would be the line that might
+                # trip up some insecure BMC
+                # implementation
+                return
+            encrypted = 0
+            if data[5] & 0b10000000:
+                encrypted = 1
+            authcode = data[-self.currhashlen:]
+            if self.k1 is None:  # we are in no shape to process a packet now
+                return
+            expectedauthcode = hmac.new(
+                self.k1, data[4:-self.currhashlen],
+                self.currhashlib).digest()[:self.currhashlen]
+            if authcode != expectedauthcode:
+                return  # BMC failed to assure integrity to us, drop it
+            sid = struct.unpack("<I", bytes(data[6:10]))[0]
+            if sid != self.localsid:  # session id mismatch, drop it
+                return
+            remseqnumber = struct.unpack("<I", bytes(data[10:14]))[0]
+            if (hasattr(self, 'remseqnumber')
+                    and (remseqnumber < self.remseqnumber)
+                    and (self.remseqnumber != 0xffffffff)):
+                return
+            self.remseqnumber = remseqnumber
+            psize = data[14] + (data[15] << 8)
+            payload = data[16:16 + psize]
+            if encrypted:
+                iv = data[16:32]
+                crypter = Cipher(
+                    algorithm=algorithms.AES(self.aeskey),
+                    mode=modes.CBC(bytes(iv)),
+                    backend=self._crypto_backend
+                )
+                decryptor = crypter.decryptor()
+                payload = bytearray(decryptor.update(bytes(payload[16:])
+                                                     ) + decryptor.finalize())
+                padsize = payload[-1] + 1
+                payload = payload[:-padsize]
+            if ptype == 0:
+                self._parse_ipmi_payload(payload)
+            elif ptype == 1:  # There should be no other option
+                if (payload[1] & 0b1111) and self.last_payload_type == 1:
+                    # for ptype 1, the 4 least significant bits of 2nd byte
+                    # is  the ACK number.
+                    # if it isn't an ACK at all, we'll keep retrying, however
+                    # if it's a subtle SOL situation (partial ACK, wrong ACK)
+                    # then sol_handler will have to resubmit and we will
+                    # stop the generic retry behavior here
+                    self.lastpayload = None
+                    self.last_payload_type = None
+                    with util.protect(WAITING_SESSIONS):
+                        Session.waiting_sessions.pop(self, None)
+                    if len(self.pendingpayloads) > 0:
+                        (nextpayload, nextpayloadtype, retry) = \
+                            self.pendingpayloads.popleft()
+                        self.send_payload(payload=nextpayload,
+                                          payload_type=nextpayloadtype,
+                                          retry=retry)
+                if self.sol_handler:
+                    self.sol_handler(payload)
+
+    def _got_rmcp_response(self, data):
+        # see RMCP+ open session response table
+        if not (self.sessioncontext and self.sessioncontext != "Established"):
+            return -9
+            # ignore payload as we are not in a state valid it
+        if data[0] != self.rmcptag:
+            return -9  # use rmcp tag to track and reject stale responses
+        if data[1] != 0:  # response code...
+            if self.attemptedhash == 256:
+                self.attemptedhash = 1
+                self._open_rmcpplus_request()
+                return
+            if data[1] in constants.rmcp_codes:
+                errstr = constants.rmcp_codes[data[1]]
+            else:
+                errstr = "Unrecognized RMCP code %d" % data[1]
+            self.onlogon({'error': errstr})
+            return -9
+        self.allowedpriv = data[2]
+        # NOTE(jbjohnso): At this point, the BMC has no idea about what user
+        # shall be used.  As such, the allowedpriv field is actually
+        # not particularly useful.  got_rakp2 is a good place to
+        # gracefully detect and downgrade privilege for retry
+        localsid = struct.unpack("<I", bytes(data[4:8]))[0]
+        if self.localsid != localsid:
+            return -9
+        self.pendingsessionid = struct.unpack("<I", bytes(data[8:12]))[0]
+        # TODO(jbjohnso): currently, we take it for granted that the responder
+        # accepted our integrity/auth/confidentiality proposal
+        self.lastpayload = None
+        self._send_rakp1()
+
+    def _send_rakp1(self):
+        self.rmcptag += 1
+        self.randombytes = os.urandom(16)
+        userlen = len(self.userid)
+        payload = bytearray([self.rmcptag, 0, 0, 0]) + \
+            struct.pack("<I", self.pendingsessionid) + \
+            self.randombytes +\
+            bytearray([self.nameonly | self.privlevel, 0, 0, userlen]) + \
+            self.userid
+        self.sessioncontext = "EXPECTINGRAKP2"
+        self.send_payload(
+            payload=payload, payload_type=constants.payload_types['rakp1'])
+
+    def _got_rakp2(self, data):
+        if not (self.sessioncontext in ('EXPECTINGRAKP2', 'EXPECTINGRAKP4')):
+            # if we are not expecting rakp2, ignore. In a retry
+            # scenario, replying from stale RAKP2 after sending
+            # RAKP3 seems to be best
+            return -9
+        if data[0] != self.rmcptag:  # ignore mismatched tags for retry logic
+            return -9
+        if data[1] != 0:  # if not successful, consider next move
+            if data[1] in (9, 0xd) and self.privlevel == 4 and self.autopriv:
+                # Here the situation is likely that the peer didn't want
+                # us to use admin.  Degrade to operator and try again
+                self.privlevel = 3
+                self.login()
+                return
+            # invalid sessionid 99% of the time means a retry
+            # scenario invalidated an in-flight transaction
+            if data[1] == 2:
+                return
+            if data[1] in constants.rmcp_codes:
+                errstr = constants.rmcp_codes[data[1]]
+            else:
+                errstr = "Unrecognized RMCP code %d" % data[1]
+            self.onlogon({'error': errstr + " in RAKP2"})
+            return -9
+        localsid = struct.unpack("<I", bytes(data[4:8]))[0]
+        if localsid != self.localsid:
+            return -9  # discard mismatch in the session identifier
+        self.remoterandombytes = bytes(data[8:24])
+        self.remoteguid = bytes(data[24:40])
+        userlen = len(self.userid)
+        hmacdata = (struct.pack("<II", localsid, self.pendingsessionid)
+                    + self.randombytes + self.remoterandombytes
+                    + self.remoteguid + struct.pack("2B", self.nameonly
+                                                    | self.privlevel, userlen)
+                    + self.userid)
+        expectedhash = hmac.new(self.password, hmacdata,
+                                self.currhashlib).digest()
+        hashlen = len(expectedhash)
+        givenhash = struct.pack("%dB" % hashlen, *data[40:hashlen + 40])
+        if givenhash != expectedhash:
+            self.sessioncontext = "FAILED"
+            self.onlogon({'error': "Incorrect password provided"})
+            return -9
+        # We have now validated that the BMC and client agree on password, time
+        # to store the keys
+        self.sik = hmac.new(self.kg,
+                            self.randombytes + self.remoterandombytes
+                            + struct.pack("2B", self.nameonly
+                                          | self.privlevel, userlen)
+                            + self.userid, self.currhashlib).digest()
+        self.k1 = hmac.new(self.sik, b'\x01' * 20, self.currhashlib).digest()
+        self.k2 = hmac.new(self.sik, b'\x02' * 20, self.currhashlib).digest()
+        self.aeskey = self.k2[0:16]
+        self.sessioncontext = "EXPECTINGRAKP4"
+        self.lastpayload = None
+        self._send_rakp3()
+
+    def _send_rakp3(self):  # rakp message 3
+        self.rmcptag += 1
+        # rmcptag, then status 0, then two reserved 0s
+        payload = [self.rmcptag, 0, 0, 0] +\
+            list(struct.unpack("4B", struct.pack("<I", self.pendingsessionid)))
+        hmacdata = self.remoterandombytes +\
+            struct.pack("<I", self.localsid) +\
+            struct.pack("2B", self.nameonly | self.privlevel,
+                        len(self.userid)) +\
+            self.userid
+
+        authcode = hmac.new(self.password, hmacdata, self.currhashlib).digest()
+        payload += list(struct.unpack("%dB" % len(authcode), authcode))
+        self.send_payload(
+            payload=payload, payload_type=constants.payload_types['rakp3'])
+
+    def _relog(self):
+        self._initsession()
+        self.logontries -= 1
+        return self._get_channel_auth_cap()
+
+    def _got_rakp4(self, data):
+        if self.sessioncontext != "EXPECTINGRAKP4" or data[0] != self.rmcptag:
+            return -9
+        if data[1] != 0:
+            if data[1] == 2 and self.logontries:  # if we retried RAKP3 because
+                # RAKP4 got dropped, BMC can consider it done and we must
+                # restart
+                self._relog()
+            # ignore 15 value if we are retrying.
+            # xCAT did but I can't recall why exactly
+            if data[1] == 15 and self.logontries:
+                # TODO(jbjohnso) jog my memory to update the comment
+                return
+            if data[1] in constants.rmcp_codes:
+                errstr = constants.rmcp_codes[data[1]]
+            else:
+                errstr = "Unrecognized RMCP code %d" % data[1]
+            self.onlogon({'error': errstr + " reported in RAKP4"})
+            return -9
+        localsid = struct.unpack("<I", bytes(data[4:8]))[0]
+        if localsid != self.localsid:  # ignore if wrong session id indicated
+            return -9
+        hmacdata = self.randombytes +\
+            struct.pack("<I", self.pendingsessionid) +\
+            self.remoteguid
+        expectedauthcode = hmac.new(
+            self.sik, hmacdata, self.currhashlib).digest()[:self.currhashlen]
+        aclen = len(expectedauthcode)
+        authcode = struct.pack("%dB" % aclen, *data[8:aclen + 8])
+        if authcode != expectedauthcode:
+            self.onlogon({'error': "Invalid RAKP4 integrity code (wrong Kg?)"})
+            return
+        self.sessionid = self.pendingsessionid
+        self.integrityalgo = self.attemptedhash
+        self.confalgo = 'aes'
+        self.sequencenumber = 1
+        self.sessioncontext = 'ESTABLISHED'
+        self.lastpayload = None
+        self._req_priv_level()
+
+    # Internal function to parse IPMI nugget once extracted from its framing
+    def _parse_ipmi_payload(self, payload):
+        # For now, skip the checksums since we are in LAN only,
+        # TODO(jbjohnso): if implementing other channels, add checksum checks
+        # here
+        if len(payload) < 7:
+            # This cannot possibly be a valid IPMI packet.  Note this is after
+            # the integrity checks, so this must be a buggy BMC packet
+            # One example was a BMC that if receiving an SOL deactivate
+            # from another party would emit what looks to be an attempt
+            # at SOL deactivation payload, but with the wrong payload type
+            # since we can't do anything remotely sane with such a packet,
+            # drop it and carry about our business.
+            return
+        entry = (payload[1] >> 2, payload[4] >> 2, payload[5])
+        if self._lookup_request_entry(entry):
+            self._remove_request_entry(entry)
+
+            # NOTE(fengqian): for bridge request, we need to handle the
+            # response twice. First response shows if message send correctly,
+            # second response is the real response.
+            # If the message is send crrectly, we will discard the first
+            # response or else error message will be parsed and return.
+            if ((entry[0] in [0x06, 0x07])
+                    and (entry[2] == 0x34)
+                    and (payload[-2] == 0x0)):
+                return -1
+            else:
+                self._parse_payload(payload)
+                # NOTE(fengqian): recheck if the certain entry is removed in
+                # case that bridge request failed.
+                if self.request_entry:
+                    self._remove_request_entry((self.expectednetfn,
+                                                self.seqlun, self.expectedcmd))
+        else:
+            # payload is not a match for our last packet
+            # it is also not a bridge request.
+            return -1
+
+    def _parse_payload(self, payload):
+        if hasattr(self, 'hasretried') and self.hasretried:
+            self.hasretried = 0
+            # try to skip it for at most 16 cycles of overflow
+            self.tabooseq[
+                (self.expectednetfn, self.expectedcmd, self.seqlun)] = 16
+        # We want to now remember that we do not have an expected packet
+        # bigger than one byte means it can never match the one byte value
+        # by mistake
+        self.expectednetfn = 0x1ff
+        self.expectedcmd = 0x1ff
+        if not self.servermode:
+            self.seqlun += 1  # prepare seqlun for next transmit
+            self.seqlun &= 0x3f  # when overflowing, wrap around
+        # render retry mechanism utterly incapable of
+        # doing anything, though it shouldn't matter
+        self.lastpayload = None
+        self.last_payload_type = None
+        response = {'netfn': payload[1] >> 2}
+        # ^^ remove header of rsaddr/netfn/lun/checksum/rq/seq/lun
+        del payload[0:5]
+        # remove the trailing checksum
+        del payload[-1]
+        response['command'] = payload[0]
+        if self.servermode:
+            del payload[0:1]
+            response['data'] = payload
+        else:
+            response['code'] = payload[1]
+            del payload[0:2]
+            response['data'] = payload
+        self.timeout = initialtimeout + (0.5 * random.random())
+        if not self.servermode and len(self.pendingpayloads) > 0:
+            (nextpayload, nextpayloadtype, retry) = \
+                self.pendingpayloads.popleft()
+            self.send_payload(payload=nextpayload,
+                              payload_type=nextpayloadtype,
+                              retry=retry)
+        self.ipmicallback(response)
+
+    def _timedout(self):
+        if not self.lastpayload:
+            return
+        self.nowait = True
+        self.timeout += 1
+        if self.timeout > self.maxtimeout:
+            response = {'error': 'timeout', 'code': 0xffff}
+            self.ipmicallback(response)
+            self.nowait = False
+            self._mark_broken()
+            return
+        elif self.sessioncontext == 'FAILED':
+            self.lastpayload = None
+            self.nowait = False
+            return
+        if self.sessioncontext == 'OPENSESSION':
+            # In this case, we want to craft a new session request to have
+            # unambiguous session id regardless of how packet was dropped or
+            # delayed in this case, it's safe to just redo the request
+            self.lastpayload = None
+            self._open_rmcpplus_request()
+        elif (self.sessioncontext == 'EXPECTINGRAKP2'
+              or self.sessioncontext == 'EXPECTINGRAKP4'):
+            # If we can't be sure which RAKP was dropped or if RAKP3/4 was just
+            # delayed, the most reliable thing to do is rewind and start over
+            # bmcs do not take kindly to receiving RAKP1 or RAKP3 twice
+            self.lastpayload = None
+            self._relog()
+        else:  # in IPMI case, the only recourse is to act as if the packet is
+            # idempotent.  SOL has more sophisticated retry handling
+            # the biggest risks are reset sp which is often fruitless to retry
+            # and chassis reset, which sometimes will shoot itself
+            # systematically in the head in a shared port case making replies
+            # impossible
+            self.hasretried = 1  # remember so that we can track taboo
+            # combinations
+            # of sequence number, netfn, and lun due to
+            # ambiguity on the wire
+            self.send_payload()
+        self.nowait = False
+
+    def _xmit_packet(self, retry=True, delay_xmit=None, timeout=None):
+        if self.sequencenumber:  # seq number of zero will be left alone, it is
+            # special, otherwise increment
+            self.sequencenumber += 1
+        if delay_xmit is not None:
+            select.select([self.socket], [], [], delay_xmit)
+        if self.sockaddr:
+            self.socket.sendto(self.netpacket, self.sockaddr)
+        else:
+            # he have not yet picked a working sockaddr for this connection,
+            # try all the candidates that getaddrinfo provides
+            self.allsockaddrs = []
+            try:
+                for res in socket.getaddrinfo(self.bmc,
+                                              self.port,
+                                              0,
+                                              socket.SOCK_DGRAM):
+                    sockaddr = res[4]
+                    if ipv6support and res[0] == socket.AF_INET:
+                        # convert the sockaddr to AF_INET6
+                        newhost = '::ffff:' + sockaddr[0]
+                        sockaddr = (newhost, sockaddr[1], 0, 0)
+                    self.allsockaddrs.append(sockaddr)
+                    self.socket.sendto(self.netpacket, sockaddr)
+            except socket.gaierror:
+                raise exc.IpmiException(
+                    "Unable to transmit to specified address")
+        if retry:
+            # TODO(jjohnson2):  implement retry for simplesession
+            pass
+
+    def logout(self, sessionok=True):
+        if not self.logged:
+            return {'success': True}
+        if self.cleaningup:
+            self.nowait = True
+        if self.sol_handler:
+            self.raw_command(netfn=6, command=0x49, data=(1, 1, 0, 0, 0, 0),
+                             retry=sessionok)
+        self.raw_command(command=0x3c,
+                         netfn=6,
+                         data=struct.unpack("4B",
+                                            struct.pack("I", self.sessionid)),
+                         retry=False)
+        # stop trying for a keepalive,
+        self.lastpayload = None
+        with util.protect(KEEPALIVE_SESSIONS):
+            Session.keepalive_sessions.pop(self, None)
+        self.logged = 0
+        self.logging = False
+        if self._customkeepalives:
+            for ka in list(self._customkeepalives):
+                # Be thorough and notify parties through their custom
+                # keepalives.  In practice, this *should* be the same, but
+                # if a code somehow makes duplicate SOL handlers,
+                # this would notify all the handlers rather than just the
+                # last one to take ownership
+                self._customkeepalives[ka][1](
+                    {'error': 'Session Disconnected'})
+        self._customkeepalives = None
+        self.broken = True
+        self.nowait = False
+        return {'success': True}
+
+
+if __name__ == "__main__":
+    import sys
+
+    ipmis = Session(bmc=sys.argv[1],
+                    userid=sys.argv[2],
+                    password=os.environ['IPMIPASS'])
+    print(ipmis.raw_command(command=2, data=[1], netfn=0))
+    print(get_ipmi_error({'command': 8, 'code': 128, 'netfn': 1}))
diff --git a/confluent_server/aiohmi/ipmi/private/spd.py b/confluent_server/aiohmi/ipmi/private/spd.py
new file mode 100644
index 00000000..1aec0777
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/spd.py
@@ -0,0 +1,839 @@
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This implements parsing of DDR SPD data.  This is offered up in a pass
+through fashion by some service processors.
+
+For now, just doing DDR3 and DDR4
+
+In many cases, astute readers will note that some of the lookup tables
+should be a matter of math rather than lookup.  However the SPD
+specification explicitly reserves values not in the lookup tables for
+future use.  It has happened, for example, that a spec was amended
+with discontinuous values for a field that was until that point
+possible to derive in a formulaic way
+"""
+
+import math
+import struct
+
+jedec_ids = [
+    {
+        0x01: "AMD",
+        0x02: "AMI",
+        0x83: "Fairchild",
+        0x04: "Fujitsu",
+        0x85: "GTE",
+        0x86: "Harris",
+        0x07: "Hitachi",
+        0x08: "Inmos",
+        0x89: "Intel",
+        0x8a: "I.T.T.",
+        0x0b: "Intersil",
+        0x8c: "Monolithic Memories",
+        0x0d: "Mostek",
+        0x0e: "Motorola",
+        0x8f: "National",
+        0x10: "NEC",
+        0x91: "RCA",
+        0x92: "Raytheon",
+        0x13: "Conexant (Rockwell)",
+        0x94: "Seeq",
+        0x15: "Philips Semi. (Signetics)",
+        0x16: "Synertek",
+        0x97: "Texas Instruments",
+        0x98: "Toshiba",
+        0x19: "Xicor",
+        0x1a: "Zilog",
+        0x9b: "Eurotechnique",
+        0x1c: "Mitsubishi",
+        0x9d: "Lucent (AT&T)",
+        0x9e: "Exel",
+        0x1f: "Atmel",
+        0x20: "SGS/Thomson",
+        0xa1: "Lattice Semi.",
+        0xa2: "NCR",
+        0x23: "Wafer Scale Integration",
+        0xa4: "IBM",
+        0x25: "Tristar",
+        0x26: "Visic",
+        0xa7: "Intl. CMOS Technology",
+        0xa8: "SSSI",
+        0x29: "Microchip Technology",
+        0x2a: "Ricoh Ltd.",
+        0xab: "VLSI",
+        0x2c: "Micron Technology",
+        0xad: "Hyundai Electronics",
+        0xae: "OKI Semiconductor",
+        0x2f: "ACTEL",
+        0xb0: "Sharp",
+        0x31: "Catalyst",
+        0x32: "Panasonic",
+        0xb3: "IDT",
+        0x34: "Cypress",
+        0xb5: "DEC",
+        0xb6: "LSI Logic",
+        0x37: "Zarlink",
+        0x38: "UTMC",
+        0xb9: "Thinking Machine",
+        0xba: "Thomson CSF",
+        0x3b: "Integrated CMOS(Vertex)",
+        0xbc: "Honeywell",
+        0x3d: "Tektronix",
+        0x3e: "Sun Microsystems",
+        0xbf: "SST",
+        0x40: "MOSEL",
+        0xc1: "Infineon",
+        0xc2: "Macronix",
+        0x43: "Xerox",
+        0xc4: "Plus Logic",
+        0x45: "SunDisk",
+        0x46: "Elan Circuit Tech.",
+        0xc7: "European Silicon Str.",
+        0xc8: "Apple Computer",
+        0xc9: "Xilinx",
+        0x4a: "Compaq",
+        0xcb: "Protocol Engines",
+        0x4c: "SCI",
+        0xcd: "Seiko Instruments",
+        0xce: "Samsung",
+        0x4f: "I3 Design System",
+        0xd0: "Klic",
+        0x51: "Crosspoint Solutions",
+        0x52: "Alliance Semiconductor",
+        0xd3: "Tandem",
+        0x54: "Hewlett-Packard",
+        0xd5: "Intg. Silicon Solutions",
+        0xd6: "Brooktree",
+        0x57: "New Media",
+        0x58: "MHS Electronic",
+        0xd9: "Performance Semi.",
+        0xda: "Winbond Electronic",
+        0x5b: "Kawasaki Steel",
+        0xdc: "Bright Micro",
+        0x5d: "TECMAR",
+        0x5e: "Exar",
+        0xdf: "PCMCIA",
+        0xe0: "LG Semiconductor",
+        0x61: "Northern Telecom",
+        0x62: "Sanyo",
+        0xe3: "Array Microsystems",
+        0x64: "Crystal Semiconductor",
+        0xe5: "Analog Devices",
+        0xe6: "PMC-Sierra",
+        0x67: "Asparix",
+        0x68: "Convex Computer",
+        0xe9: "Quality Semiconductor",
+        0xea: "Nimbus Technology",
+        0x6b: "Transwitch",
+        0xec: "Micronas (ITT Intermetall)",
+        0x6d: "Cannon",
+        0x6e: "Altera",
+        0xef: "NEXCOM",
+        0x70: "QUALCOMM",
+        0xf1: "Sony",
+        0xf2: "Cray Research",
+        0x73: "AMS (Austria Micro)",
+        0xf4: "Vitesse",
+        0x75: "Aster Electronics",
+        0x76: "Bay Networks (Synoptic)",
+        0xf7: "Zentrum",
+        0xf8: "TRW",
+        0x79: "Thesys",
+        0x7a: "Solbourne Computer",
+        0xfb: "Allied-Signal",
+        0x7c: "Dialog",
+        0xfd: "Media Vision",
+        0xfe: "Level One Communication",
+    },
+    {
+        0x01: "Cirrus Logic",
+        0x02: "National Instruments",
+        0x83: "ILC Data Device",
+        0x04: "Alcatel Mietec",
+        0x85: "Micro Linear",
+        0x86: "Univ. of NC",
+        0x07: "JTAG Technologies",
+        0x08: "Loral",
+        0x89: "Nchip",
+        0x8A: "Galileo Tech",
+        0x0B: "Bestlink Systems",
+        0x8C: "Graychip",
+        0x0D: "GENNUM",
+        0x0E: "VideoLogic",
+        0x8F: "Robert Bosch",
+        0x10: "Chip Express",
+        0x91: "DATARAM",
+        0x92: "United Microelec Corp.",
+        0x13: "TCSI",
+        0x94: "Smart Modular",
+        0x15: "Hughes Aircraft",
+        0x16: "Lanstar Semiconductor",
+        0x97: "Qlogic",
+        0x98: "Kingston",
+        0x19: "Music Semi",
+        0x1A: "Ericsson Components",
+        0x9B: "SpaSE",
+        0x1C: "Eon Silicon Devices",
+        0x9D: "Programmable Micro Corp",
+        0x9E: "DoD",
+        0x1F: "Integ. Memories Tech.",
+        0x20: "Corollary Inc.",
+        0xA1: "Dallas Semiconductor",
+        0xA2: "Omnivision",
+        0x23: "EIV(Switzerland)",
+        0xA4: "Novatel Wireless",
+        0x25: "Zarlink (formerly Mitel)",
+        0x26: "Clearpoint",
+        0xA7: "Cabletron",
+        0xA8: "Silicon Technology",
+        0x29: "Vanguard",
+        0x2A: "Hagiwara Sys-Com",
+        0xAB: "Vantis",
+        0x2C: "Celestica",
+        0xAD: "Century",
+        0xAE: "Hal Computers",
+        0x2F: "Rohm Company Ltd.",
+        0xB0: "Juniper Networks",
+        0x31: "Libit Signal Processing",
+        0x32: "Enhanced Memories Inc.",
+        0xB3: "Tundra Semiconductor",
+        0x34: "Adaptec Inc.",
+        0xB5: "LightSpeed Semi.",
+        0xB6: "ZSP Corp.",
+        0x37: "AMIC Technology",
+        0x38: "Adobe Systems",
+        0xB9: "Dynachip",
+        0xBA: "PNY Electronics",
+        0x3B: "Newport Digital",
+        0xBC: "MMC Networks",
+        0x3D: "T Square",
+        0x3E: "Seiko Epson",
+        0xBF: "Broadcom",
+        0x40: "Viking Components",
+        0xC1: "V3 Semiconductor",
+        0xC2: "Flextronics (formerly Orbit)",
+        0x43: "Suwa Electronics",
+        0xC4: "Transmeta",
+        0x45: "Micron CMS",
+        0x46: "American Computer & Digital Components Inc",
+        0xC7: "Enhance 3000 Inc",
+        0xC8: "Tower Semiconductor",
+        0x49: "CPU Design",
+        0x4A: "Price Point",
+        0xCB: "Maxim Integrated Product",
+        0x4C: "Tellabs",
+        0xCD: "Centaur Technology",
+        0xCE: "Unigen Corporation",
+        0x4F: "Transcend Information",
+        0xD0: "Memory Card Technology",
+        0x51: "CKD Corporation Ltd.",
+        0x52: "Capital Instruments, Inc.",
+        0xD3: "Aica Kogyo, Ltd.",
+        0x54: "Linvex Technology",
+        0xD5: "MSC Vertriebs GmbH",
+        0xD6: "AKM Company, Ltd.",
+        0x57: "Dynamem, Inc.",
+        0x58: "NERA ASA",
+        0xD9: "GSI Technology",
+        0xDA: "Dane-Elec (C Memory)",
+        0x5B: "Acorn Computers",
+        0xDC: "Lara Technology",
+        0x5D: "Oak Technology, Inc.",
+        0x5E: "Itec Memory",
+        0xDF: "Tanisys Technology",
+        0xE0: "Truevision",
+        0x61: "Wintec Industries",
+        0x62: "Super PC Memory",
+        0xE3: "MGV Memory",
+        0x64: "Galvantech",
+        0xE5: "Gadzoox Nteworks",
+        0xE6: "Multi Dimensional Cons.",
+        0x67: "GateField",
+        0x68: "Integrated Memory System",
+        0xE9: "Triscend",
+        0xEA: "XaQti",
+        0x6B: "Goldenram",
+        0xEC: "Clear Logic",
+        0x6D: "Cimaron Communications",
+        0x6E: "Nippon Steel Semi. Corp.",
+        0xEF: "Advantage Memory",
+        0x70: "AMCC",
+        0xF1: "LeCroy",
+        0xF2: "Yamaha Corporation",
+        0x73: "Digital Microwave",
+        0xF4: "NetLogic Microsystems",
+        0x75: "MIMOS Semiconductor",
+        0x76: "Advanced Fibre",
+        0xF7: "BF Goodrich Data.",
+        0xF8: "Epigram",
+        0x79: "Acbel Polytech Inc.",
+        0x7A: "Apacer Technology",
+        0xFB: "Admor Memory",
+        0x7C: "FOXCONN",
+        0xFD: "Quadratics Superconductor",
+        0xFE: "3COM",
+    },
+    {
+        0x01: "Camintonn Corporation",
+        0x02: "ISOA Incorporated",
+        0x83: "Agate Semiconductor",
+        0x04: "ADMtek Incorporated",
+        0x85: "HYPERTEC",
+        0x86: "Adhoc Technologies",
+        0x07: "MOSAID Technologies",
+        0x08: "Ardent Technologies",
+        0x89: "Switchcore",
+        0x8A: "Cisco Systems, Inc.",
+        0x0B: "Allayer Technologies",
+        0x8C: "WorkX AG",
+        0x0D: "Oasis Semiconductor",
+        0x0E: "Novanet Semiconductor",
+        0x8F: "E-M Solutions",
+        0x10: "Power General",
+        0x91: "Advanced Hardware Arch.",
+        0x92: "Inova Semiconductors GmbH",
+        0x13: "Telocity",
+        0x94: "Delkin Devices",
+        0x15: "Symagery Microsystems",
+        0x16: "C-Port Corporation",
+        0x97: "SiberCore Technologies",
+        0x98: "Southland Microsystems",
+        0x19: "Malleable Technologies",
+        0x1A: "Kendin Communications",
+        0x9B: "Great Technology Microcomputer",
+        0x1C: "Sanmina Corporation",
+        0x9D: "HADCO Corporation",
+        0x9E: "Corsair",
+        0x1F: "Actrans System Inc.",
+        0x20: "ALPHA Technologies",
+        0xA1: "Cygnal Integrated Products Incorporated",
+        0xA2: "Artesyn Technologies",
+        0x23: "Align Manufacturing",
+        0xA4: "Peregrine Semiconductor",
+        0x25: "Chameleon Systems",
+        0x26: "Aplus Flash Technology",
+        0xA7: "MIPS Technologies",
+        0xA8: "Chrysalis ITS",
+        0x29: "ADTEC Corporation",
+        0x2A: "Kentron Technologies",
+        0xAB: "Win Technologies",
+        0x2C: "ASIC Designs Inc",
+        0xAD: "Extreme Packet Devices",
+        0xAE: "RF Micro Devices",
+        0x2F: "Siemens AG",
+        0xB0: "Sarnoff Corporation",
+        0x31: "Itautec Philco SA",
+        0x32: "Radiata Inc.",
+        0xB3: "Benchmark Elect. (AVEX)",
+        0x34: "Legend",
+        0xB5: "SpecTek Incorporated",
+        0xB6: "Hi/fn",
+        0x37: "Enikia Incorporated",
+        0x38: "SwitchOn Networks",
+        0xB9: "AANetcom Incorporated",
+        0xBA: "Micro Memory Bank",
+        0x3B: "ESS Technology",
+        0xBC: "Virata Corporation",
+        0x3D: "Excess Bandwidth",
+        0x3E: "West Bay Semiconductor",
+        0xBF: "DSP Group",
+        0x40: "Newport Communications",
+        0xC1: "Chip2Chip Incorporated",
+        0xC2: "Phobos Corporation",
+        0x43: "Intellitech Corporation",
+        0xC4: "Nordic VLSI ASA",
+        0x45: "Ishoni Networks",
+        0x46: "Silicon Spice",
+        0xC7: "Alchemy Semiconductor",
+        0xC8: "Agilent Technologies",
+        0x49: "Centillium Communications",
+        0x4A: "W.L. Gore",
+        0xCB: "HanBit Electronics",
+        0x4C: "GlobeSpan",
+        0xCD: "Element 14",
+        0xCE: "Pycon",
+        0x4F: "Saifun Semiconductors",
+        0xD0: "Sibyte, Incorporated",
+        0x51: "MetaLink Technologies",
+        0x52: "Feiya Technology",
+        0xD3: "I & C Technology",
+        0x54: "Shikatronics",
+        0xD5: "Elektrobit",
+        0xD6: "Megic",
+        0x57: "Com-Tier",
+        0x58: "Malaysia Micro Solutions",
+        0xD9: "Hyperchip",
+        0xDA: "Gemstone Communications",
+        0x5B: "Anadyne Microelectronics",
+        0xDC: "3ParData",
+        0x5D: "Mellanox Technologies",
+        0x5E: "Tenx Technologies",
+        0xDF: "Helix AG",
+        0xE0: "Domosys",
+        0x61: "Skyup Technology",
+        0x62: "HiNT Corporation",
+        0xE3: "Chiaro",
+        0x64: "MCI Computer GMBH",
+        0xE5: "Exbit Technology A/S",
+        0xE6: "Integrated Technology Express",
+        0x67: "AVED Memory",
+        0x68: "Legerity",
+        0xE9: "Jasmine Networks",
+        0xEA: "Caspian Networks",
+        0x6B: "nCUBE",
+        0xEC: "Silicon Access Networks",
+        0x6D: "FDK Corporation",
+        0x6E: "High Bandwidth Access",
+        0xEF: "MultiLink Technology",
+        0x70: "BRECIS",
+        0xF1: "World Wide Packets",
+        0xF2: "APW",
+        0x73: "Chicory Systems",
+        0xF4: "Xstream Logic",
+        0x75: "Fast-Chip",
+        0x76: "Zucotto Wireless",
+        0xF7: "Realchip",
+        0xF8: "Galaxy Power",
+        0x79: "eSilicon",
+        0x7A: "Morphics Technology",
+        0xFB: "Accelerant Networks",
+        0x7C: "Silicon Wave",
+        0xFD: "SandCraft",
+        0xFE: "Elpida",
+    },
+    {
+        0x01: "Solectron",
+        0x02: "Optosys Technologies",
+        0x83: "Buffalo (Formerly Melco)",
+        0x04: "TriMedia Technologies",
+        0x85: "Cyan Technologies",
+        0x86: "Global Locate",
+        0x07: "Optillion",
+        0x08: "Terago Communications",
+        0x89: "Ikanos Communications",
+        0x8A: "Princeton Technology",
+        0x0B: "Nanya Technology",
+        0x8C: "Elite Flash Storage",
+        0x0D: "Mysticom",
+        0x0E: "LightSand Communications",
+        0x8F: "ATI Technologies",
+        0x10: "Agere Systems",
+        0x91: "NeoMagic",
+        0x92: "AuroraNetics",
+        0x13: "Golden Empire",
+        0x94: "Muskin",
+        0x15: "Tioga Technologies",
+        0x16: "Netlist",
+        0x97: "TeraLogic",
+        0x98: "Cicada Semiconductor",
+        0x19: "Centon Electronics",
+        0x1A: "Tyco Electronics",
+        0x9B: "Magis Works",
+        0x1C: "Zettacom",
+        0x9D: "Cogency Semiconductor",
+        0x9E: "Chipcon AS",
+        0x1F: "Aspex Technology",
+        0x20: "F5 Networks",
+        0xA1: "Programmable Silicon Solutions",
+        0xA2: "ChipWrights",
+        0x23: "Acorn Networks",
+        0xA4: "Quicklogic",
+        0x25: "Kingmax Semiconductor",
+        0x26: "BOPS",
+        0xA7: "Flasys",
+        0xA8: "BitBlitz Communications",
+        0x29: "eMemory Technology",
+        0x2A: "Procket Networks",
+        0xAB: "Purple Ray",
+        0x2C: "Trebia Networks",
+        0xAD: "Delta Electronics",
+        0xAE: "Onex Communications",
+        0x2F: "Ample Communications",
+        0xB0: "Memory Experts Intl",
+        0x31: "Astute Networks",
+        0x32: "Azanda Network Devices",
+        0xB3: "Dibcom",
+        0x34: "Tekmos",
+        0xB5: "API NetWorks",
+        0xB6: "Bay Microsystems",
+        0x37: "Firecron Ltd",
+        0x38: "Resonext Communications",
+        0xB9: "Tachys Technologies",
+        0xBA: "Equator Technology",
+        0x3B: "Concept Computer",
+        0xBC: "SILCOM",
+        0x3D: "3Dlabs",
+        0x3E: "ct Magazine",
+        0xBF: "Sanera Systems",
+        0x40: "Silicon Packets",
+        0xC1: "Viasystems Group",
+        0xC2: "Simtek",
+        0x43: "Semicon Devices Singapore",
+        0xC4: "Satron Handelsges",
+        0x45: "Improv Systems",
+        0x46: "INDUSYS GmbH",
+        0xC7: "Corrent",
+        0xC8: "Infrant Technologies",
+        0x49: "Ritek Corp",
+        0x4A: "empowerTel Networks",
+        0xCB: "Hypertec",
+        0x4C: "Cavium Networks",
+        0xCD: "PLX Technology",
+        0xCE: "Massana Design",
+        0x4F: "Intrinsity",
+        0xD0: "Valence Semiconductor",
+        0x51: "Terawave Communications",
+        0x52: "IceFyre Semiconductor",
+        0xD3: "Primarion",
+        0x54: "Picochip Designs Ltd",
+        0xD5: "Silverback Systems",
+        0xD6: "Jade Star Technologies",
+        0x57: "Pijnenburg Securealink",
+        0x58: "MemorySolutioN",
+        0xD9: "Cambridge Silicon Radio",
+        0xDA: "Swissbit",
+        0x5B: "Nazomi Communications",
+        0xDC: "eWave System",
+        0x5D: "Rockwell Collins",
+        0x5E: "PAION",
+        0xDF: "Alphamosaic Ltd",
+        0xE0: "Sandburst",
+        0x61: "SiCon Video",
+        0x62: "NanoAmp Solutions",
+        0xE3: "Ericsson Technology",
+        0x64: "PrairieComm",
+        0xE5: "Mitac International",
+        0xE6: "Layer N Networks",
+        0x67: "Atsana Semiconductor",
+        0x68: "Allegro Networks",
+        0xE9: "Marvell Semiconductors",
+        0xEA: "Netergy Microelectronic",
+        0x6B: "NVIDIA",
+        0xEC: "Internet Machines",
+        0x6D: "Peak Electronics",
+        0xEF: "Accton Technology",
+        0x70: "Teradiant Networks",
+        0xF1: "Europe Technologies",
+        0xF2: "Cortina Systems",
+        0x73: "RAM Components",
+        0xF4: "Raqia Networks",
+        0x75: "ClearSpeed",
+        0x76: "Matsushita Battery",
+        0xF7: "Xelerated",
+        0xF8: "SimpleTech",
+        0x79: "Utron Technology",
+        0x7A: "Astec International",
+        0xFB: "AVM gmbH",
+        0x7C: "Redux Communications",
+        0xFD: "Dot Hill Systems",
+        0xFE: "TeraChip",
+    },
+    {
+        0x01: "T-RAM Incorporated",
+        0x02: "Innovics Wireless",
+        0x83: "Teknovus",
+        0x04: "KeyEye Communications",
+        0x85: "Runcom Technologies",
+        0x86: "RedSwitch",
+        0x07: "Dotcast",
+        0x08: "Silicon Mountain Memory",
+        0x89: "Signia Technologies",
+        0x8A: "Pixim",
+        0x0B: "Galazar Networks",
+        0x8C: "White Electronic Designs",
+        0x0D: "Patriot Scientific",
+        0x0E: "Neoaxiom Corporation",
+        0x8F: "3Y Power Technology",
+        0x10: "Europe Technologies",
+        0x91: "Potentia Power Systems",
+        0x92: "C-guys Incorporated",
+        0x13: "Digital Communications Technology Incorporated",
+        0x94: "Silicon-Based Technology",
+        0x15: "Fulcrum Microsystems",
+        0x16: "Positivo Informatica Ltd",
+        0x97: "XIOtech Corporation",
+        0x98: "PortalPlayer",
+        0x19: "Zhiying Software",
+        0x1A: "Direct2Data",
+        0x9B: "Phonex Broadband",
+        0x1C: "Skyworks Solutions",
+        0x9D: "Entropic Communications",
+        0x9E: "Pacific Force Technology",
+        0x1F: "Zensys A/S",
+        0x20: "Legend Silicon Corp.",
+        0xA1: "sci-worx GmbH",
+        0xA2: "Oasis Silicon Systems",
+        0x23: "Renesas Technology",
+        0xA4: "Raza Microelectronics",
+        0x25: "Phyworks",
+        0x26: "MediaTek",
+        0xA7: "Non-cents Productions",
+        0xA8: "US Modular",
+        0x29: "Wintegra Ltd",
+        0x2A: "Mathstar",
+        0xAB: "StarCore",
+        0x2C: "Oplus Technologies",
+        0xAD: "Mindspeed",
+        0xAE: "Just Young Computer",
+        0x2F: "Radia Communications",
+        0xB0: "OCZ",
+        0x31: "Emuzed",
+        0x32: "LOGIC Devices",
+        0xB3: "Inphi Corporation",
+        0x34: "Quake Technologies",
+        0xB5: "Vixel",
+        0xB6: "SolusTek",
+        0x37: "Kongsberg Maritime",
+        0x38: "Faraday Technology",
+        0xB9: "Altium Ltd.",
+        0xBA: "Insyte",
+        0x3B: "ARM Ltd.",
+        0xBC: "DigiVision",
+        0x3D: "Vativ Technologies",
+        0x3E: "Endicott Interconnect Technologies",
+        0xBF: "Pericom",
+        0x40: "Bandspeed",
+        0xC1: "LeWiz Communications",
+        0xC2: "CPU Technology",
+        0x43: "Ramaxel Technology",
+        0xC4: "DSP Group",
+        0x45: "Axis Communications",
+        0x46: "Legacy Electronics",
+        0xC7: "Chrontel",
+        0xC8: "Powerchip Semiconductor",
+        0x49: "MobilEye Technologies",
+        0x4A: "Excel Semiconductor",
+        0xCB: "A-DATA Technology",
+        0x4C: "VirtualDigm",
+    },
+]
+
+memory_types = {
+    1: "STD FPM DRAM",
+    2: "EDO",
+    3: "Pipelined Nibble",
+    4: "SDRAM",
+    5: "ROM",
+    6: "DDR SGRAM",
+    7: "DDR SDRAM",
+    8: "DDR2 SDRAM",
+    9: "DDR2 SDRAM FB-DIMM",
+    10: "DDR2 SDRAM FB-DIMM PROBE",
+    11: "DDR3 SDRAM",
+    12: "DDR4 SDRAM",
+    0x12: "DDR5 SDRAM",
+}
+
+module_types = {
+    1: "RDIMM",
+    2: "UDIMM",
+    3: "SODIMM",
+    4: "Micro-DIMM",
+    5: "Mini-RDIMM",
+    6: "Mini-UDIMM",
+}
+
+ddr3_module_capacity = {
+    0: 256,
+    1: 512,
+    2: 1024,
+    3: 2048,
+    4: 4096,
+    5: 8192,
+    6: 16384,
+    7: 32768,
+}
+
+ddr3_dev_width = {
+    0: 4,
+    1: 8,
+    2: 16,
+    3: 32,
+}
+
+ddr3_ranks = {
+    0: 1,
+    1: 2,
+    2: 3,
+    3: 4
+}
+
+ddr3_bus_width = {
+    0: 8,
+    1: 16,
+    2: 32,
+    3: 64,
+}
+
+
+def speed_from_clock(clock):
+    return int(clock * 8 - (clock * 8 % 100))
+
+
+def decode_manufacturer(index, mfg):
+    index &= 0x7f
+    try:
+        return jedec_ids[index][mfg]
+    except (KeyError, IndexError):
+        return 'Unknown ({0}, {1})'.format(index, mfg)
+
+
+def decode_spd_date(year, week):
+    if year == 0 and week == 0:
+        return 'Unknown'
+    return '20{0:02x}-W{1:x}'.format(year, week)
+
+
+class SPD(object):
+    def __init__(self, bytedata):
+        """Parsed memory information
+
+        Parse bytedata input and provide a structured detail about the
+        described memory component
+
+        :param bytedata: A bytearray of data to decode
+        :return:
+        """
+        self.rawdata = bytearray(bytedata)
+        spd = self.rawdata
+        self.info = {'memory_type': memory_types.get(spd[2], 'Unknown')}
+        if spd[2] == 11:
+            self._decode_ddr3()
+        elif spd[2] == 12:
+            self._decode_ddr4()
+        elif spd[2] == 0x12: # ddr5
+            self._decode_ddr5()
+
+    def _decode_ddr3(self):
+        spd = self.rawdata
+        finetime = (spd[9] >> 4) / (spd[9] & 0xf)
+        fineoffset = spd[34]
+        if fineoffset & 0b10000000:
+            # Take two's complement for negative offset
+            fineoffset = 0 - ((fineoffset ^ 0xff) + 1)
+        fineoffset = (finetime * fineoffset) * 10 ** -3
+        mtb = spd[10] / float(spd[11])
+        clock = math.floor(2 / ((mtb * spd[12] + fineoffset) * 10 ** -3))
+        self.info['speed'] = speed_from_clock(clock)
+        self.info['ecc'] = (spd[8] & 0b11000) != 0
+        self.info['module_type'] = module_types.get(spd[3] & 0xf, 'Unknown')
+        sdramcap = ddr3_module_capacity[spd[4] & 0xf]
+        buswidth = ddr3_bus_width[spd[8] & 0b111]
+        sdramwidth = ddr3_dev_width[spd[7] & 0b111]
+        ranks = ddr3_ranks[(spd[7] & 0b111000) >> 3]
+        self.info['capacity_mb'] = sdramcap / 8 * buswidth / sdramwidth * ranks
+        self.info['manufacturer'] = decode_manufacturer(spd[117], spd[118])
+        self.info['manufacture_location'] = spd[119]
+        self.info['manufacture_date'] = decode_spd_date(spd[120], spd[121])
+        self.info['serial'] = hex(struct.unpack(
+            '>I', struct.pack('4B', *spd[122:126]))[0])[2:].rjust(8, '0')
+        self.info['model'] = struct.pack('20B', *spd[128:148]).strip(
+            b'\x00\xff ')
+
+    def _decode_ddr5(self):
+        spd = self.rawdata
+        modtypes = {
+            1: 'RDIMM',
+            2: 'UDIMM',
+            3: 'SODIMM',
+        }
+        sdramdensities = {
+            1: 4,
+            2: 8,
+            3: 12,
+            4: 16,
+            5: 24,
+            6: 32,
+            7: 48,
+            8: 64,
+        }
+        ddp = {
+            0: 1,
+            1: 2,
+            2: 2,
+            3: 4,
+            4: 8,
+            6: 16,
+        }
+        self.info['module_type'] = modtypes.get(
+            spd[3], 'Unknown')
+        self.info['manufacturer'] = decode_manufacturer(spd[512], spd[513])
+        self.info['model'] = struct.pack('30B', *spd[521:551]).strip(
+            b'\x00\xff ')
+        self.info['serial'] = hex(struct.unpack(
+            '>I', struct.pack('4B', *spd[517:521]))[0])[2:].rjust(8, '0')
+        self.info['manufacture_date'] = decode_spd_date(spd[515], spd[516])
+        self.info['manufacture_location'] = spd[514]
+        self.info['ecc'] = (spd[235] & 0b11000) != 0
+        if spd[19] == 0:
+            tckmin = struct.unpack('<H', spd[20:22])[0]
+            self.info['speed'] = math.floor(160000.0 / tckmin) * 100
+        else:
+            self.info['speed'] = 'Unknown'
+        asymmetric = bool(spd[234] & 64)
+        numrankspersubchannel = ((spd[234] & 56) >> 3) + 1
+        subchannels = ((spd[235] & 0b01100000) >> 5) + 1
+        buswidthpersubchannel = 2 ** ((spd[235] & 0b111) + 3)
+        # these bits are either all, or for half the ranks in asymettric
+        densityperdie = spd[4]
+        sdramiowidth = 2**((spd[6] >> 5) + 2)
+        densityperdie = sdramdensities.get(spd[4] & 0b11111, 0)
+        diesperpackage = ddp.get(spd[4] >> 5, 1)
+        capacity = (subchannels
+                    * (buswidthpersubchannel / sdramiowidth)
+                    * diesperpackage * densityperdie / 8
+                    * numrankspersubchannel)
+        if asymmetric:
+            capacity = capacity // 2 # the calculation is halved to make room for the odd ranks
+            densityperdie = spd[8]
+            sdramiowidth = 2**((spd[10] >> 5) + 2)
+            densityperdie = sdramdensities.get(spd[8] & 0b11111, 0)
+            diesperpackage = ddp.get(spd[8] >> 5, 1)
+            oddcapacity = (subchannels
+                           * (buswidthpersubchannel / sdramiowidth)
+                           * diesperpackage * densityperdie / 8
+                           * numrankspersubchannel)
+            oddcapacity = oddcapacity // 2  # this is halved, since this is only half the ranks
+            capacity += oddcapacity
+        self.info['capacity_mb'] = capacity * 1024
+
+    def _decode_ddr4(self):
+        spd = self.rawdata
+        if spd[17] == 0:
+            fineoffset = spd[125]
+            if fineoffset & 0b10000000:
+                fineoffset = 0 - ((fineoffset ^ 0xff) + 1)
+            clock = math.floor(
+                2 / ((0.125 * spd[18] + fineoffset * 0.001) * 0.001))
+            self.info['speed'] = speed_from_clock(clock)
+        else:
+            self.info['speed'] = 'Unknown'
+        self.info['ecc'] = (spd[13] & 0b11000) == 0b1000
+        self.info['module_type'] = module_types.get(spd[3] & 0xf,
+                                                    'Unknown')
+        sdramcap = ddr3_module_capacity[spd[4] & 0xf]
+        buswidth = ddr3_bus_width[spd[13] & 0b111]
+        sdramwidth = ddr3_dev_width[spd[12] & 0b111]
+        ranks = ddr3_ranks[(spd[12] & 0b111000) >> 3]
+        if spd[6] & 0b11 == 0b10:
+            ranks = ranks * (((spd[6] >> 4) & 0b111) + 1)
+        self.info['capacity_mb'] = sdramcap / 8 * buswidth / sdramwidth * ranks
+        self.info['manufacturer'] = decode_manufacturer(spd[320], spd[321])
+        self.info['manufacture_location'] = spd[322]
+        self.info['manufacture_date'] = decode_spd_date(spd[323], spd[324])
+        self.info['serial'] = hex(struct.unpack(
+            '>I', struct.pack('4B', *spd[325:329]))[0])[2:].rjust(8, '0')
+        self.info['model'] = struct.pack('20B', *spd[329:349]).strip(
+            b'\x00\xff ')
diff --git a/confluent_server/aiohmi/ipmi/private/util.py b/confluent_server/aiohmi/ipmi/private/util.py
new file mode 100644
index 00000000..782b1195
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/private/util.py
@@ -0,0 +1,134 @@
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import ctypes
+import functools
+import os
+import socket
+import struct
+
+from aiohmi.ipmi.private import constants
+
+try:
+    range = xrange
+except NameError:
+    pass
+try:
+    buffer
+except NameError:
+    buffer = memoryview
+
+
+wintime = None
+try:
+    wintime = ctypes.windll.kernel32.GetTickCount64
+except AttributeError:
+    pass
+
+
+def decode_wireformat_uuid(rawguid, bigendian=False):
+    """Decode a wire format UUID
+
+    It handles the rather particular scheme where half is little endian
+    and half is big endian.  It returns a string like dmidecode would output.
+    """
+    if isinstance(rawguid, list):
+        rawguid = bytearray(rawguid)
+    endian = '<IHH'  # little endian
+    if bigendian:
+        endian = '>IHH'  # big endian
+    lebytes = struct.unpack_from(endian, buffer(rawguid[:8]))
+    bebytes = struct.unpack_from('>HHI', buffer(rawguid[8:]))
+    return '{0:08X}-{1:04X}-{2:04X}-{3:04X}-{4:04X}{5:08X}'.format(
+        lebytes[0], lebytes[1], lebytes[2], bebytes[0], bebytes[1], bebytes[2])
+
+
+def urlsplit(url):
+    """Split an arbitrary url into protocol, host, rest
+
+    The standard urlsplit does not want to provide 'netloc' for arbitrary
+    protocols, this works around that.
+
+    :param url: The url to split into component parts
+    """
+    proto, rest = url.split(':', 1)
+    host = ''
+    if rest[:2] == '//':
+        host, rest = rest[2:].split('/', 1)
+        rest = '/' + rest
+    return proto, host, rest
+
+
+def get_ipv4(hostname):
+    """Get list of ipv4 addresses for hostname
+
+    """
+    addrinfo = socket.getaddrinfo(hostname, None, socket.AF_INET,
+                                  socket.SOCK_STREAM)
+    return [addrinfo[x][4][0] for x in range(len(addrinfo))]
+
+
+def get_ipmi_error(response, suffix=""):
+    if 'error' in response:
+        return response['error'] + suffix
+    code = response['code']
+    if code == 0:
+        return False
+    command = response['command']
+    netfn = response['netfn']
+    if ((netfn, command) in constants.command_completion_codes
+            and code in constants.command_completion_codes[(netfn, command)]):
+        res = constants.command_completion_codes[(netfn, command)][code]
+        res += suffix
+    elif code in constants.ipmi_completion_codes:
+        res = constants.ipmi_completion_codes[code] + suffix
+    else:
+        res = "Unknown code 0x%2x encountered" % code
+    return res
+
+
+def _monotonic_time():
+    """Provides a monotonic timer
+
+    This code is concerned with relative, not absolute time.
+    This function facilitates that prior to python 3.3
+    """
+    # Python does not provide one until 3.3, so we make do
+    # for most OSes, os.times()[4] works well.
+    # for microsoft, GetTickCount64
+    if wintime:
+        return wintime() / 1000.0
+    return os.times()[4]
+
+
+class protect(object):
+
+    def __init__(self, lock):
+        self.lock = lock
+
+    def __call__(self, func):
+        @functools.wraps(func)
+        def _wrapper(*args, **kwargs):
+            self.lock.acquire()
+            try:
+                return func(*args, **kwargs)
+            finally:
+                self.lock.release()
+        return _wrapper
+
+    def __enter__(self):
+        self.lock.acquire()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.lock.release()
diff --git a/confluent_server/aiohmi/ipmi/sdr.py b/confluent_server/aiohmi/ipmi/sdr.py
new file mode 100644
index 00000000..d2855525
--- /dev/null
+++ b/confluent_server/aiohmi/ipmi/sdr.py
@@ -0,0 +1,863 @@
+# coding=utf8
+# Copyright 2014 IBM Corporation
+# Copyright 2015 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This module provides access to SDR offered by a BMC
+
+This data is common between 'sensors' and 'inventory' modules since SDR
+is both used to enumerate sensors for sensor commands and FRU ids for FRU
+commands
+
+For now, we will not offer persistent SDR caching as we do in xCAT's IPMI
+code.  Will see if it is adequate to advocate for high object reuse in a
+persistent process for the moment.
+
+Focus is at least initially on the aspects that make the most sense for a
+remote client to care about.  For example, smbus information is being
+skipped for now
+"""
+
+import math
+import os
+import random
+import string
+import struct
+import weakref
+
+
+import aiohmi.constants as const
+import aiohmi.exceptions as exc
+
+
+TYPE_UNKNOWN = 0
+TYPE_SENSOR = 1
+TYPE_FRU = 2
+
+shared_sdrs = {}
+
+
+oem_type_offsets = {
+    343: {  # Intel
+        149: {  # Cascade Lake-AP
+            0x7a: {
+                0xda: {
+                    3: {
+                        'desc': 'Allowed',
+                        'severity': const.Health.Ok,
+                    },
+                    4: {
+                        'desc': 'Restricted',
+                        'severity': const.Health.Ok,
+                    },
+                    5: {
+                        'desc': 'Disabled',
+                        'severity': const.Health.Ok,
+                    },
+                },
+            },
+        },
+    },
+}
+
+
+def ones_complement(value, bits):
+    # utility function to help with the large amount of 2s
+    # complement prevalent in ipmi spec
+    signbit = 0b1 << (bits - 1)
+    if value & signbit:
+        # if negative, subtract 1, then take 1s
+        # complement given bits width
+        return 0 - (value ^ ((0b1 << bits) - 1))
+    else:
+        return value
+
+
+def twos_complement(value, bits):
+    # utility function to help with the large amount of 2s
+    # complement prevalent in ipmi spec
+    signbit = 0b1 << (bits - 1)
+    if value & signbit:
+        # if negative, subtract 1, then take 1s
+        # complement given bits width
+        return 0 - ((value - 1) ^ ((0b1 << bits) - 1))
+    else:
+        return value
+
+
+unit_types = {
+    # table 43-15 'sensor unit type codes'
+    0: '',
+    1: '°C',
+    2: '°F',
+    3: 'K',
+    4: 'V',
+    5: 'A',
+    6: 'W',
+    7: 'J',
+    8: 'C',
+    9: 'VA',
+    10: 'nt',
+    11: 'lm',
+    12: 'lx',
+    13: 'cd',
+    14: 'kPa',
+    15: 'PSI',
+    16: 'N',
+    17: 'CFM',
+    18: 'RPM',
+    19: 'Hz',
+    20: 'μs',
+    21: 'ms',
+    22: 's',
+    23: 'min',
+    24: 'hr',
+    25: 'd',
+    26: 'week(s)',
+    27: 'mil',
+    28: 'inches',
+    29: 'ft',
+    30: 'cu in',
+    31: 'cu feet',
+    32: 'mm',
+    33: 'cm',
+    34: 'm',
+    35: 'cu cm',
+    36: 'cu m',
+    37: 'L',
+    38: 'fl. oz.',
+    39: 'radians',
+    40: 'steradians',
+    41: 'revolutions',
+    42: 'cycles',
+    43: 'g',
+    44: 'ounce',
+    45: 'lb',
+    46: 'ft-lb',
+    47: 'oz-in',
+    48: 'gauss',
+    49: 'gilberts',
+    50: 'henry',
+    51: 'millihenry',
+    52: 'farad',
+    53: 'microfarad',
+    54: 'ohms',
+    55: 'siemens',
+    56: 'mole',
+    57: 'becquerel',
+    58: 'ppm',
+    60: 'dB',
+    61: 'dBA',
+    62: 'dBC',
+    63: 'Gy',
+    64: 'sievert',
+    65: 'color temp deg K',
+    66: 'bit',
+    67: 'kb',
+    68: 'mb',
+    69: 'gb',
+    70: 'byte',
+    71: 'kB',
+    72: 'mB',
+    73: 'gB',
+    74: 'word',
+    75: 'dword',
+    76: 'qword',
+    77: 'line',
+    78: 'hit',
+    79: 'miss',
+    80: 'retry',
+    81: 'reset',
+    82: 'overrun/overflow',
+    83: 'underrun',
+    84: 'collision',
+    85: 'packets',
+    86: 'messages',
+    87: 'characters',
+    88: 'error',
+    89: 'uncorrectable error',
+    90: 'correctable error',
+    91: 'fatal error',
+    92: 'grams',
+}
+
+sensor_rates = {
+    0: '',
+    1: ' per us',
+    2: ' per ms',
+    3: ' per s',
+    4: ' per minute',
+    5: ' per hour',
+    6: ' per day',
+}
+
+
+class SensorReading(object):
+    """Representation of the state of a sensor.
+
+    It is initialized by aiohmi internally, it does not make sense for
+    a developer to create one of these objects directly.
+
+    It provides the following properties:
+    name: UTF-8 string describing the sensor
+    units: UTF-8 string describing the units of the sensor (if numeric)
+    value: Value of the sensor if numeric
+    imprecision: The amount by which the actual measured value may deviate from
+        'value' due to limitations in the resolution of the given sensor.
+    """
+
+    def __init__(self, reading, suffix):
+        self.broken_sensor_ids = {}
+        self.health = const.Health.Ok
+        self.type = reading['type']
+        self.value = None
+        self.imprecision = None
+        self.states = []
+        self.state_ids = []
+        self.unavailable = 0
+        try:
+            self.health = reading['health']
+            self.states = reading['states']
+            self.state_ids = reading['state_ids']
+            self.value = reading['value']
+            self.imprecision = reading['imprecision']
+        except KeyError:
+            pass
+        if 'unavailable' in reading:
+            self.unavailable = 1
+        self.units = suffix
+        self.name = reading['name']
+
+    def __repr__(self):
+        return repr({
+            'value': self.value,
+            'states': self.states,
+            'state_ids': self.state_ids,
+            'units': self.units,
+            'imprecision': self.imprecision,
+            'name': self.name,
+            'type': self.type,
+            'unavailable': self.unavailable,
+            'health': self.health
+        })
+
+    def simplestring(self):
+        """Return a summary string of the reading.
+
+        This is intended as a sampling of how the data could be presented by
+        a UI.  It's intended to help a developer understand the relation
+        between the attributes of a sensor reading if it is not quite clear
+        """
+        repr = self.name + ": "
+        if self.value is not None:
+            repr += str(self.value)
+            repr += " ± " + str(self.imprecision)
+            repr += self.units
+        for state in self.states:
+            repr += state + ","
+        if self.health >= const.Health.Failed:
+            repr += '(Failed)'
+        elif self.health >= const.Health.Critical:
+            repr += '(Critical)'
+        elif self.health >= const.Health.Warning:
+            repr += '(Warning)'
+        return repr
+
+
+class SDREntry(object):
+    """Represent a single entry in the IPMI SDR.
+
+    This is created and consumed by aiohmi internally, there is no reason for
+    external code to pay attention to this class.
+    """
+
+    def __init__(self, entrybytes, event_consts, reportunsupported=False,
+                 mfg_id=0, prod_id=0):
+        self.mfg_id = mfg_id
+        self.prod_id = prod_id
+        self.event_consts = event_consts
+        # ignore record id for now, we only care about the sensor number for
+        # moment
+        self.readable = True
+        self.reportunsupported = reportunsupported
+        if entrybytes[2] != 0x51:
+            # only recognize '1.5', the only version defined at time of writing
+            raise NotImplementedError
+        self.rectype = entrybytes[3]
+        self.linearization = None
+        # most important to get going are 1, 2, and 11
+        self.sdrtype = TYPE_SENSOR  # assume a sensor
+        if self.rectype == 1:  # full sdr
+            self.full_decode(entrybytes[5:])
+        elif self.rectype == 2:  # full sdr
+            self.compact_decode(entrybytes[5:])
+        elif self.rectype == 3:  # event only
+            self.eventonly_decode(entrybytes[5:])
+        elif self.rectype == 8:  # entity association
+            self.association_decode(entrybytes[5:])
+        elif self.rectype == 0x11:  # FRU locator
+            self.fru_decode(entrybytes[5:])
+        elif self.rectype == 0x12:  # Management controller
+            self.mclocate_decode(entrybytes[5:])
+        elif self.rectype == 0xc0:  # OEM format
+            self.sdrtype = TYPE_UNKNOWN   # assume undefined
+            self.oem_decode(entrybytes[5:])
+        elif self.reportunsupported:
+            raise NotImplementedError
+        else:
+            self.sdrtype = TYPE_UNKNOWN
+
+    @property
+    def name(self):
+        if self.sdrtype == TYPE_SENSOR:
+            return self.sensor_name
+        elif self.sdrtype == TYPE_FRU:
+            return self.fru_name
+        else:
+            return "UNKNOWN"
+
+    def oem_decode(self, entry):
+        mfgid = entry[0] + (entry[1] << 8) + (entry[2] << 16)
+        if self.reportunsupported:
+            raise NotImplementedError("No support for mfgid %X" % mfgid)
+
+    def mclocate_decode(self, entry):
+        # For now, we don't have use for MC locator records
+        # we'll ignore them at the moment
+        self.sdrtype = TYPE_UNKNOWN
+        pass
+
+    def fru_decode(self, entry):
+        # table 43-7 FRU Device Locator
+        self.sdrtype = TYPE_FRU
+        self.fru_name = self.tlv_decode(entry[10], entry[11:])
+        self.fru_number = entry[1]
+        self.fru_logical = (entry[2] & 0b10000000) == 0b10000000
+        # 0x8  to 0x10..  0 unspecified except on 0x10, 1 is dimm
+        self.fru_type_and_modifier = (entry[5] << 8) + entry[6]
+
+    def association_decode(self, entry):
+        # table 43-4 Entity Associaition Record
+        # TODO(jbjohnso): actually represent this data
+        self.sdrtype = TYPE_UNKNOWN
+
+    def eventonly_decode(self, entry):
+        # table 43-3 event_only sensor record
+        self._common_decode(entry)
+        self.sensor_name = self.tlv_decode(entry[11], entry[12:])
+        self.readable = False
+
+    def compact_decode(self, entry):
+        # table 43-2 compact sensor record
+        self._common_decode(entry)
+        self.sensor_name = self.tlv_decode(entry[26], entry[27:])
+
+    def assert_trap_value(self, offset):
+        trapval = (self.sensor_type_number << 16) + (self.reading_type << 8)
+        return trapval + offset
+
+    def _common_decode(self, entry):
+        # event only, compact and full are very similar
+        # this function handles the common aspects of compact and full
+        # offsets from spec, minus 6
+        self.has_thresholds = False
+        self.sensor_owner = entry[0]
+        self.sensor_lun = entry[1] & 0x03
+        self.sensor_number = entry[2]
+        self.entity = self.event_consts.entity_ids.get(
+            entry[3], 'Unknown entity {0}'.format(entry[3]))
+        if self.rectype == 3:
+            self.sensor_type_number = entry[5]
+            self.reading_type = entry[6]  # table 42-1
+        else:
+            self.sensor_type_number = entry[7]
+            self.reading_type = entry[8]  # table 42-1
+        if self.rectype == 1 and entry[6] & 0b00001100:
+            self.has_thresholds = True
+        try:
+            self.sensor_type = self.event_consts.sensor_type_codes[
+                self.sensor_type_number]
+        except KeyError:
+            self.sensor_type = "UNKNOWN type " + str(self.sensor_type_number)
+        if self.rectype == 3:
+            return
+        # 0: unspecified
+        # 1: generic threshold based
+        # 0x6f: discrete sensor-specific from table 42-3, sensor offsets
+        # all others per table 42-2, generic discrete
+        # numeric format is one of:
+        # 0 - unsigned, 1 - 1s complement, 2 - 2s complement, 3 - ignore number
+        # compact records are supposed to always write it as '3', presumably
+        # to allow for the concept of a compact record with a numeric format
+        # even though numerics are not allowed today.  Some implementations
+        # violate the spec and do something other than 3 today.  Tolerate
+        # the violation under the assumption that things are not so hard up
+        # that there will ever be a need for compact sensors supporting numeric
+        # values
+        if self.rectype == 2:
+            self.numeric_format = 3
+        else:
+            self.numeric_format = (entry[15] & 0b11000000) >> 6
+        self.sensor_rate = sensor_rates[(entry[15] & 0b111000) >> 3]
+        self.unit_mod = ""
+        if (entry[15] & 0b110) == 0b10:  # unit1 by unit2
+            self.unit_mod = "/"
+        elif (entry[15] & 0b110) == 0b100:
+            # combine the units by multiplying, SI nomenclature is either spac
+            # or hyphen, so go with space
+            self.unit_mod = " "
+        self.percent = ''
+        if entry[15] & 1 == 1:
+            self.percent = '% '
+        if self.sensor_type_number == 0xb:
+            if self.unit_mod == '':
+                if entry[16] == 6:
+                    self.sensor_type = 'Power'
+            elif self.unit_mod == ' ':
+                if entry[16] == 6 and entry[17] in (22, 23, 24):
+                    self.sensor_type = 'Energy'
+        self.baseunit = unit_types[entry[16]]
+        self.modunit = unit_types[entry[17]]
+        self.unit_suffix = self.percent + self.baseunit + self.unit_mod + \
+            self.modunit
+
+    def full_decode(self, entry):
+        # offsets are table from spec, minus 6
+        # TODO(jbjohnso): table 43-13, put in constants to interpret entry[3]
+        self._common_decode(entry)
+        # now must extract the formula data to transform values
+        # entry[18 to entry[24].
+        # if not linear, must use get sensor reading factors
+        # TODO(jbjohnso): the various other values
+        self.sensor_name = self.tlv_decode(entry[42], entry[43:])
+        self.linearization = entry[18] & 0b1111111
+        if self.linearization <= 11:
+            # the enumuration of linear sensors goes to 11,
+            # static formula parameters are applicable, decode them
+            # if 0x70, then the sesor reading will have to get the
+            # factors on the fly.
+            # the formula could apply if we bother with nominal
+            # reading interpretation
+            self.decode_formula(entry[19:25])
+
+    def _decode_state(self, state):
+        mapping = self.event_consts.generic_type_offsets
+        try:
+            if self.reading_type in mapping:
+                desc = mapping[self.reading_type][state]['desc']
+                health = mapping[self.reading_type][state]['severity']
+            elif self.reading_type == 0x6f:
+                mapping = self.event_consts.sensor_type_offsets
+                desc = mapping[self.sensor_type_number][state]['desc']
+                health = mapping[self.sensor_type_number][state]['severity']
+            elif self.reading_type >= 0x70 and self.reading_type <= 0x7f:
+                sensedata = oem_type_offsets[self.mfg_id][self.prod_id][
+                    self.reading_type][self.sensor_type_number][state]
+                desc = sensedata['desc']
+                health = sensedata['severity']
+            else:
+                desc = "Unknown state %d" % state
+                health = const.Health.Ok
+        except KeyError:
+            desc = "Unknown state %d for reading type %d/sensor type %d" % (
+                state, self.reading_type, self.sensor_type_number)
+            health = const.Health.Ok
+        return desc, health
+
+    def decode_sensor_reading(self, ipmicmd, reading):
+        numeric = None
+        output = {
+            'name': self.sensor_name,
+            'type': self.sensor_type,
+            'id': self.sensor_number,
+        }
+        if reading[1] & 0b100000 or not reading[1] & 0b1000000:
+            output['unavailable'] = 1
+            return SensorReading(output, self.unit_suffix)
+        if self.numeric_format == 2:
+            numeric = twos_complement(reading[0], 8)
+        elif self.numeric_format == 1:
+            numeric = ones_complement(reading[0], 8)
+        elif self.numeric_format == 0 and (self.has_thresholds or self.reading_type == 1):
+            numeric = reading[0]
+        discrete = True
+        if numeric is not None:
+            lowerbound = numeric - (0.5 + (self.tolerance / 2.0))
+            upperbound = numeric + (0.5 + (self.tolerance / 2.0))
+            lowerbound = self.decode_value(ipmicmd, lowerbound)
+            upperbound = self.decode_value(ipmicmd, upperbound)
+            output['value'] = (lowerbound + upperbound) / 2.0
+            output['imprecision'] = output['value'] - lowerbound
+            discrete = False
+        upper = 'upper'
+        lower = 'lower'
+        if self.linearization == 7:
+            # if the formula is 1/x, then the intuitive sense of upper and
+            # lower are backwards
+            upper = 'lower'
+            lower = 'upper'
+        output['states'] = []
+        output['state_ids'] = []
+        output['health'] = const.Health.Ok
+        if discrete:
+            for state in range(8):
+                if reading[2] & (0b1 << state):
+                    statedesc, health = self._decode_state(state)
+                    output['health'] |= health
+                    output['states'].append(statedesc)
+                    output['state_ids'].append(self.assert_trap_value(state))
+            if len(reading) > 3:
+                for state in range(7):
+                    if reading[3] & (0b1 << state):
+                        statedesc, health = self._decode_state(state + 8)
+                        output['health'] |= health
+                        output['states'].append(statedesc)
+                        output['state_ids'].append(
+                            self.assert_trap_value(state + 8))
+        else:
+            if reading[2] & 0b1:
+                output['health'] |= const.Health.Warning
+                output['states'].append(lower + " non-critical threshold")
+                output['state_ids'].append(self.assert_trap_value(1))
+            if reading[2] & 0b10:
+                output['health'] |= const.Health.Critical
+                output['states'].append(lower + " critical threshold")
+                output['state_ids'].append(self.assert_trap_value(2))
+            if reading[2] & 0b100:
+                output['health'] |= const.Health.Failed
+                output['states'].append(lower + " non-recoverable threshold")
+                output['state_ids'].append(self.assert_trap_value(3))
+            if reading[2] & 0b1000:
+                output['health'] |= const.Health.Warning
+                output['states'].append(upper + " non-critical threshold")
+                output['state_ids'].append(self.assert_trap_value(4))
+            if reading[2] & 0b10000:
+                output['health'] |= const.Health.Critical
+                output['states'].append(upper + " critical threshold")
+                output['state_ids'].append(self.assert_trap_value(5))
+            if reading[2] & 0b100000:
+                output['health'] |= const.Health.Failed
+                output['states'].append(upper + " non-recoverable threshold")
+                output['state_ids'].append(self.assert_trap_value(6))
+        return SensorReading(output, self.unit_suffix)
+
+    def _set_tmp_formula(self, ipmicmd, value):
+        rsp = ipmicmd.raw_command(netfn=4, command=0x23,
+                                  data=(self.sensor_number, value))
+        # skip next reading field, not used in on-demand situation
+        self.decode_formula(rsp['data'][1:])
+
+    def decode_value(self, ipmicmd, value):
+        # Take the input value and return meaningful value
+        linearization = self.linearization
+        if linearization > 11:  # direct calling code to get factors
+            # for now, we will get the factors on demand
+            # the facility is engineered such that at construction
+            # time the entire BMC table should be fetchable in a reasonable
+            # fashion.  However for now opt for retrieving rows as needed
+            # rather than tracking all that information for a relatively
+            # rare behavior
+            self._set_tmp_formula(ipmicmd, value)
+            linearization = 0
+        # time to compute the pre-linearization value.
+        decoded = float((value * self.m + self.b)
+                        * (10 ** self.resultexponent))
+        if linearization == 0:
+            return decoded
+        elif linearization == 1:
+            return math.log(decoded)
+        elif linearization == 2:
+            return math.log(decoded, 10)
+        elif linearization == 3:
+            return math.log(decoded, 2)
+        elif linearization == 4:
+            return math.exp(decoded)
+        elif linearization == 5:
+            return 10 ** decoded
+        elif linearization == 6:
+            return 2 ** decoded
+        elif linearization == 7:
+            return 1 / decoded
+        elif linearization == 8:
+            return decoded ** 2
+        elif linearization == 9:
+            return decoded ** 3
+        elif linearization == 10:
+            return math.sqrt(decoded)
+        elif linearization == 11:
+            return decoded ** (1.0 / 3)
+        else:
+            raise NotImplementedError
+
+    def decode_formula(self, entry):
+        self.m = twos_complement(entry[0] + ((entry[1] & 0b11000000) << 2), 10)
+        self.tolerance = entry[1] & 0b111111
+        self.b = twos_complement(entry[2] + ((entry[3] & 0b11000000) << 2), 10)
+        self.accuracy = (entry[3] & 0b111111) + (entry[4] & 0b11110000) << 2
+        self.accuracyexp = (entry[4] & 0b1100) >> 2
+        self.direction = entry[4] & 0b11
+        # 0 = n/a, 1 = input, 2 = output
+        self.resultexponent = twos_complement((entry[5] & 0b11110000) >> 4, 4)
+        bexponent = twos_complement(entry[5] & 0b1111, 4)
+        # might as well do the math to 'b' now rather than wait for later
+        self.b = self.b * (10**bexponent)
+
+    def tlv_decode(self, tlv, data):
+        # Per IPMI 'type/length byte format
+        ipmitype = (tlv & 0b11000000) >> 6
+        if not len(data):
+            return ""
+        if ipmitype == 0:  # Unicode per 43.15 in ipmi 2.0 spec
+            # the spec is not specific about encoding, assuming utf8
+            return struct.pack("%dB" % len(data), *data).decode("utf-8")
+        elif ipmitype == 1:  # BCD '+'
+            tmpl = "%02X" * len(data)
+            tstr = tmpl % tuple(data)
+            tstr = tstr.replace("A", " ").replace("B", "-").replace("C", ".")
+            return tstr.replace("D", ":").replace("E", ",").replace("F", "_")
+        elif ipmitype == 2:  # 6 bit ascii, start at 0x20
+            # the ordering is very peculiar and is best understood from
+            # IPMI SPEC "6-bit packed ascii example
+            tstr = ""
+            while len(data) >= 3:  # the packing only works with 3 byte chunks
+                tstr += chr((data[0] & 0b111111) + 0x20)
+                tstr += chr(((data[1] & 0b1111) << 2) + (data[0] >> 6) + 0x20)
+                tstr += chr(((data[2] & 0b11) << 4) + (data[1] >> 4) + 0x20)
+                tstr += chr((data[2] >> 2) + 0x20)
+            if not isinstance(tstr, str):
+                tstr = tstr.decode('utf-8')
+            return tstr
+        elif ipmitype == 3:  # ACSII+LATIN1
+            ret = struct.pack("%dB" % len(data), *data)
+            if not isinstance(ret, str):
+                ret = ret.decode('utf-8')
+            return ret
+
+
+class SDR(object):
+    """Examine the state of sensors managed by a BMC
+
+    Presents the data from sensor read commands as directed by the SDR in a
+    reasonable format.  This module is used by the command module, and is not
+    intended for consumption by external code directly
+
+    :param ipmicmd: A Command class object
+    """
+    def __init__(self, ipmicmd, cachedir=None):
+        self.ipmicmd = weakref.proxy(ipmicmd)
+        self.sensors = {}
+        self.fru = {}
+        self.cachedir = cachedir
+    
+    async def initialize(self):
+        await self.read_info()
+
+    async def read_info(self):
+        # first, we want to know the device id
+        rsp = await self.ipmicmd.raw_command(netfn=6, command=1)
+        rsp['data'] = bytearray(rsp['data'])
+        self.device_id = rsp['data'][0]
+        self.device_rev = rsp['data'][1] & 0b111
+        # Going to ignore device available until get sdr command
+        # since that provides usefully distinct state and this does not
+        self.fw_major = rsp['data'][2] & 0b1111111
+        self.fw_minor = "%02X" % rsp['data'][3]  # BCD encoding, oddly enough
+        self.ipmiversion = rsp['data'][4]  # 51h = 1.5, 02h = 2.0
+        self.mfg_id = (rsp['data'][8] << 16) + (rsp['data'][7] << 8) + \
+            rsp['data'][6]
+        self.prod_id = (rsp['data'][10] << 8) + rsp['data'][9]
+        if len(rsp['data']) > 11:
+            self.aux_fw = self.decode_aux(rsp['data'][11:15])
+        if rsp['data'][1] & 0b10000000 and rsp['data'][5] & 0b10 == 0:
+            # The device has device sdrs, also does not support SDR repository
+            # device, so we are meant to use an alternative mechanism to get
+            # SDR data
+            if rsp['data'][5] & 1:
+                # The device has sensor device support, so in theory we should
+                # be able to proceed
+                # However at the moment, we haven't done so
+                raise NotImplementedError
+            return
+            # We have Device SDR, without SDR Repository device, but
+            # also without sensor device support, no idea how to
+            # continue
+        await self.get_sdr()
+
+    async def get_sdr_reservation(self):
+        rsp = await self.ipmicmd.raw_command(netfn=0x0a, command=0x22)
+        if rsp['code'] != 0:
+            raise exc.IpmiException(rsp['error'])
+        return rsp['data'][0] + (rsp['data'][1] << 8)
+
+    async def get_sdr(self):
+        repinfo = await self.ipmicmd.raw_command(netfn=0x0a, command=0x20)
+        repinfo['data'] = bytearray(repinfo['data'])
+        if (repinfo['data'][0] != 0x51):
+            # we only understand SDR version 51h, the only version defined
+            # at time of this writing
+            raise NotImplementedError
+        # NOTE(jbjohnso): we actually don't need to care about 'numrecords'
+        # since FFFF marks the end explicitly
+        # numrecords = (rsp['data'][2] << 8) + rsp['data'][1]
+        # NOTE(jbjohnso): don't care about 'free space' at the moment
+        # NOTE(jbjohnso): most recent timstamp data for add and erase could be
+        # handy to detect cache staleness, but for now will assume invariant
+        # over life of session
+        # NOTE(jbjohnso): not looking to support the various options in op
+        # support, ignore those for now, reservation if some BMCs can't read
+        # full SDR in one slurp
+        modtime = struct.unpack('!Q', bytes(repinfo['data'][5:13]))[0]
+        recid = 0
+        rsvid = 0  # partial 'get sdr' will require this
+        offset = 0
+        size = 0xff
+        chunksize = 128
+        try:
+            csdrs = shared_sdrs[
+                (self.fw_major, self.fw_minor, self.mfg_id, self.prod_id,
+                 self.device_id, modtime)]
+            self.sensors = csdrs['sensors']
+            self.fru = csdrs['fru']
+            return
+        except KeyError:
+            pass
+        cachefilename = None
+        self.broken_sensor_ids = {}
+        if self.cachedir:
+            cachefilename = 'sdrcache-2.{0}.{1}.{2}.{3}.{4}.{5}'.format(
+                self.mfg_id, self.prod_id, self.device_id, self.fw_major,
+                self.fw_minor, modtime)
+            cachefilename = os.path.join(self.cachedir, cachefilename)
+        if cachefilename and os.path.isfile(cachefilename):
+            with open(cachefilename, 'rb') as cfile:
+                csdrlen = cfile.read(2)
+                while csdrlen:
+                    csdrlen = struct.unpack('!H', csdrlen)[0]
+                    await self.add_sdr(cfile.read(csdrlen))
+                    csdrlen = cfile.read(2)
+                for sid in self.broken_sensor_ids:
+                    try:
+                        del self.sensors[sid]
+                    except KeyError:
+                        pass
+                shared_sdrs[
+                    (self.fw_major, self.fw_minor, self.mfg_id, self.prod_id,
+                     self.device_id, modtime)] = {
+                    'sensors': self.sensors,
+                    'fru': self.fru,
+                }
+                return
+        sdrraw = [] if cachefilename else None
+        while recid != 0xffff:  # per 33.12 Get SDR command, 0xffff marks end
+            newrecid = 0
+            currlen = 0
+            sdrdata = bytearray()
+            while True:  # loop until SDR fetched wholly
+                if size != 0xff and rsvid == 0:
+                    rsvid = await self.get_sdr_reservation()
+                rqdata = [rsvid & 0xff, rsvid >> 8,
+                          recid & 0xff, recid >> 8,
+                          offset, size]
+                sdrrec = await self.ipmicmd.raw_command(netfn=0x0a, command=0x23,
+                                                  data=rqdata)
+                if sdrrec['code'] == 0xca:
+                    if size == 0xff:  # get just 5 to get header to know length
+                        size = 5
+                    elif size > 5:
+                        size //= 2
+                        # push things over such that it's less
+                        # likely to be just 1 short of a read
+                        # and incur a whole new request
+                        size += 2
+                        chunksize = size
+                    continue
+                if sdrrec['code'] == 0xc5:  # need a new reservation id
+                    rsvid = 0
+                    continue
+                if sdrrec['code'] != 0:
+                    raise exc.IpmiException(sdrrec['error'])
+                if newrecid == 0:
+                    newrecid = (sdrrec['data'][1] << 8) + sdrrec['data'][0]
+                if currlen == 0:
+                    currlen = sdrrec['data'][6] + 5  # compensate for header
+                sdrdata.extend(sdrrec['data'][2:])
+                # determine next offset to use based on current offset and the
+                # size used last time.
+                offset += size
+                if offset >= currlen:
+                    break
+                if size == 5 and offset == 5:
+                    # bump up size after header retrieval
+                    size = chunksize
+                if (offset + size) > currlen:
+                    size = currlen - offset
+            await self.add_sdr(sdrdata)
+            if sdrraw is not None:
+                sdrraw.append(bytes(sdrdata))
+            offset = 0
+            if size != 0xff:
+                size = 5
+            if newrecid == recid:
+                raise exc.BmcErrorException("Incorrect SDR record id from BMC")
+            recid = newrecid
+        for sid in self.broken_sensor_ids:
+            try:
+                del self.sensors[sid]
+            except KeyError:
+                pass
+        shared_sdrs[(self.fw_major, self.fw_minor, self.mfg_id, self.prod_id,
+                     self.device_id, modtime)] = {
+            'sensors': self.sensors,
+            'fru': self.fru,
+        }
+        if cachefilename:
+            suffix = ''.join(
+                random.choice(string.ascii_lowercase) for _ in range(12))
+            with open(cachefilename + '.' + suffix, 'wb') as cfile:
+                for csdr in sdrraw:
+                    cfile.write(struct.pack('!H', len(csdr)))
+                    cfile.write(csdr)
+            os.rename(cachefilename + '.' + suffix, cachefilename)
+
+    def get_sensor_numbers(self):
+        for number in self.sensors:
+            if self.sensors[number].readable:
+                yield number
+
+    async def make_sdr_entry(self, sdrbytes):
+        return SDREntry(sdrbytes, await self.ipmicmd.get_event_constants(),
+                        False, self.mfg_id, self.prod_id)
+
+    async def add_sdr(self, sdrbytes):
+        if not isinstance(sdrbytes[0], int):
+            sdrbytes = bytearray(sdrbytes)
+        newent = await self.make_sdr_entry(sdrbytes)
+        if newent.sdrtype == TYPE_SENSOR:
+            id = '{0}.{1}.{2}'.format(
+                newent.sensor_owner, newent.sensor_number, newent.sensor_lun)
+            if id in self.sensors:
+                self.broken_sensor_ids[id] = True
+                return
+            self.sensors[id] = newent
+        elif newent.sdrtype == TYPE_FRU:
+            id = newent.fru_number
+            if id in self.fru:
+                self.broken_sensor_ids[id] = True
+                return
+            self.fru[id] = newent
+
+    def decode_aux(self, auxdata):
+        # This is where manufacturers can add their own
+        # decode information
+        return "".join(hex(x) for x in auxdata)
diff --git a/confluent_server/aiohmi/media.py b/confluent_server/aiohmi/media.py
new file mode 100644
index 00000000..fced107d
--- /dev/null
+++ b/confluent_server/aiohmi/media.py
@@ -0,0 +1,22 @@
+# Copyright 2013 IBM Corporation
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# These are the objects returned by list_media
+
+
+class Media(object):
+    def __init__(self, name, url=None):
+        self.name = name
+        self.url = url
diff --git a/confluent_server/aiohmi/redfish/__init__.py b/confluent_server/aiohmi/redfish/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/redfish/command.py b/confluent_server/aiohmi/redfish/command.py
new file mode 100644
index 00000000..87aaae76
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/command.py
@@ -0,0 +1,1588 @@
+# coding: utf8
+# Copyright 2021 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The command module for redfish systems.  Provides https-only support
+for redfish compliant endpoints
+"""
+
+import asyncio
+import base64
+from datetime import datetime
+from datetime import timedelta
+import json
+import os
+import re
+import socket
+import struct
+import sys
+import time
+
+from dateutil import tz
+
+import aiohmi.constants as const
+import aiohmi.exceptions as exc
+import aiohmi.redfish.oem.lookup as oem
+from aiohmi.util.parse import parse_time
+import aiohmi.util.webclient as webclient
+
+
+numregex = re.compile('([0-9]+)')
+
+
+powerstates = {
+    'on': 'On',
+    'off': 'ForceOff',
+    'softoff': 'GracefulShutdown',
+    'shutdown': 'GracefulShutdown',
+    'reset': 'ForceRestart',
+    'boot': None,
+}
+
+
+boot_devices_read = {
+    'BiosSetup': 'setup',
+    'Cd': 'optical',
+    'Floppy': 'floppy',
+    'Hdd': 'hd',
+    'None': 'default',
+    'Pxe': 'network',
+    'Usb': 'usb',
+    'SDCard': 'sdcard',
+}
+
+
+_healthmap = {
+    'Critical': const.Health.Critical,
+    'Unknown': const.Health.Warning,
+    'Warning': const.Health.Warning,
+    'OK': const.Health.Ok,
+    None: const.Health.Ok,
+}
+
+
+def _mask_to_cidr(mask):
+    maskn = socket.inet_pton(socket.AF_INET, mask)
+    maskn = struct.unpack('!I', maskn)[0]
+    cidr = 32
+    while maskn & 0b1 == 0 and cidr > 0:
+        cidr -= 1
+        maskn >>= 1
+    return cidr
+
+
+
+def _cidr_to_mask(cidr):
+    return socket.inet_ntop(
+        socket.AF_INET, struct.pack(
+            '!I', (2**32 - 1) ^ (2**(32 - cidr) - 1)))
+
+
+def naturalize_string(key):
+    """Analyzes string in a human way to enable natural sort
+
+    :param nodename: The node name to analyze
+    :returns: A structure that can be consumed by 'sorted'
+    """
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(numregex, key)]
+
+
+def natural_sort(iterable):
+    """Return a sort using natural sort if possible
+
+    :param iterable:
+    :return:
+    """
+    try:
+        return sorted(iterable, key=naturalize_string)
+    except TypeError:
+        # The natural sort attempt failed, fallback to ascii sort
+        return sorted(iterable)
+
+
+class SensorReading(object):
+    def __init__(self, healthinfo, sensor=None, value=None, units=None,
+                 unavailable=False):
+        self.states = []
+        if sensor:
+            self.name = sensor['name']
+        else:
+            self.name = healthinfo['Name']
+            self.health = _healthmap.get(healthinfo.get(
+                'Status', {}).get('Health', None), const.Health.Warning)
+            self.states = [healthinfo.get('Status', {}).get('Health',
+                                                            'Unknown')]
+            if self.health == const.Health.Ok:
+                self.states = []
+        self.value = value
+        self.state_ids = None
+        self.imprecision = None
+        self.units = units
+        self.unavailable = unavailable
+    
+    def __repr__(self):
+        return repr({
+            'value': self.value,
+            'state_ids': self.state_ids,
+            'units': self.units,
+            'imprecision': self.imprecision,
+            'name': self.name,
+            'unavailable': self.unavailable,
+        })
+
+
+class Command(object):
+
+    @classmethod
+    async def create(cls, bmc, userid, password, verifycallback, sysurl=None,
+                 bmcurl=None, chassisurl=None, pool=None, port=443):
+        self = cls()
+        self.wc = webclient.WebConnection(
+            bmc, port, verifycallback=verifycallback)
+        self._hwnamemap = {}
+        self._fwnamemap = {}
+        self._urlcache = {}
+        self._varbmcurl = bmcurl
+        self._varbiosurl = None
+        self._varbmcnicurl = None
+        self._varsetbiosurl = None
+        self._varchassisurl = chassisurl
+        self._varresetbmcurl = None
+        self._varupdateservice = None
+        self._varfwinventory = None
+        self._oem = None
+        self._gpool = pool
+        self._bmcv4ip = None
+        self._bmcv6ip = None
+        self.xauthtoken = None
+        for addrinf in socket.getaddrinfo(bmc, 0, 0, socket.SOCK_STREAM):
+            if addrinf[0] == socket.AF_INET:
+                self._bmcv4ip = socket.inet_pton(addrinf[0], addrinf[-1][0])
+            elif addrinf[0] == socket.AF_INET6:
+                theip = addrinf[-1][0]
+                theip = theip.split('%')[0]
+                self._bmcv6ip = socket.inet_pton(addrinf[0], theip)
+        self.wc.set_header('Accept', 'application/json')
+        self.wc.set_header('User-Agent', 'aiohmi')
+        self.wc.set_header('Accept-Encoding', 'gzip')
+        self.wc.set_header('OData-Version', '4.0')
+        overview = await self.wc.grab_json_response('/redfish/v1/')
+        self.username = userid
+        self.password = password
+        self.wc.set_basic_credentials(self.username, self.password)
+        self.wc.set_header('Content-Type', 'application/json')
+        if 'Systems' not in overview and 'Managers' not in overview:
+            raise exc.PyghmiException('Redfish not ready')
+        if 'SessionService' in overview:
+            await self._get_session_token(self.wc)
+        self._varsensormap = {}
+        self.powerurl = None
+        self.sysurl = None
+        self._initsysurl = sysurl
+        tmpoem = await oem.get_oem_handler({}, sysurl, self.wc, self._urlcache, self,
+                                    rootinfo=overview)
+        self._varbmcurl = await tmpoem.get_default_mgrurl()        
+        if 'Systems' in overview:
+            self.sysurl = await tmpoem.get_default_sysurl()
+            sysinfo = await self.sysinfo()
+            self.powerurl = sysinfo.get('Actions', {}).get(
+                '#ComputerSystem.Reset', {}).get('target', None)               
+        return self
+
+    async def _get_session_token(self, wc):
+        # specification actually indicates we can skip straight to this url
+        username = self.username
+        password = self.password
+        if not isinstance(username, str):
+            username = username.decode()
+        if not isinstance(password, str):
+            password = password.decode()
+        _, status, headers = await wc.grab_response_with_status('/redfish/v1/SessionService/Sessions',
+                          {'UserName': username, 'Password': password})
+        if status > 299 or status < 200:
+            return
+        self.xauthtoken = headers.get('X-Auth-Token')
+        if self.xauthtoken:
+            if 'Authorization' in wc.stdheaders:
+                del wc.stdheaders['Authorization']
+            if 'Authorization' in self.wc.stdheaders:
+                del self.wc.stdheaders['Authorization']
+            wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+            self.wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+
+    async def _accountserviceurl(self):
+        sroot = await self._do_web_request('/redfish/v1/')
+        return sroot.get('AccountService', {}).get('@odata.id', None)
+
+    async def _validroles(self):
+        okroles = set()
+        roleurl = (await self._do_web_request(await self._accountserviceurl())).get(
+            'Roles', {}).get('@odata.id', None)
+        if roleurl:
+            roles = (await self._do_web_request(roleurl)).get('Members', [])
+            for role in roles:
+                role = role.get('@odata.id', '')
+                if not role:
+                    continue
+                okroles.add(role.split('/')[-1])
+        if not okroles:
+            okroles.add('Administrator')
+            okroles.add('Operator')
+            okroles.add('ReadOnly')
+        return okroles
+
+    async def get_trusted_cas(self):
+        oem = await self.oem()
+        async for ca in oem.get_trusted_cas():
+            yield ca
+    
+    async def get_bmc_csr(self, keytype=None, keylength=None, cn=None, city=None,
+                    state=None, country=None, org=None, orgunit=None):
+        oem = await self.oem()
+        return await oem.get_bmc_csr(
+            keytype=keytype, keylength=keylength, cn=cn)
+
+    async def install_bmc_certificate(self, certdata):
+        oem = await self.oem()
+        return await oem.install_bmc_certificate(certdata)
+    
+    async def add_trusted_ca(self, pemdata):
+        oem = await self.oem()
+        return await oem.add_trusted_ca(pemdata)
+    
+    async def del_trusted_ca(self, certid):
+        oem = await self.oem()
+        return await oem.del_trusted_ca(certid)
+
+    async def get_users(self):
+        """get list of users and channel access information (helper)
+
+        :param channel: number [1:7]
+
+        :return:
+            name: (str)
+            uid: (int)
+            channel: (int)
+            access:
+                callback (bool)
+                link_auth (bool)
+                ipmi_msg (bool)
+                privilege_level: (str)[callback, user, operatorm administrator,
+                                       proprietary, no_access]
+        """
+        srvurl = await self._accountserviceurl()
+        names = {}
+        if srvurl:
+            srvinfo = await self._do_web_request(srvurl)
+            srvurl = srvinfo.get('Accounts', {}).get('@odata.id', None)
+            if srvurl:
+                srvinfo = await self._do_web_request(srvurl)
+                accounts = srvinfo.get('Members', [])
+                oem = await self.oem()
+                for account in accounts:
+                    accinfo = await self._do_web_request(account['@odata.id'])
+                    currname = accinfo.get('UserName', '')
+                    currid = accinfo.get('Id', None)
+                    if currname:
+                        names[currid] = {
+                            'name': currname,
+                            'uid': currid,
+                            'expiration': await oem.get_user_expiration(currid),
+                            'access': {
+                                'privilege_level': accinfo.get('RoleId',
+                                                               'Unknown')
+                            }
+                        }
+        return names
+
+    async def _account_url_info_by_id(self, uid):
+        srvurl = await self._accountserviceurl()
+        oem = await self.oem()
+        if srvurl:
+            srvinfo = await self._do_web_request(srvurl)
+            srvurl = srvinfo.get('Accounts', {}).get('@odata.id', None)
+            if srvurl:
+                srvinfo = await self._do_web_request(srvurl)
+                accounts = srvinfo.get('Members', [])
+                for account in accounts:
+                    accinfo = await self._do_web_request(account['@odata.id'])
+                    currid = accinfo.get('Id', None)
+                    if str(currid) == str(uid):
+                        accinfo['expiration'] = await oem.get_user_expiration(
+                            uid)
+                        return account['@odata.id'], accinfo
+
+    async def get_user(self, uid):
+        srvurl = await self._accountserviceurl()
+        oem = await self.oem()
+        if srvurl:
+            srvinfo = await self._do_web_request(srvurl)
+            srvurl = srvinfo.get('Accounts', {}).get('@odata.id', None)
+            if srvurl:
+                srvinfo = await self._do_web_request(srvurl)
+                accounts = srvinfo.get('Members', [])
+                for account in accounts:
+                    accinfo = await self._do_web_request(account['@odata.id'])
+                    currname = accinfo.get('UserName', '')
+                    currid = accinfo.get('Id', None)
+                    if str(currid) == str(uid):
+                        oem = await self.oem()
+                        return {'name': currname, 'uid': uid,
+                                'expiration': await oem.get_user_expiration(
+                                    uid),
+                                'access': {
+                                    'privilege_level': accinfo.get(
+                                        'RoleId', 'Unknown')}}
+
+    async def set_user_password(self, uid, mode='set_password', password=None):
+        """Set user password and (modes)
+
+        :param uid: id number of user.  see: get_names_uid()['name']
+
+        :param mode:
+            disable       = disable user connections
+            enable        = enable user connections
+            set_password  = set or ensure password
+
+        :param password: Password
+            (optional when mode is [disable or enable])
+
+        :return:
+            True on success
+        """
+
+        accinfo = await self._account_url_info_by_id(uid)
+        if not accinfo:
+            raise Exception("No such account found")
+        etag = accinfo[1].get('@odata.etag', None)
+        if mode == 'set_password':
+            await self._do_web_request(accinfo[0], {'Password': password},
+                                 method='PATCH', etag=etag)
+        elif mode == 'disable':
+            await self._do_web_request(accinfo[0], {'Enabled': False},
+                                 method='PATCH', etag=etag)
+        elif mode == 'enable':
+            await self._do_web_request(accinfo[0], {'Enabled': True},
+                                 method='PATCH', etag=etag)
+        return True
+
+    async def disable_user(self, uid, mode):
+        """Disable User
+
+        Just disable the User.
+        This will not disable the password or revoke privileges.
+
+        :param uid: user id
+        :param mode:
+            disable       = disable user connections
+            enable        = enable user connections
+        """
+        await self.set_user_password(uid, mode)
+        return True
+
+    async def set_user_access(self, uid, privilege_level='ReadOnly'):
+        if privilege_level.startswith('custom.'):
+            privilege_level = privilege_level.replace('custom.', '')
+        accinfo = await self._account_url_info_by_id(uid)
+        if accinfo:
+            method = 'PATCH'
+        else:
+            accinfo = ((await self._accountserviceurl()) + '/Accounts', {})
+            method = 'POST'
+        etag = accinfo[1].get('@odata.etag', None)
+        for role in await self._validroles():
+            if role.lower() == privilege_level.lower():
+                privilege_level = role
+                break
+        await self._do_web_request(accinfo[0], {'RoleId': privilege_level},
+                             method=method, etag=etag)
+
+    async def create_user(self, uid, name, password, privilege_level='ReadOnly'):
+        """create/ensure a user is created with provided settings
+
+        :param privilege_level:
+            User Privilege level.  Redfish role, commonly Administrator,
+            Operator, and ReadOnly
+        """
+        accinfo = await self._account_url_info_by_id(uid)
+        if not accinfo:
+            raise Exception("Unable to find indicated uid")
+        if privilege_level.startswith('custom.'):
+            privilege_level = privilege_level.replace('custom.', '')
+        for role in await self._validroles():
+            if role.lower() == privilege_level.lower():
+                privilege_level = role
+                break
+        etag = accinfo[1].get('@odata.etag', None)
+        userinfo = {
+            "UserName": name,
+            "Password": password,
+            "RoleId": privilege_level,
+        }
+        await self._do_web_request(accinfo[0], userinfo, method='PATCH', etag=etag)
+        return True
+
+    async def get_screenshot(self, outfile):
+        oem = await self.oem()
+        return await oem.get_screenshot(outfile)
+
+    async def get_ikvm_methods(self):
+        oem = await self.oem()
+        return await oem.get_ikvm_methods()
+
+    async def get_ikvm_launchdata(self):
+        oem = await self.oem()
+        return await oem.get_ikvm_launchdata()   
+
+    async def user_delete(self, uid):
+        oem = await self.oem()
+        return await oem.user_delete(uid, self)
+
+    async def set_user_name(self, uid, name):
+        """Set user name
+
+        :param uid: user id
+        :param name: username
+        """
+        accinfo = await self._account_url_info_by_id(uid)
+        if not accinfo:
+            raise Exception("No such account found")
+        etag = accinfo[1].get('@odata.etag', None)
+        await self._do_web_request(accinfo[0], {'UserName': name}, method='PATCH',
+                             etag=etag)
+        return True
+
+    async def _updateservice(self):
+        if not self._varupdateservice:
+            overview = await self._do_web_request('/redfish/v1/')
+            us = overview.get('UpdateService', {}).get('@odata.id', None)
+            if not us:
+                raise exc.UnsupportedFunctionality(
+                    'BMC does not implement extended firmware information')
+            self._varupdateservice = us
+        return self._varupdateservice
+
+    async def get_fwinventory(self):
+        if not self._varfwinventory:
+            usi = await self._do_web_request(await self._updateservice())
+            self._varfwinventory = usi.get('FirmwareInventory', {}).get(
+                '@odata.id', None)
+            if not self._varfwinventory:
+                raise exc.UnsupportedFunctionality(
+                    'BMC does not implement extended firmware information')
+        return self._varfwinventory
+
+    async def sysinfo(self):
+        if not self.sysurl:
+            return {}
+        try:
+            return await self._do_web_request(self.sysurl)
+        except exc.RedfishError:
+            self.sysurl = None
+            return {}
+
+    async def bmcinfo(self):
+        bmcurl = await self.get_bmcurl()
+        return await self._do_web_request(bmcurl)
+
+    async def get_power(self):
+        currinfo = await self._do_web_request(self.sysurl, cache=False)
+        return {'powerstate': str(currinfo['PowerState'].lower())}
+
+    async def reseat_bay(self, bay):
+        """Request the reseat of a bay
+
+        Request the enclosure manager to reseat the system in a particular
+        bay.
+
+        :param bay: The bay identifier to reseat
+        :return:
+        """
+        oem = await self.oem()
+        await oem.reseat_bay(bay)
+
+    async def set_power(self, powerstate, wait=False):
+        if powerstate == 'boot':
+            oldpowerstate = (await self.get_power())['powerstate']
+            powerstate = 'on' if oldpowerstate == 'off' else 'reset'
+        elif powerstate in ('on', 'off'):
+            oldpowerstate = (await self.get_power())['powerstate']
+            if oldpowerstate == powerstate:
+                return {'powerstate': powerstate}
+        reqpowerstate = powerstate
+        if powerstate not in powerstates:
+            raise exc.InvalidParameterValue(
+                "Unknown power state %s requested" % powerstate)
+        powerstate = powerstates[powerstate]
+        await self._do_web_request(
+            self.powerurl, {'ResetType': powerstate})
+        if wait and reqpowerstate in ('on', 'off', 'softoff', 'shutdown'):
+            if reqpowerstate in ('softoff', 'shutdown'):
+                reqpowerstate = 'off'
+            timeout = os.times()[4] + 300
+            while (await self.get_power())['powerstate'] != reqpowerstate and os.times()[4] < timeout:
+                await asyncio.sleep(1)
+            if (await self.get_power())['powerstate'] != reqpowerstate:
+                raise exc.PyghmiException(
+                    "System did not accomplish power state change")
+            return {'powerstate': reqpowerstate}
+        return {'pendingpowerstate': reqpowerstate}
+
+    def _get_cache(self, url, cache=30):
+        now = os.times()[4]
+        cachent = self._urlcache.get(url, None)
+        if cachent and cachent['vintage'] > now - cache:
+            return cachent['contents']
+        return None
+
+    async def _do_bulk_requests(self, urls, cache=True):
+        if self._gpool:
+            urls = [(x, None, None, cache) for x in urls]
+            for res in self._gpool.starmap(self._do_web_request_withurl, urls):
+                yield res
+        else:
+            for url in urls:
+                yield await self._do_web_request_withurl(url, cache=cache)
+
+    async def _do_web_request_withurl(self, url, payload=None, method=None,
+                                cache=True):
+        return await self._do_web_request(url, payload, method, cache), url
+
+    async def _do_web_request(self, url, payload=None, method=None, cache=True,
+                        etag=None):
+        res = None
+        if cache is True:
+            cache = 30
+        if cache and payload is None and method is None:
+            res = self._get_cache(url, cache)
+        if res:
+            return res
+        wc = self.wc
+        if etag:
+            wc.stdheaders['If-Match'] = etag
+        try:
+            res = await wc.grab_json_response_with_status(url, payload,
+                                                    method=method)
+        finally:
+            if 'If-Match' in wc.stdheaders:
+                del wc.stdheaders['If-Match']
+        if res[1] == 401 and self.xauthtoken:
+            wc.set_basic_credentials(self.username, self.password)
+            await self._get_session_token(wc)
+            if etag:
+                wc.stdheaders['If-Match'] = etag
+            try:
+                res = await wc.grab_json_response_with_status(url, payload,
+                                                              method=method)
+            finally:
+                if 'If-Match' in wc.stdheaders:
+                    del wc.stdheaders['If-Match']
+
+        if res[1] < 200 or res[1] >= 300:
+            try:
+                info = json.loads(res[0])
+                errmsg = [
+                    x.get('Message', x['MessageId']) for x in info.get(
+                        'error', {}).get('@Message.ExtendedInfo', {})]
+                msgid = [
+                    x['MessageId'] for x in info.get(
+                        'error', {}).get('@Message.ExtendedInfo', {})]
+                errmsg = ','.join(errmsg)
+                msgid = ','.join(msgid)
+                raise exc.RedfishError(errmsg, msgid=msgid)
+            except (ValueError, KeyError):
+                raise exc.PyghmiException(str(url) + ":" + str(res[0]))
+        if payload is None and method is None:
+            self._urlcache[url] = {'contents': res[0],
+                                   'vintage': os.times()[4]}
+        return res[0]
+
+    async def get_bootdev(self):
+        """Get current boot device override information.
+
+        :raises: PyghmiException on error
+        :returns: dict
+        """
+        result = await self._do_web_request(self.sysurl)
+        overridestate = result.get('Boot', {}).get(
+            'BootSourceOverrideEnabled', None)
+        if overridestate == 'Disabled':
+            return {'bootdev': 'default', 'persistent': True}
+        persistent = None
+        if overridestate == 'Once':
+            persistent = False
+        elif overridestate == 'Continuous':
+            persistent = True
+        else:
+            raise exc.PyghmiException('Unrecognized Boot state: %s'
+                                      % repr(overridestate))
+        uefimode = result.get('Boot', {}).get('BootSourceOverrideMode', None)
+        if uefimode == 'UEFI':
+            uefimode = True
+        elif uefimode == 'Legacy':
+            uefimode = False
+        else:
+            raise exc.PyghmiException('Unrecognized mode: %s' % uefimode)
+        bootdev = result.get('Boot', {}).get('BootSourceOverrideTarget', None)
+        if bootdev not in boot_devices_read:
+            raise exc.PyghmiException('Unrecognized boot target: %s'
+                                      % repr(bootdev))
+        bootdev = boot_devices_read[bootdev]
+        return {'bootdev': bootdev, 'persistent': persistent,
+                'uefimode': uefimode}
+
+    async def set_bootdev(self, bootdev, persist=False, uefiboot=None):
+        """Set boot device to use on next reboot
+
+        :param bootdev:
+                        *network -- Request network boot
+                        *hd -- Boot from hard drive
+                        *safe -- Boot from hard drive, requesting 'safe mode'
+                        *optical -- boot from CD/DVD/BD drive
+                        *setup -- Boot into setup utility
+                        *default -- remove any directed boot device request
+        :param persist: If true, ask that system firmware use this device
+                        beyond next boot.  Be aware many systems do not honor
+                        this
+        :param uefiboot: If true, request UEFI boot explicitly.  If False,
+                         request BIOS style boot.
+                         None (default) does not modify the boot mode.
+        :raises: PyghmiException on an error.
+        :returns: dict or True -- If callback is not provided, the response
+        """
+        oem = await self.oem()
+        return await oem.set_bootdev(bootdev, persist, uefiboot, self)
+
+    async def get_biosurl(self):
+        if not self._varbiosurl:
+            sysinfo = await self.sysinfo()
+            self._varbiosurl = sysinfo.get('Bios', {}).get('@odata.id',
+                                                          None)
+        if self._varbiosurl is None:
+            raise exc.UnsupportedFunctionality(
+                'Bios management not detected on this platform')
+        return self._varbiosurl
+
+    async def get_setbiosurl(self):
+        if self._varsetbiosurl is None:
+            biosinfo = await self._do_web_request(await self.get_biosurl())
+            self._varsetbiosurl = biosinfo.get(
+                '@Redfish.Settings', {}).get('SettingsObject', {}).get(
+                    '@odata.id', None)
+        if self._varsetbiosurl is None:
+            raise exc.UnsupportedFunctionality('Ability to set BIOS settings '
+                                               'not detected on this platform')
+        return self._varsetbiosurl
+
+    async def _sensormap(self):
+        if not self._varsensormap:
+            sysinfo = await self.sysinfo()
+            if sysinfo:
+                for chassis in sysinfo.get('Links', {}).get('Chassis', []):
+                    await self._mapchassissensors(chassis)
+            else:  # no system, but check if this is a singular chassis
+                rootinfo = await self._do_web_request('/redfish/v1/')
+                chassiscol = rootinfo.get('Chassis', {}).get('@odata.id', '')
+                if chassiscol:
+                    chassislist = await self._do_web_request(chassiscol)
+                    if len(chassislist.get('Members', [])) == 1:
+                        await self._mapchassissensors(chassislist['Members'][0])
+        return self._varsensormap
+
+    async def _mapchassissensors(self, chassis):
+        chassisurl = chassis['@odata.id']
+        chassisinfo = await self._do_web_request(chassisurl)
+        sensors = None
+        oem = await self.oem()
+        if oem.usegenericsensors:
+            sensors = chassisinfo.get('Sensors', {}).get('@odata.id', '')
+        if sensors:
+            sensorinf = await self._do_web_request(sensors)
+            for sensor in sensorinf.get('Members', []):
+                sensedata = await self._do_web_request(sensor['@odata.id'])
+                if 'Name' in sensedata:
+                    sensetype = sensedata.get('ReadingType', 'Unknown')
+                    self._varsensormap[sensedata['Name']] = {
+                        'name': sensedata['Name'], 'type': sensetype,
+                        'url': sensor['@odata.id'], 'generic': True}
+        else:
+            powurl = chassisinfo.get('Power', {}).get('@odata.id', '')
+            if powurl:
+                powinf = await self._do_web_request(powurl)
+                for voltage in powinf.get('Voltages', []):
+                    if 'Name' in voltage:
+                        self._varsensormap[voltage['Name']] = {
+                            'name': voltage['Name'], 'url': powurl,
+                            'type': 'Voltage'}
+            thermurl = chassisinfo.get('Thermal', {}).get('@odata.id', '')
+            if thermurl:
+                therminf = await self._do_web_request(thermurl)
+                for fan in therminf.get('Fans', []):
+                    if 'Name' in fan:
+                        self._varsensormap[fan['Name']] = {
+                            'name': fan['Name'], 'type': 'Fan',
+                            'url': thermurl}
+                for temp in therminf.get('Temperatures', []):
+                    if 'Name' in temp:
+                        self._varsensormap[temp['Name']] = {
+                            'name': temp['Name'], 'type': 'Temperature',
+                            'url': thermurl}      
+        for subchassis in chassisinfo.get('Links', {}).get('Contains', []):
+            await self._mapchassissensors(subchassis)
+
+    async def _get_thermals(self, chassis):
+        chassisurl = chassis['@odata.id']
+        chassisinfo = await self._do_web_request(chassisurl)
+        thermurl = chassisinfo.get('Thermal', {}).get('@odata.id', '')
+        if thermurl:
+            therminf = await self._do_web_request(thermurl, cache=1)
+            return therminf.get('Temperatures', [])
+
+    async def get_bmcurl(self):
+        if not self._varbmcurl:
+            sysinfo = await self.sysinfo()
+            self._varbmcurl = sysinfo.get('Links', {}).get(
+                'ManagedBy', [{}])[0].get('@odata.id', None)
+        return self._varbmcurl
+
+    async def get_bmcnicurl(self):
+        if not self._varbmcnicurl:
+            self._varbmcnicurl = await self._get_bmc_nic_url()
+        return self._varbmcnicurl
+
+    async def list_network_interface_names(self):
+        bmcurl = await self.get_bmcurl()
+        bmcinfo = await self._do_web_request(bmcurl)
+        nicurl = bmcinfo.get('EthernetInterfaces', {}).get('@odata.id', None)
+        if not nicurl:
+            return
+        niclist = await self._do_web_request(nicurl)
+        for nic in niclist.get('Members', []):
+            curl = nic.get('@odata.id', None)
+            if not curl:
+                continue
+            yield curl.rsplit('/', 1)[1]
+
+    async def _get_bmc_nic_url(self, name=None):
+        bmcinfo = await self._do_web_request(await self.get_bmcurl())
+        nicurl = bmcinfo.get('EthernetInterfaces', {}).get('@odata.id', None)
+        niclist = await self._do_web_request(nicurl)
+        foundnics = 0
+        lastnicurl = None
+        oem = await self.oem()
+        for nic in niclist.get('Members', []):
+            curl = nic.get('@odata.id', None)
+            if not curl:
+                continue
+            if name is not None:
+                if curl.endswith('/{0}'.format(name)):
+                    return curl
+                continue
+            if oem.hostnic and curl.endswith('/{0}'.format(
+                    oem.hostnic)):
+                continue
+            nicinfo = await self._do_web_request(curl)
+            if nicinfo.get('Links', {}).get('HostInterface', None):
+                # skip host interface
+                continue
+            if not nicinfo.get('InterfaceEnabled', True):
+                # skip disabled interfaces
+                continue
+            for addrs in nicinfo.get('IPv4Addresses', []):
+                v4addr = socket.inet_pton(
+                    socket.AF_INET, addrs.get('Address', '0.0.0.0'))
+                if self._bmcv4ip == v4addr:
+                    return curl
+            for addrs in nicinfo.get('IPv6Addresses', []):
+                v6addr = socket.inet_pton(
+                    socket.AF_INET6, addrs.get('Address', '::'))
+                if self._bmcv6ip == v6addr:
+                    return curl
+            foundnics += 1
+            lastnicurl = curl
+        if name is None and foundnics != 1:
+            raise exc.PyghmiException(
+                'BMC does not have exactly one interface')
+        if name is None:
+            return lastnicurl
+
+    async def _bmcresetinfo(self):
+        if not self._varresetbmcurl:
+            bmcinfo = await self._do_web_request(await self.get_bmcurl())
+            resetinf = bmcinfo.get('Actions', {}).get('#Manager.Reset', {})
+            url = resetinf.get('target', '')
+            valid = resetinf.get('ResetType@Redfish.AllowableValues', [])
+            if not valid:
+                tmpurl = resetinf.get('@Redfish.ActionInfo', None)
+                if tmpurl:
+                    resetinf = await self._do_web_request(tmpurl)
+                    valid = resetinf.get('Parameters', [{}])[0].get(
+                        'AllowableValues')
+            resettype = None
+            if 'GracefulRestart' in valid:
+                resettype = 'GracefulRestart'
+            elif 'ForceRestart' in valid:
+                resettype = 'ForceRestart'
+            elif 'ColdReset' in valid:
+                resettype = 'ColdReset'
+            self._varresetbmcurl = url, resettype
+        return self._varresetbmcurl
+
+    async def reset_bmc(self):
+        url, action = await self._bmcresetinfo()
+        if not url:
+            raise Exception('BMC does not provide reset action')
+        if not action:
+            raise Exception('BMC does not accept a recognized reset type')
+        await self._do_web_request(url, {'ResetType': action})
+
+    async def set_identify(self, on=True, blink=None):
+        oem = await self.oem()
+        if hasattr(oem, 'set_identify'):
+            return await oem.set_identify(on, blink)    
+        targurl = self.sysurl
+        if not targurl:
+            root = await self._do_web_request('/redfish/v1')
+            systemsurl = root.get('Systems', {}).get('@odata.id', None)
+            if systemsurl:
+                targurl = await self._do_web_request(systemsurl)
+                if len(targurl.get('Members', [])) == 1:
+                    targurl = targurl['Members'][0]['@odata.id']
+        if not targurl:
+            raise Exception("Unable to identify system url")        
+        await self._do_web_request(
+            targurl,
+            {'IndicatorLED': 'Blinking' if blink else 'Lit' if on else 'Off'},
+            method='PATCH', etag='*')
+
+    _idstatemap = {
+        'Blinking': 'blink',
+        'Lit': 'on',
+        'Off': 'off',
+    }
+
+    async def get_identify(self):
+        await self.sysinfo()
+        ledstate = self.sysinfo
+        return {'identifystate': self._idstatemap[ledstate]}
+
+    async def get_health(self, verbose=True):
+        oem = await self.oem()
+        return await oem.get_health(self, verbose)
+
+    async def get_extended_bmc_configuration(self, hideadvanced=True):
+        oem = await self.oem()
+        return await oem.get_extended_bmc_configuration(self, hideadvanced=hideadvanced)
+
+    async def get_bmc_configuration(self):
+        """Get miscellaneous BMC configuration
+
+        In much the same way a bmc can present arbitrary key-value
+        structure for BIOS/UEFI configuration, provide a mechanism
+        for a BMC to provide arbitrary key-value for BMC specific
+        settings.
+        """
+
+        # For now, this is a stub, no implementation for redfish currently
+        oem = await self.oem()
+        return await oem.get_bmc_configuration()
+
+    async def set_bmc_configuration(self, changeset):
+        """Get miscellaneous BMC configuration
+
+        In much the same way a bmc can present arbitrary key-value
+        structure for BIOS/UEFI configuration, provide a mechanism
+        for a BMC to provide arbitrary key-value for BMC specific
+        settings.
+        """
+
+        # For now, this is a stub, no implementation for redfish currently
+        oem = await self.oem()
+        return await oem.set_bmc_configuration(changeset)
+
+    async def set_system_configuration(self, changeset):
+        oem = await self.oem()
+        return await oem.set_system_configuration(changeset, self)
+
+    async def get_ntp_enabled(self):
+        bmcinfo = await self._do_web_request(await self.get_bmcurl())
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        if netprotocols:
+            netprotoinfo = await self._do_web_request(netprotocols)
+            enabled = netprotoinfo.get('NTP', {}).get('ProtocolEnabled', False)
+            return enabled
+        return False
+
+    async def set_ntp_enabled(self, enable):
+        bmcinfo = await self._do_web_request(await self.get_bmcurl())
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        if netprotocols:
+            request = {'NTP':{'ProtocolEnabled': enable}}
+            await self._do_web_request(netprotocols, request, method='PATCH')
+            await self._do_web_request(netprotocols, cache=0)
+
+    async def get_ntp_servers(self):
+        bmcinfo = await self._do_web_request(await self.get_bmcurl())
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        if not netprotocols:
+            return []
+        netprotoinfo = await self._do_web_request(netprotocols)
+        return netprotoinfo.get('NTP', {}).get('NTPServers', [])
+
+    async def set_ntp_server(self, server, index=None):
+        bmcinfo = await self._do_web_request(await self.get_bmcurl())
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        currntpservers = await self.get_ntp_servers()
+        if index is None:
+            if server in currntpservers:
+                return
+            currntpservers = [server] + currntpservers
+        else:
+            if (index + 1) > len(currntpservers):
+                if not server:
+                    return
+                currntpservers.append(server)
+            else:
+                if not server:
+                    del currntpservers[index]
+                else:
+                    currntpservers[index] = server
+        request = {'NTP':{'NTPServers': currntpservers}}
+        await self._do_web_request(netprotocols, request, method='PATCH')
+        await self._do_web_request(netprotocols, cache=0)
+
+    async def clear_bmc_configuration(self):
+        """Reset BMC to factory default
+
+        Call appropriate function to clear BMC to factory default settings.
+        In many cases, this may render remote network access impracticle or
+        impossible."
+        """
+        bmcinfo = await self._do_web_request(await self.get_bmcurl())
+        rc = bmcinfo.get('Actions', {}).get('#Manager.ResetToDefaults', {})
+        actinf = rc.get('ResetType@Redfish.AllowableValues', [])
+        if 'ResetAll' in actinf: 
+            acturl = rc.get('target', None)
+            if acturl:
+                await self._do_web_request(acturl, {'ResetType': 'ResetAll'})
+                return
+        raise exc.UnsupportedFunctionality(
+            'Clear BMC configuration not supported on this platform')
+
+    async def get_system_configuration(self, hideadvanced=True):
+        oem = await self.oem()
+        return await oem.get_system_configuration(hideadvanced, self)
+
+    async def clear_system_configuration(self):
+        """Clear the BIOS/UEFI configuration
+
+        """
+        biosinfo = await self._do_web_request(await self.get_biosurl())
+        rb = biosinfo.get('Actions', {}).get('#Bios.ResetBios', {})
+        actinf = rb.get('@Redfish.ActionInfo', None)
+        rb = rb.get('target', '')
+        parms = {}
+        if actinf:
+            actinf = await self._do_web_request(
+                '/redfish/v1/Systems/Self/Bios/ResetBiosActionInfo')
+            for parm in actinf.get('Parameters', ()):
+                if parm.get('Required', False):
+                    if parm.get('Name', None) == 'ResetType' and parm.get(
+                            'AllowableValues', [None])[0] == 'Reset':
+                        parms['ResetType'] = 'Reset'
+                    else:
+                        raise Exception(
+                            'Unrecognized required parameter {0}'.format(
+                                parm.get('Name', 'Unknown')))
+        if not rb:
+            raise Exception('BIOS reset not detected on this system')
+        if not parms:
+            parms = {'Action': 'Bios.ResetBios'}
+        await self._do_web_request(rb, parms)
+
+    async def set_net6_configuration(self, static_addresses=None, static_gateway=None, name=None):
+        patch = {}
+        if static_addresses is not None:
+            sa = []
+            patch['IPv6StaticAddresses'] = sa
+            for addr in static_addresses:
+                if '/' in addr:
+                    addr, plen = addr.split('/', 1)
+                else:
+                    plen = '64'
+                sa.append({
+                    'PrefixLength': int(plen),
+                    'Address': addr
+                })
+        if static_gateway:
+            patch['IPv6StaticDefaultGateways'] = [{
+                'Address': static_gateway,
+            }]
+        if patch:
+            nicurl = self._get_bmc_nic_url(name)
+            await self._do_web_request(nicurl, patch, 'PATCH')
+
+    async def set_net_configuration(self, ipv4_address=None, ipv4_configuration=None,
+                              ipv4_gateway=None, vlan_id=None, name=None):
+        patch = {}
+        ipinfo = {}
+        dodhcp = None
+        netmask = None
+        if (ipv4_address is None and ipv4_configuration is None
+                and ipv4_gateway is None and vlan_id is None):
+            return
+        if ipv4_address:
+            if '/' in ipv4_address:
+                ipv4_address, cidr = ipv4_address.split('/')
+                netmask = _cidr_to_mask(int(cidr))
+            patch['IPv4StaticAddresses'] = [ipinfo]
+            ipinfo['Address'] = ipv4_address
+            ipv4_configuration = 'static'
+            if netmask:
+                ipinfo['SubnetMask'] = netmask
+        if ipv4_gateway:
+            patch['IPv4StaticAddresses'] = [ipinfo]
+            ipinfo['Gateway'] = ipv4_gateway
+            ipv4_configuration = 'static'
+        if ipv4_configuration and ipv4_configuration.lower() == 'dhcp':
+            dodhcp = True
+            patch['DHCPv4'] = {'DHCPEnabled': True}
+        elif (ipv4_configuration == 'static'
+              or 'IPv4StaticAddresses' in patch):
+            dodhcp = False
+            patch['DHCPv4'] = {'DHCPEnabled': False}
+        if vlan_id in ('off', 0, '0'):
+            patch['VLAN'] = {'VLANEnable': False}
+        elif vlan_id:
+            patch['VLAN'] = {'VLANEnable': True, 'VLANId': int(vlan_id)}        
+        if patch:
+            nicurl = await self._get_bmc_nic_url(name)
+            try:
+                await self._do_web_request(nicurl, patch, 'PATCH')
+            except exc.RedfishError:
+                patch = {'IPv4Addresses': [ipinfo]}
+                if dodhcp:
+                    ipinfo['AddressOrigin'] = 'DHCP'
+                elif dodhcp is not None:
+                    ipinfo['AddressOrigin'] = 'Static'
+                await self._do_web_request(nicurl, patch, 'PATCH')
+
+    async def get_net6_configuration(self, name=None):
+        nicurl = await self._get_bmc_nic_url(name)
+        netcfg = await self._do_web_request(nicurl, cache=False)
+        retdata = {}
+        saddrs = netcfg.get('IPv6StaticAddresses', ())
+        retdata['static_addrs'] = []
+        for sa in saddrs:
+            ca = '{}/{}'.format(sa['Address'], sa['PrefixLength'])
+            retdata['static_addrs'].append(ca)
+        gws = netcfg.get('IPv6StaticDefaultGateways', None)
+        if gws:
+            for gw in gws:
+                retdata['static_gateway'] = gw['Address']
+        tagged = netcfg.get('VLAN', {}).get('VLANEnabled', False)
+        if tagged:
+            retdata['vlan_id'] = netcfg.get('VLAN', {}).get('VLANId', None)
+        else:
+            retdata['vlan_id'] = 'off'
+        return retdata
+
+    async def get_net_configuration(self, name=None):
+        nicurl = await self._get_bmc_nic_url(name)
+        netcfg = await self._do_web_request(nicurl, cache=False)
+        ipv4 = netcfg.get('IPv4Addresses', {})
+        if not ipv4:
+            raise exc.PyghmiException('Unable to locate network information')
+        retval = {}
+        if len(netcfg['IPv4Addresses']) != 1:
+            netcfg['IPv4Addresses'] = [
+                x for x in netcfg['IPv4Addresses']
+                if x['Address'] != '0.0.0.0']
+        if len(netcfg['IPv4Addresses']) != 1:
+            raise exc.PyghmiException('Multiple IP addresses not supported')
+        currip = netcfg['IPv4Addresses'][0]
+        cidr = _mask_to_cidr(currip['SubnetMask'])
+        retval['ipv4_address'] = '{0}/{1}'.format(currip['Address'], cidr)
+        retval['mac_address'] = netcfg['MACAddress']
+        hasgateway = _mask_to_cidr(currip['Gateway'])
+        retval['ipv4_gateway'] = currip['Gateway'] if hasgateway else None
+        retval['ipv4_configuration'] = currip['AddressOrigin']
+        tagged = netcfg.get('VLAN', {}).get('VLANEnable', False)
+        if tagged:
+            retval['vlan_id'] = netcfg.get('VLAN', {}).get('VLANId', None)
+        else:
+            retval['vlan_id'] = 'off'        
+        return retval
+
+    async def get_hostname(self):
+        netcfg = await self._do_web_request(await self.get_bmcnicurl())
+        return netcfg['HostName']
+
+    async def set_hostname(self, hostname):
+        await self._do_web_request(await self.get_bmcnicurl(),
+                             {'HostName': hostname}, 'PATCH')
+
+    async def get_firmware(self, components=(), category=None):
+        self._fwnamemap = {}
+        oem = await self.oem()
+        try:
+            async for firminfo in oem.get_firmware_inventory(components, self, category):
+                yield firminfo
+        except exc.BypassGenericBehavior:
+            return
+        fwlist = await self._do_web_request(await self.get_fwinventory())
+        fwurls = [x['@odata.id'] for x in fwlist.get('Members', [])]
+        async for res in self._do_bulk_requests(fwurls):
+            res = self._extract_fwinfo(res)
+            if res[0] is None:
+                continue
+            yield res
+
+    def _extract_fwinfo(self, inf):
+        currinf = self._oem._extract_fwinfo(inf)
+        fwi, url = inf
+        fwname = fwi.get('Name', 'Unknown')
+        if fwname in self._fwnamemap:
+            fwname = fwi.get('Id', fwname)
+        if fwname in self._fwnamemap:
+            # Block duplicates for by name retrieval
+            self._fwnamemap[fwname] = None
+        else:
+            self._fwnamemap[fwname] = url
+        currinf['name'] = fwname
+        currinf['id'] = fwi.get('Id', None)
+        currinf['version'] = fwi.get('Version', 'Unknown')
+        currinf['date'] = parse_time(fwi.get('ReleaseDate', ''))
+        currinf['software_id'] = fwi.get('SoftwareId', '')
+        if not (currinf['version'] or currinf['date']):
+            return None, None
+        # TODO(Jarrod Johnson): OEM extended data with buildid
+        currstate = fwi.get('Status', {}).get('State', 'Unknown')
+        if currstate == 'StandbyOffline':
+            currinf['state'] = 'pending'
+        elif currstate == 'Enabled':
+            currinf['state'] = 'active'
+        elif currstate == 'StandbySpare':
+            currinf['state'] = 'backup'
+        return fwname, currinf
+
+    async def get_inventory_descriptions(self, withids=False):
+        oem = await self.oem()
+        async for desc in oem.get_inventory_descriptions(withids):
+            yield desc
+
+    async def get_inventory_of_component(self, component):
+        oem = await self.oem()
+        return await oem.get_inventory_of_component(component)
+
+    async def get_inventory(self, withids=False):
+        oem = await self.oem()
+        async for x in oem.get_inventory(withids):
+            yield x
+
+    async def get_location_information(self):
+        locationinfo = {}
+        sysinfo = await self.sysinfo()
+        for chassis in sysinfo.get('Links', {}).get('Chassis', []):
+            chassisurl = chassis['@odata.id']
+            data = await self._do_web_request(chassisurl)
+            locdata = data.get('Location', {})
+            postaladdress = locdata.get('PostalAddress', {})
+            placement = locdata.get('Placement', {})
+            contactinfo = locdata.get('Contacts', [])
+            currval = postaladdress.get('Room', '')
+            if currval:
+                locationinfo['room'] = currval
+            currval = postaladdress.get('Location', '')
+            if currval:
+                locationinfo['location'] = currval
+            currval = postaladdress.get('Building', '')
+            if currval:
+                locationinfo['building'] = currval
+            currval = placement.get('Rack', '')
+            if currval:
+                locationinfo['rack'] = currval
+            for contact in contactinfo:
+                contact = contact.get('ContactName', '')
+                if not contact:
+                    continue
+                if 'contactnames' not in locationinfo:
+                    locationinfo['contactnames'] = [contact]
+                else:
+                    locationinfo['contactnames'].append(contact)
+        return locationinfo
+
+    async def set_location_information(self, room=None, contactnames=None,
+                                 location=None, building=None, rack=None):
+        locationinfo = {}
+        postaladdress = {}
+        placement = {}
+        if contactnames is not None:
+            locationinfo['Contacts'] = [
+                {'ContactName': x} for x in contactnames]
+        if room is not None:
+            postaladdress['Room'] = room
+        if location is not None:
+            postaladdress['Location'] = location
+        if building is not None:
+            postaladdress['Building'] = building
+        if rack is not None:
+            placement['Rack'] = rack
+        if postaladdress:
+            locationinfo['PostalAddress'] = postaladdress
+        if placement:
+            locationinfo['Placement'] = placement
+        if locationinfo:
+            sysinfo = await self.sysinfo()
+            for chassis in sysinfo.get('Links', {}).get('Chassis', []):
+                chassisurl = chassis['@odata.id']
+                await self._do_web_request(chassisurl, {'Location': locationinfo},
+                                     method='PATCH')
+
+    async def oem(self):
+        if not self._oem:
+            if self.sysurl:
+                await self._do_web_request(self.sysurl, cache=False)  # This is to trigger token validation and renewel
+            elif self._varbmcurl:
+                await self._do_web_request(self._varbmcurl, cache=False)  # This is to trigger token validation and renewel
+            sysinfo = await self.sysinfo()
+            self._oem = await oem.get_oem_handler(
+                sysinfo, self._initsysurl, self.wc, self._urlcache, self)
+            self._oem.set_credentials(self.username, self.password)
+        return self._oem
+
+    async def get_description(self):
+        oem = await self.oem()
+        return await oem.get_description(self)
+
+    async def get_event_log(self, clear=False):
+        oem = await self.oem()
+        async for logent in oem.get_event_log(clear, self):
+            yield logent
+    
+    async def _get_chassis_env(self, chassis):
+        chassisurl = chassis['@odata.id']
+        chassisinfo = await self._do_web_request(chassisurl)
+        envurl = chassisinfo.get('EnvironmentMetrics', {}).get('@odata.id', '')
+        if not envurl:
+            return {}
+        envmetric = await self._do_web_request(envurl, cache=1)
+        retval = {
+            'watts': envmetric.get('PowerWatts', {}).get('Reading', None),
+            'inlet': envmetric.get('TemperatureCelsius', {}).get('Reading', None)
+        }
+        return retval
+
+    async def get_average_processor_temperature(self):
+        oem = await self.oem()
+        return await oem.get_average_processor_temperature(self)
+
+    async def get_system_power_watts(self):
+        oem = await self.oem()
+        return await oem.get_system_power_watts(self)
+
+    async def get_inlet_temperature(self):
+        inlets = []
+        sysinfo = await self.sysinfo()
+        for chassis in sysinfo.get('Links', {}).get('Chassis', []):
+            envinfo = await self._get_chassis_env(chassis)
+            currinlet = envinfo.get('inlet', None)
+            if currinlet:
+                inlets.append(currinlet)
+        if inlets:
+            val = sum(inlets) / len(inlets)
+            unavail = False
+        else:
+            val = None
+            unavail = True
+        return SensorReading(
+                        None, {'name': 'Inlet Temperature'}, value=val, units='°C',
+                        unavailable=unavail)
+    async def get_sensor_descriptions(self):
+        for sensor in natural_sort(await self._sensormap()):
+            yield (await self._sensormap())[sensor]
+
+    async def get_sensor_reading(self, sensorname):
+        sensormap = await self._sensormap()
+        if sensorname not in sensormap:
+            raise Exception('Sensor not found')
+        sensor = sensormap[sensorname]
+        reading = await self._do_web_request(sensor['url'], cache=1)
+        return self._extract_reading(sensor, reading)
+
+    async def get_sensor_data(self):
+        for sensor in natural_sort(await self._sensormap()):
+            yield await self.get_sensor_reading(sensor)
+
+    def _extract_reading(self, sensor, reading):
+        if sensor.get('generic', False):  # generic sensor
+            val = reading.get('Reading', None)
+            unavail = val is None
+            units = reading.get('ReadingUnits', None)
+            if units == 'Cel':
+                units = '°C'
+            if units == 'cft_i/min':
+                units = 'CFM'
+            return SensorReading(reading, None, value=val, units=units,
+                          unavailable=unavail)
+        if sensor['type'] == 'Fan':
+            for fan in reading['Fans']:
+                if fan['Name'] == sensor['name']:
+                    val = fan.get('Reading', None)
+                    unavail = val is None
+                    units = fan.get('ReadingUnits', None)
+                    return SensorReading(
+                        None, sensor, value=val, units=units,
+                        unavailable=unavail)
+        elif sensor['type'] == 'Temperature':
+            for temp in reading['Temperatures']:
+                if temp['Name'] == sensor['name']:
+                    val = temp.get('ReadingCelsius', None)
+                    unavail = val is None
+                    return SensorReading(
+                        None, sensor, value=val, units='°C',
+                        unavailable=unavail)
+        elif sensor['type'] == 'Voltage':
+            for volt in reading['Voltages']:
+                if volt['Name'] == sensor['name']:
+                    val = volt.get('ReadingVolts', None)
+                    unavail = val is None
+                    return SensorReading(
+                        None, sensor, value=val, units='V',
+                        unavailable=unavail)
+
+    async def list_media(self):
+        oem = await self.oem()
+        async for res in oem.list_media(self):
+            yield res
+
+    async def get_storage_configuration(self):
+        """"Get storage configuration data
+
+        Retrieves the storage configuration from the target.  Data is given
+        about disks, pools, and volumes.  When referencing something, use the
+        relevant 'cfgpath' attribute to describe it.  It is not guaranteed that
+        cfgpath will be consistent version to version, so a lookup is suggested
+        in end user applications.
+
+        :return: A aiohmi.storage.ConfigSpec object describing current config
+        """
+        oem = await self.oem()
+        return await oem.get_storage_configuration()
+
+    async def remove_storage_configuration(self, cfgspec):
+        """Remove specified storage configuration from controller.
+
+        :param cfgspec: A aiohmi.storage.ConfigSpec describing what to remove
+        :return:
+        """
+        oem = await self.oem()
+        return await oem.remove_storage_configuration(cfgspec)
+
+    async def apply_storage_configuration(self, cfgspec=None):
+        """Evaluate a configuration for validity
+
+        This will check if configuration is currently available and, if given,
+        whether the specified cfgspec can be applied.
+        :param cfgspec: A aiohmi.storage.ConfigSpec describing desired oonfig
+        :return:
+        """
+        oem = await self.oem()
+        return await oem.apply_storage_configuration(cfgspec)
+
+    def check_storage_configuration(self, cfgspec=None):
+        """Evaluate a configuration for validity
+
+        This will check if configuration is currently available and, if given,
+        whether the specified cfgspec can be applied.
+        :param cfgspec: A aiohmi.storage.ConfigSpec describing desired oonfig
+        :return:
+        """
+        return self._oem.check_storage_configuration(cfgspec)
+
+    async def attach_remote_media(self, url, username=None, password=None):
+        """Attach remote media by url
+
+        Given a url, attach remote media (cd/usb image) to the target system.
+
+        :param url:  URL to indicate where to find image (protocol support
+                     varies by BMC)
+        :param username: Username for endpoint to use when accessing the URL.
+                         If applicable, 'domain' would be indicated by '@' or
+                         '\' syntax.
+        :param password: Password for endpoint to use when accessing the URL.
+        """
+        # At the moment, there isn't a viable way to
+        # identify the correct resource ahead of time.
+        # As such it's OEM specific until the standard
+        # provides a better way.
+        vmurls = []
+        sysinfo = await self.sysinfo()
+        vmcoll = sysinfo.get(
+            'VirtualMedia', {}).get('@odata.id', None)
+        if not vmcoll:
+            bmcinfo = await self.bmcinfo()
+            vmcoll = bmcinfo.get(
+                'VirtualMedia', {}).get('@odata.id', None)
+        if vmcoll:
+            vmlist = await self._do_web_request(vmcoll)
+            vmurls = [x['@odata.id'] for x in vmlist.get('Members', [])]
+        suspendedxauth = False  # Don't trigger token expiry linked unmount
+        if 'X-Auth-Token' in self.wc.stdheaders:
+            suspendedxauth = True
+            del self.wc.stdheaders['X-Auth-Token']
+            self.wc.set_basic_credentials(self.username, self.password)
+        oem = await self.oem()
+        try:
+            await oem.attach_remote_media(url, username, password, vmurls)
+        except exc.BypassGenericBehavior:
+            if suspendedxauth:
+                self.wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+                if 'Authorization' in self.wc.stdheaders:
+                    del self.wc.stdheaders['Authorization']            
+            return
+        for vmurl in vmurls:
+            vminfo = self._do_web_request(vmurl, cache=False)
+            if vminfo.get('ConnectedVia', None) != 'NotConnected':
+                continue
+            inserturl = vminfo.get(
+                'Actions', {}).get(
+                    '#VirtualMedia.InsertMedia', {}).get('target', None)
+            if inserturl:
+                self._do_web_request(inserturl, {'Image': url})
+            else:
+                try:
+                    self._do_web_request(vmurl,
+                                         {'Image': url, 'Inserted': True},
+                                         'PATCH')
+                except exc.RedfishError as re:
+                    if re.msgid.endswith(u'PropertyUnknown'):
+                        self._do_web_request(vmurl, {'Image': url}, 'PATCH')
+                    else:
+                        raise
+            break
+        if suspendedxauth:
+                self.wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+                if 'Authorization' in self.wc.stdheaders:
+                    del self.wc.stdheaders['Authorization']    
+        async for res in oem.list_media(self, cache=False):
+            pass          
+
+    async def detach_remote_media(self):
+        oem = await self.oem()
+        try:
+            await oem.detach_remote_media()
+        except exc.BypassGenericBehavior:
+            return
+        sysinfo = await self.sysinfo()
+        vmcoll = sysinfo.get('VirtualMedia', {}).get('@odata.id', None)
+        if not vmcoll:
+            bmcinfo = await self._do_web_request(await self.get_bmcurl())
+            vmcoll = bmcinfo.get('VirtualMedia', {}).get('@odata.id', None)
+        if vmcoll:
+            vmlist = await self._do_web_request(vmcoll)
+            vmurls = [x['@odata.id'] for x in vmlist.get('Members', [])]
+            async for vminfo in self._do_bulk_requests(vmurls):
+                vminfo, currl = vminfo
+                if vminfo['Image']:
+                    ejurl = vminfo.get(
+                        'Actions', {}).get(
+                            '#VirtualMedia.EjectMedia', {}).get('target', None)
+                    if ejurl:
+                        await self._do_web_request(ejurl, {})
+                    else:
+                        try:
+                            await self._do_web_request(currl,
+                                                       {'Image': None,
+                                                        'Inserted': False},
+                                                       method='PATCH')
+                        except exc.RedfishError as re:
+                            if re.msgid.endswith(u'PropertyUnknown'):
+                                await self._do_web_request(currl, {'Image': None},
+                                                     method='PATCH')
+                            else:
+                                raise
+        oem = await self.oem()
+        async for res in oem.list_media(self, cache=False):
+            pass
+
+    async def upload_media(self, filename, progress=None, data=None):
+        """Upload a file to be hosted on the target BMC
+
+        This will upload the specified data to
+        the BMC so that it will make it available to the system as an emulated
+        USB device.
+
+        :param filename: The filename to use, the basename of the parameter
+                         will be given to the bmc.
+        :param progress: Optional callback for progress updates
+        """
+        oem = await self.oem()
+        return await oem.upload_media(filename, progress, data)
+
+    async def get_update_status(self):
+        oem = await self.oem()
+        return await oem.get_update_status()   
+
+    async def update_firmware(self, file, data=None, progress=None, bank=None):
+        """Send file to BMC to perform firmware update
+
+         :param filename:  The filename to upload to the target BMC
+         :param data:  The payload of the firmware.  Default is to read from
+                       specified filename.
+         :param progress:  A callback that will be given a dict describing
+                           update process.  Provide if
+         :param bank: Indicate a target 'bank' of firmware if supported
+        """
+        if progress is None:
+            progress = lambda x: True
+        oem = await self.oem()
+        return await oem.update_firmware(file, data, progress, bank)
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        if os.path.exists(savefile) and not os.path.isdir(savefile):
+            raise exc.InvalidParameterValue(
+                'Not allowed to overwrite existing file: {0}'.format(
+                    savefile))
+        oem = await self.oem()
+        return await oem.get_diagnostic_data(savefile, progress, autosuffix)
+
+    async def get_licenses(self):
+        oem = await self.oem()
+        async for lic in oem.get_licenses(self):
+            yield lic
+
+    async def delete_license(self, name):
+        oem = await self.oem()
+        return await oem.delete_license(name, self)
+
+    async def save_licenses(self, directory):
+        if os.path.exists(directory) and not os.path.isdir(directory):
+            raise exc.InvalidParameterValue(
+                'Not allowed to overwrite existing file: {0}'.format(
+                    directory))
+        oem = await self.oem()
+        async for lic in oem.save_licenses(directory, self):
+            yield lic
+
+    async def apply_license(self, filename, progress=None, data=None):
+        oem = await self.oem()
+        return await oem.apply_license(filename, self, progress, data)
+
+if __name__ == '__main__':
+    print(repr(
+        Command(sys.argv[1], os.environ['BMCUSER'], os.environ['BMCPASS'],
+                verifycallback=lambda x: True).get_power()))
diff --git a/confluent_server/aiohmi/redfish/oem/__init__.py b/confluent_server/aiohmi/redfish/oem/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/redfish/oem/ami/main.py b/confluent_server/aiohmi/redfish/oem/ami/main.py
new file mode 100644
index 00000000..a1e99566
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/ami/main.py
@@ -0,0 +1,20 @@
+# Copyright 2025 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.redfish.oem.ami.megarac as megarac
+
+
+async def get_handler(sysinfo, sysurl, webclient, cache, cmd, rootinfo={}):
+    return await megarac.OEMHandler.create(sysinfo, sysurl, webclient, cache,
+                            gpool=cmd._gpool)
diff --git a/confluent_server/aiohmi/redfish/oem/ami/megarac.py b/confluent_server/aiohmi/redfish/oem/ami/megarac.py
new file mode 100644
index 00000000..366413ba
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/ami/megarac.py
@@ -0,0 +1,31 @@
+# Copyright 2025 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.redfish.oem.generic as generic
+
+
+class OEMHandler(generic.OEMHandler):
+    @classmethod
+    async def create(cls, sysinfo, sysurl, webclient, cache, gpool=None):
+        self = await super().create(sysinfo, sysurl, webclient, cache,
+                                         gpool)
+        if sysurl is None:
+            systems, status = await webclient.grab_json_response_with_status('/redfish/v1/Systems')
+            if status == 200:
+                for system in systems.get('Members', []):
+                    if system.get('@odata.id', '').endswith('/Self') or system.get('@odata.id', '').endswith('/System_0'):
+                        sysurl = system['@odata.id']
+                        break
+            self._varsysurl = sysurl
+        return self
diff --git a/confluent_server/aiohmi/redfish/oem/dell/__init__.py b/confluent_server/aiohmi/redfish/oem/dell/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/redfish/oem/dell/idrac.py b/confluent_server/aiohmi/redfish/oem/dell/idrac.py
new file mode 100644
index 00000000..e52eacdf
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/dell/idrac.py
@@ -0,0 +1,43 @@
+# Copyright 2022 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.redfish.oem.generic as generic
+
+
+class OEMHandler(generic.OEMHandler):
+
+    def set_bootdev(self, bootdev, persist=False, uefiboot=None,
+                    fishclient=None):
+        # gleaned from web console, under configuration, system settings,
+        # hardware, first boot device. iDrac presumes that the standard
+        # explicitly refers only to physical devices. I think the intent
+        # is the exact opposite for 'removable' media, and thus redirect
+        # the 'physical' standard to the vFDD/VCD-DVD seen in the idrac
+        # web gui
+        if bootdev not in ('floppy', 'cd'):
+            return super(OEMHandler, self).set_bootdev(bootdev, persist,
+                                                       uefiboot, fishclient)
+        payload = {'Attributes': {}}
+        if persist:
+            payload['Attributes']['ServerBoot.1.BootOnce'] = 'Disabled'
+        else:
+            payload['Attributes']['ServerBoot.1.BootOnce'] = 'Enabled'
+        if bootdev == 'floppy':
+            payload['Attributes']['ServerBoot.1.FirstBootDevice'] = 'vFDD'
+        elif bootdev == 'cd':
+            payload['Attributes']['ServerBoot.1.FirstBootDevice'] = 'VCD-DVD'
+        fishclient._do_web_request(
+            '/redfish/v1/Managers/iDRAC.Embedded.1/Attributes',
+            payload, method='PATCH')
+        return {'bootdev': bootdev}
diff --git a/confluent_server/aiohmi/redfish/oem/dell/main.py b/confluent_server/aiohmi/redfish/oem/dell/main.py
new file mode 100644
index 00000000..aa006ab1
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/dell/main.py
@@ -0,0 +1,20 @@
+# Copyright 2022 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from aiohmi.redfish.oem.dell import idrac
+
+
+async def get_handler(sysinfo, sysurl, webclient, cache, cmd, rootinfo={}):
+    return await idrac.OEMHandler.create(sysinfo, sysurl, webclient, cache,
+                            gpool=cmd._gpool)
diff --git a/confluent_server/aiohmi/redfish/oem/generic.py b/confluent_server/aiohmi/redfish/oem/generic.py
new file mode 100644
index 00000000..2cc2fae9
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/generic.py
@@ -0,0 +1,1663 @@
+# Copyright 2019-2022 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+from fnmatch import fnmatch
+import json
+import os
+import re
+import time
+import uuid
+
+import base64
+import copy
+import aiohmi.constants as const
+import aiohmi.exceptions as exc
+import aiohmi.media as media
+import aiohmi.util.webclient as webclient
+from aiohmi.util.parse import parse_time
+from datetime import datetime
+from datetime import timedelta
+from dateutil import tz
+import socket
+
+def _pem_to_dict(pemdata, uefi=False):
+    """Pull PEM into a dict
+
+    Accepts a file-like or a string or bytes.
+
+    A dict with the PEM as a value for CertificateString is created.
+    If uefi, then "UefiSignatureOwner" is also created with a random GUID.
+    This is how redfish expects certificate information for CAs to be provided for
+    UEFI and for itself.
+    """
+    if hasattr(pemdata, 'read'):
+        pemdata = pemdata.read()
+    if isinstance(pemdata, bytes):
+        pemdata = pemdata.decode('utf-8')
+    cert_dict = {
+        'CertificateString': pemdata,
+        'CertificateType': 'PEM',
+        }
+    if uefi:
+        cert_dict['UefiSignatureOwner'] = str(uuid.uuid4())
+    return cert_dict
+
+class SensorReading(object):
+    def __init__(self, healthinfo, sensor=None, value=None, units=None,
+                 unavailable=False):
+        if sensor:
+            self.name = sensor['name']
+        else:
+            self.name = healthinfo['Name']
+            self.health = _healthmap.get(healthinfo.get(
+                'Status', {}).get('Health', None), const.Health.Warning)
+            self.states = [healthinfo.get('Status', {}).get('Health',
+                                                            'Unknown')]
+            self.health = _healthmap[healthinfo['Status']['Health']]
+            self.states = [healthinfo['Status']['Health']]
+        self.value = value
+        self.state_ids = None
+        self.imprecision = None
+        self.units = units
+        self.unavailable = unavailable
+
+
+def _to_boolean(attrval):
+    attrval = attrval.lower()
+    if not attrval:
+        return False
+    if ('true'.startswith(attrval) or 'yes'.startswith(attrval)
+            or 'enabled'.startswith(attrval) or attrval == '1'):
+        return True
+    if ('false'.startswith(attrval) or 'no'.startswith(attrval)
+            or 'disabled'.startswith(attrval) or attrval == '0'):
+        return False
+    raise Exception(
+        'Unrecognized candidate for boolean: {0}'.format(attrval))
+
+
+def _normalize_mac(mac):
+    if ':' not in mac:
+        mac = ':'.join((
+            mac[:2], mac[2:4], mac[4:6],
+            mac[6:8], mac[8:10], mac[10:12]))
+    return mac.lower()
+
+
+_healthmap = {
+    'Critical': const.Health.Critical,
+    'Unknown': const.Health.Warning,
+    'Warning': const.Health.Warning,
+    'OK': const.Health.Ok,
+}
+
+boot_devices_write = {
+    'net': 'Pxe',
+    'network': 'Pxe',
+    'pxe': 'Pxe',
+    'hd': 'Hdd',
+    'usb': 'Usb',
+    'cd': 'Cd',
+    'cdrom': 'Cd',
+    'optical': 'Cd',
+    'dvd': 'Cd',
+    'floppy': 'Floppy',
+    'default': 'None',
+    'setup': 'BiosSetup',
+    'bios': 'BiosSetup',
+    'f1': 'BiosSetup',
+}
+
+boot_devices_read = {
+    'BiosSetup': 'setup',
+    'Cd': 'optical',
+    'Floppy': 'floppy',
+    'Hdd': 'hd',
+    'None': 'default',
+    'Pxe': 'network',
+    'Usb': 'usb',
+    'SDCard': 'sdcard',
+}
+
+
+class AttrDependencyHandler(object):
+    def __init__(self, dependencies, currsettings, pendingsettings):
+        self.dependencymap = {}
+        for dep in dependencies.get('Dependencies', [{}]):
+            if 'Dependency' not in dep:
+                continue
+            if dep['Type'] != 'Map':
+                continue
+            if dep['DependencyFor'] in self.dependencymap:
+                self.dependencymap[
+                    dep['DependencyFor']].append(dep['Dependency'])
+            else:
+                self.dependencymap[
+                    dep['DependencyFor']] = [dep['Dependency']]
+        self.curr = currsettings
+        self.pend = pendingsettings
+        self.reg = dependencies['Attributes']
+
+    def get_overrides(self, setting):
+        overrides = {}
+        blameattrs = []
+        if setting not in self.dependencymap:
+            return {}, []
+        for depinfo in self.dependencymap[setting]:
+            lastoper = None
+            lastcond = None
+            for mapfrom in depinfo.get('MapFrom', []):
+                if lastcond is not None and not lastoper:
+                    break  # MapTerm required to make sense of this, give up
+                currattr = mapfrom['MapFromAttribute']
+                blameattrs.append(currattr)
+                currprop = mapfrom['MapFromProperty']
+                if currprop == 'CurrentValue':
+                    if currattr in self.pend:
+                        currval = self.pend[currattr]
+                    elif currattr in self.curr:
+                        currval = self.curr[currattr]
+                    else:
+                        break  # The cited dependency attribute is missing, can't enforce
+                               # requested override                    
+                else:
+                    currval = self.reg[currattr][currprop]
+                lastcond = self.process(currval, mapfrom, lastcond, lastoper)
+                lastoper = mapfrom.get('MapTerms', None)
+            if lastcond:
+                if setting not in overrides:
+                    overrides[setting] = {}
+                if depinfo['MapToAttribute'] not in overrides[setting]:
+                    overrides[depinfo['MapToAttribute']] = {}
+                overrides[depinfo['MapToAttribute']][
+                    depinfo['MapToProperty']] = depinfo['MapToValue']
+        return overrides, blameattrs
+
+    def process(self, currval, mapfrom, lastcond, lastoper):
+        newcond = None
+        mfc = mapfrom['MapFromCondition']
+        if mfc == 'EQU':
+            newcond = currval == mapfrom['MapFromValue']
+        if mfc == 'NEQ':
+            newcond = currval != mapfrom['MapFromValue']
+        if mfc == 'GEQ':
+            newcond = float(currval) >= float(mapfrom['MapFromValue'])
+        if mfc == 'GTR':
+            newcond = float(currval) > float(mapfrom['MapFromValue'])
+        if mfc == 'LEQ':
+            newcond = float(currval) <= float(mapfrom['MapFromValue'])
+        if mfc == 'LSS':
+            newcond = float(currval) < float(mapfrom['MapFromValue'])
+        if lastcond is not None:
+            if lastoper == 'AND':
+                return lastcond and newcond
+            elif lastoper == 'OR':
+                return lastcond or newcond
+            return None
+        return newcond
+
+
+class OEMHandler(object):
+    hostnic = None
+    usegenericsensors = True
+    def _invalidate_url_cache(self, url):
+        if url is None:
+            return
+        if url in self._urlcache:
+            del self._urlcache[url]
+        if url + '?$expand=.' in self._urlcache:
+            del self._urlcache[url + '?$expand=.']
+    
+    @classmethod
+    async def create(cls, sysinfo, sysurl, webclient, cache, gpool=None, rootinfo={}):
+        self = cls()
+        self._gpool = gpool
+        self._varsysinfo = sysinfo
+        self._varsysurl = sysurl
+        self._varbmcurl = None
+        self._urlcache = cache
+        self.webclient = webclient
+        self._hwnamemap = {}
+        self._rootinfo = rootinfo
+        if not self._rootinfo:
+            self._rootinfo = await self.webclient.grab_json_response(
+                '/redfish/v1/')
+        self._varbmcurl = None
+        self._varsysurl = sysurl        
+        self._allsysurls = []
+        if sysurl is None:  # generic means we need to gather all systems
+            if 'Systems' in self._rootinfo:
+                systems = self._rootinfo['Systems']['@odata.id']
+                res = await self.webclient.grab_json_response_with_status(systems)
+                if res[1] == 200:
+                    members = res[0]['Members']
+                    for system in members:
+                        if system['@odata.id'] != sysurl:
+                            self._allsysurls.append(system['@odata.id'])
+        else:
+            self._allsysurls = [sysurl]
+        return self
+
+    async def get_screenshot(self, outfile):
+        raise exc.UnsupportedFunctionality(
+            'Retrieving screenshot is not implemented for this platform')
+
+    async def get_default_mgrurl(self):
+        if not self._varbmcurl and 'Managers' in self._rootinfo:
+            bmcoll = self._rootinfo['Managers']['@odata.id']
+            res = await self.webclient.grab_json_response_with_status(bmcoll)
+            if res[1] == 401:
+                raise exc.PyghmiException('Access Denied')
+            elif res[1] < 200 or res[1] >= 300:
+                raise exc.PyghmiException(repr(res[0]))
+            bmcs = res[0]['Members']
+            if len(bmcs) == 1:
+                self._varbmcurl = bmcs[0]['@odata.id']
+        return self._varbmcurl
+    
+    async def get_default_sysurl(self):
+        if not self._varsysurl and 'Systems' in self._rootinfo:
+            systems = self._rootinfo['Systems']['@odata.id']
+            res = await self.webclient.grab_json_response_with_status(systems)
+            if res[1] == 401:
+                raise exc.PyghmiException('Access Denied')
+            elif res[1] < 200 or res[1] >= 300:
+                raise exc.PyghmiException(repr(res[0]))
+            members = res[0]
+            systems = members['Members']
+            if self._varsysurl:
+                for system in systems:
+                    if system['@odata.id'] == self._varsysurl or system['@odata.id'].split('/')[-1] == self._varsysurl:
+                        self._varsysurl = system['@odata.id']
+                        break
+                else:
+                    raise exc.PyghmiException(
+                        'Specified sysurl not found: {0}'.format(self._varsysurl))
+            else:
+                if len(systems) > 1:
+                    systems = [x for x in systems if 'DPU' not in x['@odata.id']]
+                if len(systems) > 1:
+                    raise exc.PyghmiException(
+                        'Multi system manager, sysurl is required parameter')
+                if len(systems):
+                    self._varsysurl = systems[0]['@odata.id']
+                else:
+                    self._varsysurl = None
+        return self._varsysurl
+
+
+    async def supports_expand(self, url):
+        # Unfortunately, the state of expand in redfish is pretty dicey,
+        # so an OEM handler must opt into this behavior
+        # There is a way an implementation advertises support, however
+        # this isn't to be trusted.
+        # Even among some generally reputable implementations, they will fail in some scenarios
+        # and you'll see in their documentation "some urls will fail if you try to expand them"
+        # perhaps being specific, but other times being vague, but in either case,
+        # nothing programattic to consume to know when to do or not do an expand..
+        return False
+
+    async def get_system_power_watts(self, fishclient):
+        totalwatts = 0
+        gotpower = False
+        sysinfo = await fishclient.sysinfo()
+        for chassis in sysinfo.get('Links', {}).get('Chassis', []):
+            envinfo = await fishclient._get_chassis_env(chassis)
+            currwatts = envinfo.get('watts', None)
+            if currwatts is not None:
+                gotpower = True
+                totalwatts += envinfo['watts']
+        if not gotpower:
+            raise exc.UnsupportedFunctionality("System does not provide Power under redfish EnvironmentMetrics")
+        return totalwatts
+
+    async def _get_cpu_temps(self, fishclient):
+        cputemps = []
+        sysinfo = await fishclient.sysinfo()
+        for chassis in sysinfo.get('Links', {}).get('Chassis', []):
+            thermals = await fishclient._get_thermals(chassis)
+            for temp in thermals:
+                if temp.get('PhysicalContext', '') != 'CPU':
+                    continue
+                if temp.get('ReadingCelsius', None) is None:
+                    continue
+                cputemps.append(temp)
+        return cputemps
+
+    
+    async def get_bmcurl(self):
+        if not self._varbmcurl:
+            self._varbmcurl = (await self.sysinfo()).get('Links', {}).get(
+                'ManagedBy', [{}])[0].get('@odata.id', None)
+        return self._varbmcurl
+
+    
+    async def sysinfo(self):
+        sysurl = await self.get_default_sysurl()
+        return await self._do_web_request(sysurl)
+    
+    async def get_bmc_csr(self, keytype=None, keylength=None, cn=None, city=None,
+                    state=None, country=None, org=None, orgunit=None):
+        # A fun time here, the redfish specification is weird about this.
+        # We have a certificateservice, sounds good, and an action to generate a CSR,
+        # straightforward enough, but you have to indicate a certificate collection...
+        # We get a list of locations, so we have to infer the collection, which
+        # is perhaps odd, but a relatively safe bet.
+        # However, the purpose of the certificates is opaque, so we can only guess
+        # based on strings in the url if there is ambiguity.
+        rootinfo = await self._do_web_request('/redfish/v1/')
+        certserviceurl = rootinfo.get('CertificateService', {}).get('@odata.id', None)
+        if not certserviceurl:
+            raise exc.PyghmiException('No CertificateService found on platform')
+        certservice = await self._do_web_request(certserviceurl)
+        gencsractinfo = certservice.get('Actions', {}).get("#CertificateService.GenerateCSR", {})
+        curveids = gencsractinfo.get('KeyCurveId@Redfish.AllowableValues', [])
+        keylens = gencsractinfo.get('KeyBitLength@Redfish.AllowableValues', [])
+        keypairalgorithms = gencsractinfo.get('KeyPairAlgorithm@Redfish.AllowableValues', [])
+        selectedcurve = None
+        selectedkeylen = None
+        selectedkpa = None
+        if not keytype:
+            for kpa in keypairalgorithms:
+                if 'ECDH' in kpa:
+                    keytype = 'ECC'
+                    selectedkpa = kpa
+                    break
+                if 'RSA' in kpa:
+                    selectedkpa = kpa
+                    keytype = 'RSA'
+        if not keytype:
+            raise exc.PyghmiException('No valid key type found for CSR generation')
+        if keytype.upper() in ('ECC', 'ECDSA'):
+            if not curveids:
+                raise exc.PyghmiException('No valid curves found for ECC/ECDSA key type')
+            if keylength:
+                for curve in curveids:
+                    if fnmatch(curve, '*{0}'.format(keylength)):
+                        selectedcurve = curve
+                        break
+            else:
+                selectedcurve = curveids[-1]
+        elif keytype.upper() == 'RSA':
+            if not keylens:
+                raise exc.PyghmiException('No valid key lengths found for RSA key type')
+            if keylength:
+                allkeylens = []
+                for klp in keylens:
+                    if isinstance(klp, int):
+                        allkeylens.append(klp)
+                        continue
+                    for kl in klp.split(':'):
+                        allkeylens.append(int(kl))
+                if keylength not in allkeylens:
+                    raise exc.PyghmiException('Requested key length {0} not supported'.format(keylength))
+                selectedkeylen = keylength
+        gencsrtarg = gencsractinfo.get('target', None)
+        certcoll = await self.get_certificate_collection(certservice)
+        payload = {
+            'CertificateCollection': {"@odata.id": certcoll},
+            'City': city or 'Unspecified',
+            'CommonName': cn or self.webclient.thehost,
+            'Country': country or 'AQ',  # Need *a* valid two letter country code, Antarctica is more equally likely to be wrong than most.
+            'Organization': org or 'Unspecified',
+            'State': state or 'Unspecified',
+        }
+        if orgunit:
+            payload['OrganizationalUnit'] = orgunit
+        if selectedcurve:
+            payload['KeyCurveId'] = selectedcurve
+        elif selectedkeylen:
+            payload['KeyLength'] = selectedkeylen
+        if selectedkpa:
+            payload['KeyPairAlgorithm'] = selectedkpa
+        rsp = await self._do_web_request(gencsrtarg, payload)
+        csr = rsp.get('CSRString', None)
+        return csr
+
+    async def get_certificate_collection(self, certservice):
+        certcollections = set([])
+        certlocs = certservice.get('CertificateLocations', {}).get('@odata.id', None)
+        if certlocs:
+            certlocdata = await self._do_web_request(certlocs)
+            for cert in certlocdata.get('Links', {}).get('Certificates', []):
+                certurl = cert.get('@odata.id', None)
+                if not certurl:
+                    continue
+                # we need to remove the last part of url to get collection
+                collurl = '/'.join(certurl.split('/')[:-1])
+                certcollections.add(collurl)
+        if len(certcollections) == 0:
+            raise exc.PyghmiException('No certificate collections found for certificate operation')
+        if len(certcollections) > 1:
+            for candcoll in list(certcollections):
+                if 'TrustedCertificates' in candcoll:  # likely a CA store
+                    certcollections.discard(candcoll)
+                elif 'LDAP' in candcoll:  # certificate for LDAP server
+                    certcollections.discard(candcoll)
+                elif 'KMIP' in candcoll:  # not for TLS
+                    certcollections.discard(candcoll)
+                elif 'Boot/Certificates' in candcoll:
+                    certcollections.discard(candcoll)                
+        if len(certcollections) > 1:
+            raise exc.PyghmiException('Multiple certificate collections found, unable to infer intended target for certificate operation')
+        certcoll = list(certcollections)[0]
+        return certcoll
+
+    async def install_bmc_certificate(self, certdata):
+        rootinfo = await self._do_web_request('/redfish/v1/')
+        certserviceurl = rootinfo.get('CertificateService', {}).get('@odata.id', None)
+        if not certserviceurl:
+            raise exc.PyghmiException('No CertificateService found on platform')
+        certservice = await self._do_web_request(certserviceurl)
+        certlocs = certservice.get('CertificateLocations', {}).get('@odata.id', None)
+        if not certlocs:
+            raise exc.PyghmiException('No CertificateLocations found on platform')
+        certlocdata = await self._do_web_request(certlocs)
+        allcerts = set([])
+        for certloc in certlocdata.get('Links', {}).get('Certificates', []):
+            certurl = certloc.get('@odata.id', None)
+            if not certurl:
+                continue
+            allcerts.add(certurl)
+        if len(allcerts) == 0:
+            raise exc.PyghmiException('No Certificates found on platform')
+        elif len(allcerts) > 1:
+            # try to narrow down to server cert
+            for certurl in list(allcerts):
+                if 'TrustedCertificates' in certurl:
+                    allcerts.discard(certurl)
+                elif 'LDAP' in certurl:
+                    allcerts.discard(certurl)
+                elif 'KMIP' in certurl:
+                    allcerts.discard(certurl)
+                elif 'Boot/Certificates' in certurl:
+                    allcerts.discard(certurl)                
+        if len(allcerts) > 1:
+            raise exc.PyghmiException('Multiple Certificates found, unable to infer intended target for certificate installation')
+        targcerturl = list(allcerts)[0]
+        replacecerturl = certservice.get('Actions', {}).get(
+            '#CertificateService.ReplaceCertificate', {}).get('target', None)
+        certpayload = _pem_to_dict(certdata)
+        certpayload['CertificateUri'] = {'@odata.id': targcerturl}
+        #/redfish/v1/CertificateService/Actions/CertificateService.ReplaceCertificate
+        await self._do_web_request(replacecerturl, certpayload)
+
+    async def add_trusted_ca(self, pemdata):
+        mgrinfo = await self._do_web_request(await self.get_bmcurl())
+        secpolicy = mgrinfo.get('SecurityPolicy', {}).get('@odata.id', None)
+        if secpolicy:
+            secinfo = await self._do_web_request(secpolicy)
+            certcoll = secinfo.get('TLS', {}).get('Client', {}).get('TrustedCertificates', {}).get('@odata.id', None)
+            self._invalidate_url_cache(certcoll)
+            if certcoll:
+                certpayload = _pem_to_dict(pemdata)
+                await self._do_web_request(certcoll, certpayload)
+                self._invalidate_url_cache(certcoll)
+                return True
+        raise exc.PyghmiException('Platform does not support adding trusted CAs')
+
+    async def del_trusted_ca(self, certid):
+        mgrinfo = await self._do_web_request(await self.get_bmcurl())
+        secpolicy = mgrinfo.get('SecurityPolicy', {}).get('@odata.id', None)
+        if secpolicy:
+            secinfo = await self._do_web_request(secpolicy)
+            certcoll = secinfo.get('TLS', {}).get('Client', {}).get('TrustedCertificates', {}).get('@odata.id', None)
+            self._invalidate_url_cache(certcoll)
+            if certcoll:
+                certs = await self._get_expanded_data(certcoll)
+                certs = certs.get('Members', [])
+                for cert in certs:
+                    if cert.get('Id', '') == certid:
+                        await self._do_web_request(cert['@odata.id'], method='DELETE')
+                        self._invalidate_url_cache(certcoll)
+                        return True
+        raise exc.PyghmiException(f'No such certificate found: {certid}')
+
+    async def get_trusted_cas(self):
+        mgrinfo = await self._do_web_request(await self.get_bmcurl())
+        secpolicy = mgrinfo.get('SecurityPolicy', {}).get('@odata.id', None)
+        if secpolicy:
+            secinfo = await self._do_web_request(secpolicy)
+            certcoll = secinfo.get('TLS', {}).get('Client', {}).get('TrustedCertificates', {}).get('@odata.id', None)
+            if certcoll:
+                certs = await self._get_expanded_data(certcoll)
+                certs = certs.get('Members', [])
+                for cert in certs:
+                    certdesc = {
+                        'id': cert.get('Id', ''),
+                        'name': cert.get('Name', ''),
+                        'pem': cert.get('CertificateString', None),
+                        'subject': cert.get('Subject', {}).get('CommonName', ''),
+                        'sans': cert.get('Subject', {}).get('AlternativeNames', []),
+                        'issuer': cert.get('Issuer', {}).get('CommonName', ''),
+                        'validfrom': cert.get('ValidNotBefore', ''),
+                        'validto': cert.get('ValidNotAfter', ''),
+                    }
+                    yield certdesc
+
+    async def get_event_log(self, clear=False, fishclient=None, extraurls=[]):
+        bmcinfo = await self._do_web_request(await fishclient.get_bmcurl())
+        lsurl = bmcinfo.get('LogServices', {}).get('@odata.id', None)
+        if not lsurl:
+            return
+        currtime = bmcinfo.get('DateTime', None)
+        correction = timedelta(0)
+        utz = tz.tzoffset('', 0)
+        ltz = tz.gettz()
+        if currtime:
+            currtime = parse_time(currtime)
+        if currtime:
+            now = datetime.now(utz)
+            try:
+                correction = now - currtime
+            except TypeError:
+                correction = now - currtime.replace(tzinfo=utz)
+        lurls = (await self._do_web_request(lsurl)).get('Members', [])
+        lurls.extend(extraurls)
+        for lurl in lurls:
+            lurl = lurl['@odata.id']
+            try:
+                loginfo = await self._do_web_request(lurl, cache=(not clear))
+            except Exception:
+                record = {}
+                record['log_id'] = os.path.basename(lurl)
+                record['message'] = 'Could not retrieve log at {0}'.format(lurl)
+                record['severity'] = const.Health.Ok
+                record['timestamp'] = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
+                yield record
+                continue
+            loginfo = await self._do_web_request(lurl, cache=(not clear))
+            entriesurl = loginfo.get('Entries', {}).get('@odata.id', None)
+            if not entriesurl:
+                continue
+            logid = loginfo.get('Id', '')
+            entries = await self._do_web_request(entriesurl, cache=False)
+            if clear:
+                # The clear is against the log service etag, not entries
+                # so we have to fetch service etag after we fetch entries
+                # until we can verify that the etag is consistent to prove
+                # that the clear is atomic
+                newloginfo = await self._do_web_request(lurl, cache=False)
+                clearurl = newloginfo.get('Actions', {}).get(
+                    '#LogService.ClearLog', {}).get('target', '')
+                while clearurl:
+                    try:
+                        await self._do_web_request(clearurl, method='POST',
+                                            payload={})
+                        clearurl = False
+                    except exc.PyghmiException as e:
+                        if 'EtagPreconditionalFailed' not in str(e):
+                            raise
+                        # This doesn't guarantee atomicity, but it mitigates
+                        # greatly.  Unfortunately some implementations
+                        # mutate the tag endlessly and we have no hope
+                        entries = await self._do_web_request(entriesurl, cache=False)
+                        newloginfo = await self._do_web_request(lurl, cache=False)
+            for log in entries.get('Members', []):
+                if ('Created' not in log and 'Message' not in log
+                        and 'Severity' not in log):
+                    # without any data, this log entry isn't actionable
+                    continue
+                record = {}
+                record['log_id'] = logid
+                parsedtime = parse_time(log.get('Created', ''))
+                if not parsedtime:
+                    parsedtime = parse_time(log.get('EventTimestamp', ''))
+                if parsedtime:
+                    entime = parsedtime + correction
+                    entime = entime.astimezone(ltz)
+                    record['timestamp'] = entime.strftime('%Y-%m-%dT%H:%M:%S')
+                else:
+                    record['timestamp'] = log.get('Created', '')
+                record['message'] = log.get('Message', None)
+                record['severity'] = _healthmap.get(
+                    log.get('Severity', 'Warning'), const.Health.Ok)
+                yield record
+
+    async def get_average_processor_temperature(self, fishclient):
+        cputemps = await self._get_cpu_temps(fishclient)
+        if not cputemps:
+            return SensorReading(
+            None, {'name': 'Average Processor Temperature'}, value=None, units='°C',
+                   unavailable=True)
+        cputemps = [x['ReadingCelsius'] for x in cputemps]
+        avgtemp = sum(cputemps) / len(cputemps)
+        return SensorReading(
+            None, {'name': 'Average Processor Temperature'}, value=avgtemp, units='°C')
+
+
+    async def get_health(self, fishclient, verbose=True):
+        sysinfo = await self.sysinfo()
+        health = sysinfo.get('Status', {})
+        health = health.get('HealthRollup', health.get('Health', 'Unknown'))
+        warnunknown = health == 'Unknown'
+        health = _healthmap[health]
+        summary = {'badreadings': [], 'health': health}
+        if health > 0 and verbose:
+            # now have to manually peruse all psus, fans, processors, ram,
+            # storage
+            procsumstatus = sysinfo.get('ProcessorSummary', {}).get(
+                'Status', {})
+            procsumstatus = procsumstatus.get('HealthRollup',
+                                              procsumstatus.get('Health',
+                                                                None))
+            if procsumstatus != 'OK':
+                procfound = False
+                procurl = sysinfo.get('Processors', {}).get('@odata.id',
+                                                          None)
+                if procurl:
+                    for cpu in await fishclient._do_web_request(procurl).get(
+                            'Members', []):
+                        cinfo = await fishclient._do_web_request(cpu['@odata.id'])
+                        if cinfo.get('Status', {}).get(
+                                'State', None) == 'Absent':
+                            continue
+                        if cinfo.get('Status', {}).get(
+                                'Health', None) not in ('OK', None):
+                            procfound = True
+                            summary['badreadings'].append(SensorReading(cinfo))
+                if not procfound:
+                    procinfo = sysinfo['ProcessorSummary']
+                    procinfo['Name'] = 'Processors'
+                    summary['badreadings'].append(SensorReading(procinfo))
+            memsumstatus = sysinfo.get(
+                'MemorySummary', {}).get('Status', {})
+            memsumstatus = memsumstatus.get('HealthRollup',
+                                            memsumstatus.get('Health', None))
+            if memsumstatus != 'OK':
+                dimmfound = False
+                dimmdata = await self._get_mem_data()
+                for dimminfo in dimmdata:
+                    if dimminfo.get('Status', {}).get(
+                            'State', None) == 'Absent':
+                        continue
+                    if dimminfo.get('Status', {}).get(
+                            'Health', None) not in ('OK', None):
+                        summary['badreadings'].append(SensorReading(dimminfo))
+                        dimmfound = True
+                if not dimmfound:
+                    meminfo = sysinfo['MemorySummary']
+                    meminfo['Name'] = 'Memory'
+                    summary['badreadings'].append(SensorReading(meminfo))
+            for adapter in sysinfo['PCIeDevices']:
+                adpinfo = await fishclient._do_web_request(adapter['@odata.id'])
+                if adpinfo['Status']['Health'] not in ('OK', None):
+                    summary['badreadings'].append(SensorReading(adpinfo))
+            for fun in sysinfo['PCIeFunctions']:
+                funinfo = await fishclient._do_web_request(fun['@odata.id'])
+                if funinfo['Status']['Health'] not in ('OK', None):
+                    summary['badreadings'].append(SensorReading(funinfo))
+        if warnunknown and not summary['badreadings']:
+            unkinf = SensorReading({'Name': 'BMC',
+                                    'Status': {'Health': 'Unknown'}})
+            unkinf.states = ['System does not provide health information']
+            summary['badreadings'].append(unkinf)
+        return summary
+
+    async def user_delete(self, uid, fishclient):
+        # Redfish doesn't do so well with Deleting users either...
+        # Blanking the username seems to be the convention
+        # First, set a bogus password in case the implementation does honor
+        # blank user, at least render such an account harmless
+        try:
+            accinfo = await fishclient._account_url_info_by_id(uid)
+            if not accinfo:
+                raise Exception("No such account found")
+            await self._do_web_request(accinfo[0], method='DELETE')
+        except Exception: # fall back to old ipmi-like behavior for such implementations
+            await fishclient.set_user_password(uid, base64.b64encode(os.urandom(15)))
+            await fishclient.set_user_name(uid, '')        
+        return True
+
+    async def set_bootdev(self, bootdev, persist=False, uefiboot=None,
+                    fishclient=None):
+        """Set boot device to use on next reboot
+
+        :param bootdev:
+                        *network -- Request network boot
+                        *hd -- Boot from hard drive
+                        *safe -- Boot from hard drive, requesting 'safe mode'
+                        *optical -- boot from CD/DVD/BD drive
+                        *setup -- Boot into setup utility
+                        *default -- remove any directed boot device request
+        :param persist: If true, ask that system firmware use this device
+                        beyond next boot.  Be aware many systems do not honor
+                        this
+        :param uefiboot: If true, request UEFI boot explicitly.  If False,
+                         request BIOS style boot.
+                         None (default) does not modify the boot mode.
+        :raises: PyghmiException on an error.
+        :returns: dict or True -- If callback is not provided, the response
+        """
+        reqbootdev = bootdev
+        if (bootdev not in boot_devices_write
+                and bootdev not in boot_devices_read):
+            raise exc.InvalidParameterValue('Unsupported device %s'
+                                            % repr(bootdev))
+        bootdev = boot_devices_write.get(bootdev, bootdev)
+        if bootdev == 'None':
+            payload = {'Boot': {'BootSourceOverrideEnabled': 'Disabled'}}
+        else:
+            payload = {'Boot': {
+                'BootSourceOverrideEnabled': 'Continuous' if persist
+                                             else 'Once',
+                'BootSourceOverrideTarget': bootdev,
+            }}
+            if uefiboot is not None:
+                uefiboot = 'UEFI' if uefiboot else 'Legacy'
+                payload['BootSourceOverrideMode'] = uefiboot
+                try:
+                    await fishclient._do_web_request(self.sysurl, payload,
+                                               method='PATCH')
+                    return {'bootdev': reqbootdev}
+                except Exception:
+                    del payload['BootSourceOverrideMode']
+        #thetag = fishclient.sysinfo.get('@odata.etag', None)
+        await fishclient._do_web_request(fishclient.sysurl, payload, method='PATCH',
+                                   etag='*') # thetag)
+        return {'bootdev': reqbootdev}
+
+    def _get_cache(self, url):
+        now = os.times()[4]
+        cachent = self._urlcache.get(url, None)
+        if cachent and cachent['vintage'] > now - 30:
+            return cachent['contents']
+        return None
+
+    async def get_bmc_configuration(self):
+        return {}
+
+    async def set_bmc_configuration(self, changeset):
+        raise exc.UnsupportedFunctionality(
+            'Platform does not support setting bmc attributes')
+
+    async def _get_biosreg(self, url, fishclient):
+        addon = {}
+        valtodisplay = {}
+        displaytoval = {}
+        reg = await fishclient._do_web_request(url)
+        reg = reg['RegistryEntries']
+        for attr in reg['Attributes']:
+            vals = attr.get('Value', [])
+            if vals:
+                valtodisplay[attr['AttributeName']] = {}
+                displaytoval[attr['AttributeName']] = {}
+                for val in vals:
+                    valtodisplay[
+                        attr['AttributeName']][val['ValueName']] = val[
+                            'ValueDisplayName']
+                    displaytoval[
+                        attr['AttributeName']][val['ValueDisplayName']] = val[
+                            'ValueName']
+            defaultval = attr.get('DefaultValue', None)
+            defaultval = valtodisplay.get(attr['AttributeName'], {}).get(
+                defaultval, defaultval)
+            if attr['Type'] == 'Integer' and defaultval:
+                defaultval = int(defaultval)
+            if attr['Type'] == 'Boolean':
+                vals = [{'ValueDisplayName': 'True'},
+                        {'ValueDisplayName': 'False'}]
+            addon[attr['AttributeName']] = {
+                'default': defaultval,
+                'help': attr.get('HelpText', None),
+                'sortid': attr.get('DisplayOrder', None),
+                'possible': [x['ValueDisplayName'] for x in vals],
+            }
+        return addon, valtodisplay, displaytoval, reg
+
+    async def get_system_configuration(self, hideadvanced=True, fishclient=None):
+        return (await self._getsyscfg(fishclient))[0]
+
+    async def _get_attrib_registry(self, fishclient, attribreg):
+        overview = await fishclient._do_web_request('/redfish/v1/')
+        reglist = overview['Registries']['@odata.id']
+        reglist = await fishclient._do_web_request(reglist)
+        regurl = None
+        for cand in reglist.get('Members', []):
+            cand = cand.get('@odata.id', '')
+            candname = cand.split('/')[-1]
+            if candname == '':  # implementation uses trailing slash
+                candname = cand.split('/')[-2]
+            if candname == attribreg:
+                regurl = cand
+                break
+        if not regurl:
+            # Workaround a vendor bug where they link to a
+            # non-existant name
+            for cand in reglist.get('Members', []):
+                cand = cand.get('@odata.id', '')
+                candname = cand.split('/')[-1]
+                candname = candname.split('.')[0]
+                if candname == attribreg.split('.')[0]:
+                    regurl = cand
+                    break
+        if regurl:
+            reginfo = await fishclient._do_web_request(regurl)
+            for reg in reginfo.get('Location', []):
+                if reg.get('Language', 'en').startswith('en'):
+                    reguri = reg['Uri']
+                    reginfo = await self._get_biosreg(reguri, fishclient)
+                    return reginfo
+                    extrainfo, valtodisplay, _, self.attrdeps = reginfo
+
+
+    async def _getsyscfg(self, fishclient):
+        biosurl = await fishclient.get_biosurl()
+        biosinfo = await self._do_web_request(biosurl, cache=False)
+        reginfo = ({}, {}, {}, {})
+        extrainfo = {}
+        valtodisplay = {}
+        self.attrdeps = {'Dependencies': [], 'Attributes': []}
+        if 'AttributeRegistry' in biosinfo:
+            reginfo = await self._get_attrib_registry(fishclient, biosinfo['AttributeRegistry'])
+            if reginfo:
+                extrainfo, valtodisplay, _, self.attrdeps = reginfo
+        currsettings = {}
+        try:
+            pendingsettings = await fishclient._do_web_request(
+                await fishclient.get_setbiosurl())
+        except exc.UnsupportedFunctionality:
+            pendingsettings = {}
+        pendingsettings = pendingsettings.get('Attributes', {})
+        for setting in biosinfo.get('Attributes', {}):
+            val = biosinfo['Attributes'][setting]
+            currval = val
+            if setting in pendingsettings:
+                val = pendingsettings[setting]
+            val = valtodisplay.get(setting, {}).get(val, val)
+            currval = valtodisplay.get(setting, {}).get(currval, currval)
+            val = {'value': val}
+            if currval != val['value']:
+                val['active'] = currval
+            val.update(**extrainfo.get(setting, {}))
+            currsettings[setting] = val
+        return currsettings, reginfo
+
+    async def set_system_configuration(self, changeset, fishclient):
+        while True:
+            try:
+                await self._set_system_configuration(changeset, fishclient)
+                return
+            except exc.RedfishError as re:
+                if ('etag' not in re.msgid.lower()
+                        and 'PreconditionFailed' not in re.msgid):
+                    raise
+
+    async def _set_system_configuration(self, changeset, fishclient):
+        currsettings, reginfo = await self._getsyscfg(fishclient)
+        biosurl = await fishclient.get_biosurl()
+        rawsettings = await fishclient._do_web_request(biosurl,
+                                                 cache=False)
+        rawsettings = rawsettings.get('Attributes', {})
+        setbiosurl = await fishclient.get_setbiosurl()
+        pendingsettings = await fishclient._do_web_request(
+            setbiosurl)
+        return await self._set_redfish_settings(
+            changeset, fishclient, currsettings, rawsettings,
+            pendingsettings, self.attrdeps, reginfo,
+            setbiosurl)
+
+    async def _set_redfish_settings(self, inchangeset, fishclient, currsettings,                      
+                              rawsettings, pendingsettings, attrdeps, reginfo,
+                              seturl):
+
+        etag = pendingsettings.get('@odata.etag', None)
+        pendingsettings = pendingsettings.get('Attributes', {})
+        dephandler = AttrDependencyHandler(attrdeps, rawsettings,
+                                           pendingsettings)
+        changeset = copy.deepcopy(inchangeset)
+        for change in list(changeset):
+            if change not in currsettings:
+                found = False
+                for attr in currsettings:
+                    if fnmatch(attr.lower(), change.lower()):
+                        found = True
+                        changeset[attr] = changeset[change]
+                    if fnmatch(attr.lower(),
+                               change.replace('.', '_').lower()):
+                        found = True
+                        changeset[attr] = changeset[change]
+                if found:
+                    del changeset[change]
+        for change in changeset:
+            changeval = changeset[change]
+            overrides, blameattrs = dephandler.get_overrides(change)
+            meta = {}
+            for attr in attrdeps['Attributes']:
+                if attr['AttributeName'] == change:
+                    meta = dict(attr)
+                    break
+            meta.update(**overrides.get(change, {}))
+            if meta.get('ReadOnly', False) or meta.get('GrayOut', False):
+                errstr = '{0} is read only'.format(change)
+                if blameattrs:
+                    errstr += (' due to one of the following settings: '
+                               '{0}'.format(','.join(sorted(blameattrs)))
+                               )
+                raise exc.InvalidParameterValue(errstr)
+            if (currsettings.get(change, {}).get('possible', [])
+                    and changeval not in currsettings[change]['possible']):
+                normval = changeval.lower()
+                normval = re.sub(r'\s+', ' ', normval)
+                if not normval.endswith('*'):
+                    normval += '*'
+                for cand in currsettings[change]['possible']:
+                    if fnmatch(cand.lower().replace(' ', ''),
+                               normval.replace(' ', '')):
+                        changeset[change] = cand
+                        break
+                else:
+                    raise exc.InvalidParameterValue(
+                        '{0} is not a valid value for {1} ({2})'.format(
+                            changeval, change, ','.join(
+                                currsettings[change]['possible'])))
+            if changeset[change] in reginfo[2].get(change, {}):
+                changeset[change] = reginfo[2][change][changeset[change]]
+            for regentry in reginfo[3].get('Attributes', []):
+                if change in (regentry.get('AttributeName', ''),
+                              regentry.get('DisplayName', '')):
+                    if regentry.get('Type', None) == 'Integer':
+                        changeset[change] = int(changeset[change])
+                    if regentry.get('Type', None) == 'Boolean':
+                        changeset[change] = _to_boolean(changeset[change])
+        redfishsettings = {'Attributes': changeset}
+        await fishclient._do_web_request(
+           seturl, redfishsettings, 'PATCH', etag=etag)
+
+    async def attach_remote_media(self, url, username, password, vmurls):
+        return None
+
+    async def detach_remote_media(self):
+        return None
+
+    async def get_description(self):
+        for chassis in fishclient.sysinfo.get('Links', {}).get('Chassis', []):
+            chassisurl = chassis['@odata.id']
+            chassisinfo = await self._do_web_request(chassisurl)
+            hmm = chassisinfo.get('HeightMm', None)
+            if hmm:
+                return {'height': hmm/44.45}
+        return {}
+
+    def _extract_fwinfo(self, inf):
+        return {}
+
+    def get_firmware_inventory(self, components, fishclient, category=None):
+        return []
+
+    def set_credentials(self, username, password):
+        try:
+            self.username = username.decode('utf-8')
+        except AttributeError:
+            self.username = username
+        try:
+            self.password = password.decode('utf-8')
+        except AttributeError:
+            self.password = password
+
+    async def list_media(self, fishclient, cache=True):
+        bmcurl = await fishclient.get_bmcurl()
+        bmcinfo = await fishclient._do_web_request(bmcurl, cache=cache)
+        vmcoll = bmcinfo.get('VirtualMedia', {}).get('@odata.id', None)
+        if vmcoll:
+            vmlist = await fishclient._do_web_request(vmcoll, cache=cache)
+            vmurls = [x['@odata.id'] for x in vmlist.get('Members', [])]
+            async for vminfo in fishclient._do_bulk_requests(vmurls, cache=cache):
+                vminfo = vminfo[0]
+                if vminfo.get('Image', None):
+                    imageurl = vminfo['Image'].replace(
+                        '/' + vminfo['ImageName'], '')
+                    yield media.Media(vminfo['ImageName'], imageurl)
+                elif vminfo.get('Inserted', None) and vminfo.get(
+                        'ImageName', None):
+                    yield media.Media(vminfo['ImageName'])
+
+    async def get_inventory_descriptions(self, withids=False):
+        yield "System"
+        self._hwnamemap = {}
+        async for cpu in self._get_cpu_inventory(True, withids):
+            yield cpu
+        async for mem in self._get_mem_inventory(True, withids):
+            yield mem
+        async for adp in self._get_adp_inventory(True, withids):
+            yield adp
+
+    async def _get_node_info(self):
+        nodeinfo = self._varsysinfo
+        if not nodeinfo:
+            overview = await self._do_web_request('/redfish/v1/')
+            chassismembs = overview.get('Chassis', {}).get('@odata.id', None)
+            if not chassismembs:
+                return nodeinfo
+            chassislist = await self._do_web_request(chassismembs)
+            chassismembs = chassislist.get('Members', [])
+            if len(chassismembs) == 1:
+                chassisurl = chassismembs[0]['@odata.id']
+                nodeinfo = await self._do_web_request(chassisurl)
+        return nodeinfo
+
+    async def get_inventory_of_component(self, component):
+        if component.lower() == 'system':
+            nodeinfo = await self._get_node_info()
+            sysinfo = {
+                'UUID': nodeinfo.get('UUID', '').lower(),
+                'Serial Number': nodeinfo.get('SerialNumber', ''),
+                'Manufacturer': nodeinfo.get('Manufacturer', ''),
+                'Product name': nodeinfo.get('Model', ''),
+                'Model': nodeinfo.get(
+                    'SKU', nodeinfo.get('PartNumber', '')),
+            }
+            if sysinfo['UUID'] and '-' not in sysinfo['UUID']:
+                sysinfo['UUID'] = '-'.join((
+                    sysinfo['UUID'][:8], sysinfo['UUID'][8:12],
+                    sysinfo['UUID'][12:16], sysinfo['UUID'][16:20],
+                    sysinfo['UUID'][20:]))
+            sysinfo['UUID'] = sysinfo['UUID'].lower()
+
+            return sysinfo
+        else:
+            async for invpair in self.get_inventory():
+                if invpair[0].lower() == component.lower():
+                    return invpair[1]
+
+    async def get_inventory(self, withids=False):
+        sysinfo = {
+            'UUID': self._varsysinfo.get('UUID', ''),
+            'Serial Number': self._varsysinfo.get('SerialNumber', ''),
+            'Manufacturer': self._varsysinfo.get('Manufacturer', ''),
+            'Product name': self._varsysinfo.get('Model', ''),
+            'Model': self._varsysinfo.get(
+                'SKU', self._varsysinfo.get('PartNumber', '')),
+        }
+        if sysinfo['UUID'] and '-' not in sysinfo['UUID']:
+            sysinfo['UUID'] = '-'.join((
+                sysinfo['UUID'][:8], sysinfo['UUID'][8:12],
+                sysinfo['UUID'][12:16], sysinfo['UUID'][16:20],
+                sysinfo['UUID'][20:]))
+        sysinfo['UUID'] = sysinfo['UUID'].lower()
+        yield ('System', sysinfo)
+        self._hwnamemap = {}
+        adpurls = await self._get_adp_urls()
+        diskurls = await self._get_disk_urls()
+        allurls = adpurls + diskurls
+        list([x async for x in self._do_bulk_requests(allurls)])
+        async for cpu in self._get_cpu_inventory(withids=withids):
+            yield cpu
+        async for mem in self._get_mem_inventory(withids=withids):
+            yield mem
+        async for adp in self._get_adp_inventory(withids=withids, urls=adpurls):
+            yield adp
+        async for disk in self._get_disk_inventory(withids=withids, urls=diskurls):
+            yield disk
+
+    async def _get_disk_inventory(self, onlyname=False, withids=False, urls=None):
+        if not urls:
+            urls = await self._get_disk_urls()
+        async for inf in self._do_bulk_requests(urls):
+            inf, _ = inf
+            ddata = {
+                'Model': inf.get('Model', None),
+                'Serial Number': inf.get('SerialNumber', None),
+                'Description': inf.get('Name'),
+            }
+            loc = inf.get('PhysicalLocation', {}).get('Info', None)
+            if loc:
+                dname = 'Disk {0}'.format(loc)
+            else:
+                dname = inf.get('Id', 'Disk')
+            yield (dname, ddata)
+
+    async def _get_adp_inventory(self, onlyname=False, withids=False, urls=None):
+        foundmacs = False
+        macinfobyadpname = {}
+        if 'NetworkInterfaces' in self._varsysinfo:
+            nifdata = await self._get_expanded_data(
+                self._varsysinfo['NetworkInterfaces']['@odata.id'])
+            for nifinfo in nifdata.get('Members', []):
+                nadurl = nifinfo.get(
+                    'Links', {}).get('NetworkAdapter', {}).get("@odata.id")
+                if nadurl:
+                    nadinfo = await self._do_web_request(nadurl)
+                    if 'Name' not in nadinfo:
+                        continue
+                    nicname = nadinfo['Name']
+                    if nicname == 'NetworkAdapter':
+                        nicname = nadinfo.get('Model', nicname)                   
+                    yieldinf = {}
+                    macidx = 1
+                    if 'Ports' in nadinfo:
+                        for portinfo in (await self._get_expanded_data(
+                                nadinfo['Ports']['@odata.id'])).get('Members', []):
+                            ethinfo = portinfo.get('Ethernet', {})
+                            if ethinfo:
+                                macs = [x for x in ethinfo.get('AssociatedMACAddresses', [])]
+                                for mac in macs:
+                                    label = 'MAC Address {}'.format(macidx)
+                                    yieldinf[label] = _normalize_mac(mac)
+                                    macidx += 1
+                                    foundmacs = True
+                            ibinfo = portinfo.get('InfiniBand', {})
+                            if ibinfo:
+                                macs = [x for x in ibinfo.get('AssociatedPortGUIDs', [])]
+                                for mac in macs:
+                                    label = 'Port GUID {}'.format(macidx)
+                                    yieldinf[label] = mac
+                                    macidx += 1
+                                    foundmacs = True                            
+                        macinfobyadpname[nicname] = yieldinf
+                    else:
+                        for ctrlr in nadinfo.get('Controllers', []):
+                            porturls = [x['@odata.id'] for x in ctrlr.get(
+                                'Links', {}).get('Ports', [])]
+                            for porturl in porturls:
+                                portinfo = await self._do_web_request(porturl)
+                                macs = [x for x in portinfo.get(
+                                    'Ethernet', {}).get(
+                                        'AssociatedMACAddresses', [])]
+                                for mac in macs:
+                                    label = 'MAC Address {}'.format(macidx)
+                                    yieldinf[label] = _normalize_mac(mac)
+                                    macidx += 1
+                                    foundmacs = True
+                        macinfobyadpname[nicname] = yieldinf
+        if not urls:
+            urls = await self._get_adp_urls()
+        async for inf in self._do_bulk_requests(urls):
+            adpinfo, url = inf
+            aname = adpinfo.get('Name', 'Unknown')
+            if aname in self._hwnamemap:
+                aname = adpinfo.get('Id', aname)
+            if aname in self._hwnamemap:
+                self._hwnamemap[aname] = None
+            else:
+                self._hwnamemap[aname] = (url, self._get_adp_inventory)
+            if onlyname:
+                if withids:
+                    yield aname, adpinfo.get('Id', aname)
+                else:
+                    yield aname
+                continue
+            functions = adpinfo.get('Links', {}).get('PCIeFunctions', [])
+            nicidx = 1
+            if withids:
+                yieldinf = {'Id': adpinfo.get('Id', aname)}
+            else:
+                yieldinf = {}
+            if aname in macinfobyadpname:
+                yieldinf.update(macinfobyadpname[aname])
+            funurls = [x['@odata.id'] for x in functions]
+            async for fun in self._do_bulk_requests(funurls):
+                funinfo, url = fun
+                yieldinf['PCI Device ID'] = funinfo['DeviceId'].replace('0x',
+                                                                        '')
+                yieldinf['PCI Vendor ID'] = funinfo['VendorId'].replace('0x',
+                                                                        '')
+                yieldinf['PCI Subsystem Device ID'] = funinfo[
+                    'SubsystemId'].replace('0x', '')
+                yieldinf['PCI Subsystem Vendor ID'] = funinfo[
+                    'SubsystemVendorId'].replace('0x', '')
+                yieldinf['Type'] = funinfo['DeviceClass']
+                if aname not in macinfobyadpname:
+                    for nicinfo in funinfo.get('Links', {}).get(
+                            'EthernetInterfaces', []):
+                        nicinfo = await self._do_web_request(nicinfo['@odata.id'])
+                        macaddr = nicinfo.get('MACAddress', None)
+                        if macaddr:
+                            macaddr = _normalize_mac(macaddr)
+                            foundmacs = True
+                            yieldinf['MAC Address {0}'.format(nicidx)] = macaddr
+                            nicidx += 1
+            if aname in macinfobyadpname:
+                del macinfobyadpname[aname]
+            yield aname, yieldinf
+        if onlyname:
+            return
+        if macinfobyadpname:
+            for adp in macinfobyadpname:
+                yield adp, macinfobyadpname[adp]
+        if not foundmacs:
+            # No PCIe device inventory, but *maybe* ethernet inventory...
+            idxsbyname = {}
+            for nicinfo in self._get_eth_urls():
+                nicinfo = await self._do_web_request(nicinfo)
+                nicname = nicinfo.get('Name', None)
+                nicinfo = nicinfo.get('MACAddress', nicinfo.get('PermanentAddress', None))
+                if nicinfo and ':' not in nicinfo:
+                    nicinfo = ':'.join((
+                        nicinfo[:2], nicinfo[2:4], nicinfo[4:6], nicinfo[6:8],
+                        nicinfo[8:10], nicinfo[10:12]))
+                if not nicname:
+                    nicname = 'NIC'
+                if nicinfo:
+                    if nicname not in idxsbyname:
+                        idxsbyname[nicname] = 0
+                    idxsbyname[nicname] += 1
+                    nicinfo = nicinfo.lower()
+                    yield (nicname,
+                            {'MAC Address {}'.format(idxsbyname[nicname]): nicinfo})
+
+
+    async def _get_eth_urls(self):
+        ethurls = self._varsysinfo.get('EthernetInterfaces', {})
+        ethurls = ethurls.get('@odata.id', None)
+        if ethurls:
+            ethurls = await self._do_web_request(ethurls)
+            ethurls = ethurls.get('Members', [])
+            urls = [x['@odata.id'] for x in ethurls]
+        else:
+            urls = []
+        return urls
+
+    async def _get_adp_urls(self):
+        adpurls = self._varsysinfo.get('PCIeDevices', [])
+        if adpurls:
+            urls = [x['@odata.id'] for x in adpurls]
+        else:
+            urls = []
+        return urls
+
+    async def _get_cpu_inventory(self, onlynames=False, withids=False, urls=None):
+        async for currcpuinfo in self._get_cpu_data():
+            url = currcpuinfo['@odata.id']
+            name = currcpuinfo.get('Name', 'CPU')
+            if name in self._hwnamemap:
+                self._hwnamemap[name] = None
+            else:
+                self._hwnamemap[name] = (url, self._get_cpu_inventory)
+            if onlynames:
+                yield name
+                continue
+            cpuinfo = {'Model': currcpuinfo.get('Model', None)}
+            yield name, cpuinfo
+
+    async def _get_disk_urls(self):
+        storurl = self._varsysinfo.get('Storage', {}).get('@odata.id', None)
+        urls = []
+        if storurl:
+            storurl = await self._do_web_request(storurl)
+            for url in storurl.get('Members', []):
+                url = url['@odata.id']
+                ctldata = await self._do_web_request(url)
+                for durl in ctldata.get('Drives', []):
+                    urls.append(durl['@odata.id'])
+        return urls
+
+    def _get_cpu_urls(self):
+        md = self._get_cpu_data(False)
+        return [x['@odata.id'] for x in md]
+
+    async def _get_cpu_data(self, expand='.'):
+        for sysurl in self._allsysurls:
+            currsysdata = await self._do_web_request(sysurl)
+            currcpuurl = currsysdata.get('Processors', {}).get('@odata.id', None)
+            if currcpuurl:
+                currcpudata = await self._get_expanded_data(currcpuurl, expand)
+                for memb in currcpudata.get('Members', []):
+                    yield memb
+
+    async def _get_mem_inventory(self, onlyname=False, withids=False, urls=None):
+        memdata = await self._get_mem_data()
+        for currmeminfo in memdata:
+            url = currmeminfo['@odata.id']
+            name = currmeminfo.get('Name', 'Memory')
+            if name in self._hwnamemap:
+                self._hwnamemap[name] = None
+            else:
+                self._hwnamemap[name] = (url, self._get_mem_inventory)
+            if onlyname:
+                yield name
+                continue
+            if currmeminfo.get(
+                    'Status', {}).get('State', 'Absent') == 'Absent':
+                yield (name, None)
+                continue
+            currspeed = currmeminfo.get('OperatingSpeedMhz', None)
+            if currspeed:
+                currspeed = int(currspeed)
+                currspeed = currspeed * 8 - (currspeed * 8 % 100)
+            meminfo = {
+                'capacity_mb': currmeminfo.get('CapacityMiB', None),
+                'manufacturer': currmeminfo.get('Manufacturer', None),
+                'memory_type': currmeminfo.get('MemoryDeviceType', None),
+                'model': currmeminfo.get('PartNumber', None),
+                'module_type': currmeminfo.get('BaseModuleType', None),
+                'serial': currmeminfo.get('SerialNumber', None),
+                'speed': currspeed,
+            }
+            yield (name, meminfo)
+
+    async def _get_mem_urls(self):
+        md = await self._get_mem_data(False)
+        return [x['@odata.id'] for x in md]
+
+    async def _get_mem_data(self, expand='.'):
+        memmembers = []
+        for sysurl in self._allsysurls:
+            currsysdata = await self._do_web_request(sysurl)
+            currmemurl = currsysdata.get('Memory', {}).get('@odata.id', None)
+            if currmemurl:
+                currmemdata = await self._get_expanded_data(currmemurl, expand)
+                memmembers.extend(currmemdata.get('Members', []))
+        return memmembers        
+
+    async def _get_expanded_data(self, url, expand='.'):
+        topdata = []
+        if not url:
+            return topdata
+        if not expand:
+            return await self._do_web_request(url)
+        elif await self.supports_expand(url):
+            return await self._do_web_request(url + '?$expand=' + expand)
+        else:  # emulate expand behavior
+            topdata = await self._do_web_request(url)
+            newmembers = []
+            for x in topdata.get('Members', []):
+                newmembers.append(await self._do_web_request(x['@odata.id']))
+            topdata['Members'] = newmembers
+            return topdata
+        return topdata
+ 
+    async def get_ikvm_methods(self):
+        return []
+
+    async def get_ikvm_launchdata(self):
+        return {}
+
+    def get_storage_configuration(self):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    def remove_storage_configuration(self, cfgspec):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    def apply_storage_configuration(self, cfgspec):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    def check_storage_configuration(self, cfgspec):
+        raise exc.UnsupportedFunctionality(
+            'Remote storage configuration not supported on this platform')
+
+    def upload_media(self, filename, progress=None, data=None):
+        raise exc.UnsupportedFunctionality(
+            'Remote media upload not supported on this platform')
+
+    async def get_update_status(self):
+        upd = await self._do_web_request('/redfish/v1/UpdateService')
+        health = upd.get('Status', {}).get('Health', 'Unknown')
+        if health == 'OK':
+            return 'ready'
+        if health == 'Unknown' and upd.get('ServiceEnabled'):
+            return 'ready'       
+        return 'unavailable'
+
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None, otherfields=()):
+        # disable cache to make sure we trigger the token renewal logic if needed
+        usd, upurl, ismultipart = await self.retrieve_firmware_upload_url()
+        try:
+            uploadthread = await webclient.make_uploader(
+                self.webclient, upurl, filename, data, formwrap=ismultipart,
+                otherfields=otherfields)
+            wc = self.webclient
+            while not uploadthread.completed():
+                try:
+                    await uploadthread.join(3)
+                except asyncio.TimeoutError:
+                    pass
+                if progress:
+                    progress(
+                        {'phase': 'upload',
+                         'progress': 100 * await uploadthread.get_progress()})
+            rspstatus, rsp, headers = uploadthread.get_response()
+            if (rspstatus >= 300
+                    or rspstatus < 200):
+                errmsg = f'Update attempt resulted in response status {rspstatus}'
+                try:
+                    rsp = json.loads(rsp)
+                    errmsg = (
+                        rsp['error'][
+                            '@Message.ExtendedInfo'][0]['Message'])
+                except Exception:
+                    errmsg = errmsg + ': ' + repr(rsp)
+                    raise Exception(errmsg)
+                raise Exception(errmsg)
+            return await self.continue_update(rsp, progress)
+        finally:
+            if 'HttpPushUriTargetsBusy' in usd:
+                await self._do_web_request(
+                    '/redfish/v1/UpdateService',
+                    {'HttpPushUriTargetsBusy': False}, method='PATCH')
+
+    async def continue_update(self, rsp, progress):
+            monitorurl = rsp['@odata.id']
+            return await self.monitor_update_progress(monitorurl, progress)
+
+    async def monitor_update_progress(self, monitorurl, progress):
+            complete = False
+            phase = "apply"
+            statetype = 'TaskState'
+            # sometimes we get an empty pgress when transitioning from the apply phase to
+            # the validating phase; add a retry here so we don't exit the loop in this case
+            retry = 3
+            pct = 0.0
+            while not complete and retry > 0:
+                try:
+                    pgress = await self._do_web_request(monitorurl, cache=False)
+                except socket.timeout:
+                    pgress = None
+                if not pgress:
+                    retry -= 1
+                    await asyncio.sleep(3)
+                    continue
+                retry = 3
+                for msg in pgress.get('Messages', []):
+                    if 'Verify failed' in msg.get('Message', ''):
+                        raise Exception(msg['Message'])
+                state = pgress[statetype]
+                if state in ('Cancelled', 'Exception', 'Interrupted',
+                             'Suspended'):
+                    raise Exception(
+                        json.dumps(json.dumps(pgress['Messages'])))
+                if 'PercentComplete' in pgress:
+                    pct = float(pgress['PercentComplete'])
+                else:
+                    print(repr(pgress))
+                complete = state == 'Completed'
+                progress({'phase': phase, 'progress': pct})
+                if complete:
+                    msgs = pgress.get('Messages', [])
+                    if msgs and 'OperationTransitionedToJob' in msgs[0].get('MessageId', ''):
+                        monitorurl = pgress['Messages'][0]['MessageArgs'][0]
+                        phase = 'validating'
+                        statetype = 'JobState'
+                        complete = False
+                        await asyncio.sleep(3)
+                else:
+                    await asyncio.sleep(3)
+            if not retry:
+                raise Exception('Failed to monitor update progress due to excessive timeouts')
+            return 'pending'
+
+
+    async def retrieve_firmware_upload_url(self):
+        usd = await self._do_web_request('/redfish/v1/UpdateService', cache=False)
+        upurl = usd.get('MultipartHttpPushUri', None)
+        ismultipart = True
+        if not upurl:
+            ismultipart = False
+            if usd.get('HttpPushUriTargetsBusy', False):
+                raise exc.TemporaryError('Cannot run multtiple updates to '
+                                            'same target concurrently')
+            try:
+                upurl = usd['HttpPushUri']
+            except KeyError:
+                raise exc.UnsupportedFunctionality('Redfish firmware update only supported for implementations with push update support')
+            if 'HttpPushUriTargetsBusy' in usd:
+                await self._do_web_request('/redfish/v1/UpdateService',
+                    {'HttpPushUriTargetsBusy': True}, method='PATCH')
+                    
+        return usd,upurl,ismultipart
+
+
+    async def _do_bulk_requests(self, urls, cache=True):
+        if self._gpool:
+            urls = [(x, None, None, cache) for x in urls]
+            for res in self._gpool.starmap(self._do_web_request_withurl, urls):
+                yield res
+        else:
+            for url in urls:
+                yield await self._do_web_request_withurl(url, cache=cache)
+
+    async def _do_web_request_withurl(self, url, payload=None, method=None,
+                                cache=True):
+        return await self._do_web_request(url, payload, method, cache), url
+
+    async def _get_session_token(self, wc):
+        username = self.username
+        password = self.password
+        if not isinstance(username, str):
+            username = username.decode()
+        if not isinstance(password, str):
+            password = password.decode()
+        # specification actually indicates we can skip straight to this url
+        _, status, headers = await wc.grab_response_with_status('/redfish/v1/SessionService/Sessions',
+                          {'UserName': username, 'Password': password})
+        if status < 200 or status >= 300:
+            return
+        self.xauthtoken = headers.get('X-Auth-Token')
+        if self.xauthtoken:
+            if 'Authorization' in wc.stdheaders:
+                del wc.stdheaders['Authorization']
+            if 'Authorization' in self.webclient.stdheaders:
+                del self.webclient.stdheaders['Authorization']
+            wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+            self.webclient.stdheaders['X-Auth-Token'] = self.xauthtoken
+
+
+    async def _do_web_request(self, url, payload=None, method=None, cache=True, etag=None):
+        res = None
+        if cache and payload is None and method is None:
+            res = self._get_cache(url)
+        if res:
+            return res
+        # If doing a method that may change remote url state, invalidate cache
+        self._invalidate_url_cache(url)
+        wc = self.webclient.dupe()
+        if etag:
+            wc.stdheaders['If-Match'] = etag
+        res = await wc.grab_json_response_with_status(url, payload, method=method)
+        if res[1] == 401 and 'X-Auth-Token' in self.webclient.stdheaders:
+            wc.set_basic_credentials(self.username, self.password)
+            await self._get_session_token(wc)
+            if etag:
+                wc.stdheaders['If-Match'] = etag
+            res = await wc.grab_json_response_with_status(url, payload,
+                                                    method=method)
+        if res[1] < 200 or res[1] >= 300:
+            try:
+                info = json.loads(res[0])
+                errmsg = [
+                    x.get('Message', x['MessageId']) for x in info.get(
+                        'error', {}).get('@Message.ExtendedInfo', {})]
+                errmsg = ','.join(errmsg)
+                raise exc.RedfishError(errmsg)
+            except (ValueError, KeyError):
+                raise exc.PyghmiException(str(url) + ":" + res[0])
+        if payload is None and method is None:
+            self._urlcache[url] = {
+                'contents': res[0],
+                'vintage': os.times()[4]
+            }
+        return res[0]
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=None):
+        """Download diagnostic data about target to a file
+
+        This should be a payload that the vendor's support team can use
+        to do diagnostics.
+        :param savefile: File object or filename to save to
+        :param progress: Callback to be informed about progress
+        :param autosuffix: Have the library automatically amend filename per
+                           vendor support requirements.
+        :return:
+        """
+        raise exc.UnsupportedFunctionality(
+            'Retrieving diagnostic data is not implemented for this platform')
+
+    async def _get_license_collection_url(self, fishclient):
+        overview = await fishclient._do_web_request('/redfish/v1/')
+        licsrv = overview.get('LicenseService', {}).get('@odata.id', None)
+        if not licsrv:
+            raise exc.UnsupportedFunctionality()
+        lcs = await fishclient._do_web_request(licsrv)
+        licenses = lcs.get('Licenses', {}).get('@odata.id',None)
+        if not licenses:
+            raise exc.UnsupportedFunctionality()
+        return licenses
+
+    def get_extended_bmc_configuration(self, fishclient, hideadvanced=True):
+        raise exc.UnsupportedFunctionality()
+
+
+    async def _get_licenses(self, fishclient):
+        licenses = await self._get_license_collection_url(fishclient)
+        collection = await fishclient._do_web_request(licenses)
+        alllic = [x['@odata.id'] for x in collection.get('Members', [])]
+        for license in alllic:
+            licdet = await fishclient._do_web_request(license)
+            state = licdet.get('Status', {}).get('State')
+            if state != 'Enabled':
+                continue
+            yield licdet
+
+    async def get_licenses(self, fishclient):
+        async for licdet in self._get_licenses(fishclient):
+            name = licdet['Name']
+            yield {'name': name, 'state': 'Active'}
+
+    async def delete_license(self, name, fishclient):
+        async for licdet in self._get_licenses(fishclient):
+            lname = licdet['Name']
+            if name == lname:
+                await fishclient._do_web_request(licdet['@odata.id'], method='DELETE')
+
+    async def save_licenses(self, directory, fishclient):
+        async for licdet in self._get_licenses(fishclient):
+            dload = licdet.get('DownloadURI', None)
+            if dload:
+                filename = os.path.basename(dload)
+                savefile = os.path.join(directory, filename)
+                dler = webclient.make_downloader(fishclient.wc, dload, savefile)
+                await dler.join()
+                yield savefile
+
+    async def apply_license(self, filename, fishclient, progress=None, data=None):
+        licenses = await self._get_license_collection_url(fishclient)
+        if data is None:
+            data = open(filename, 'rb')
+        licdata = data.read()
+        lic64 = base64.b64encode(licdata).decode()
+        licinfo = {"LicenseString": lic64}
+        await fishclient._do_web_request(licenses, licinfo)
+
+
+    def get_user_expiration(self, uid):
+        return None
+
+    async def reseat_bay(self, bay):
+        raise exc.UnsupportedFunctionality(
+            'Reseat not supported on this platform')
diff --git a/confluent_server/aiohmi/redfish/oem/lenovo/__init__.py b/confluent_server/aiohmi/redfish/oem/lenovo/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/redfish/oem/lenovo/main.py b/confluent_server/aiohmi/redfish/oem/lenovo/main.py
new file mode 100644
index 00000000..bd2c83e7
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/lenovo/main.py
@@ -0,0 +1,66 @@
+# Copyright 2019 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.redfish.oem.generic as generic
+from aiohmi.redfish.oem.lenovo import tsma
+from aiohmi.redfish.oem.lenovo import xcc
+from aiohmi.redfish.oem.lenovo import xcc3
+from aiohmi.redfish.oem.lenovo import smm3
+
+
+async def get_handler(sysinfo, sysurl, webclient, cache, cmd, rootinfo={}):
+    if not sysinfo:  # we are before establishing there is one system, and one manager...
+        systems, status = await webclient.grab_json_response_with_status('/redfish/v1/Systems')
+        if status == 200:
+            for system in systems.get('Members', []):
+                if system.get('@odata.id', '').endswith('/1'):
+                    sysurl = system['@odata.id']
+                    sysinfo, status = await webclient.grab_json_response_with_status(sysurl)
+                    break
+    leninf = sysinfo.get('Oem', {}).get('Lenovo', {})
+    mgrinfo = {}
+    if leninf:
+        mgrinfo, status = await webclient.grab_json_response_with_status('/redfish/v1/Managers/1')
+        if status != 200:
+            mgrinfo = {}
+    if not leninf:
+        bmcinfo = await cmd.bmcinfo()
+        if 'Ami' in bmcinfo.get('Oem', {}):
+            return tsma.TsmHandler(sysinfo, sysurl, webclient, cache)
+    elif 'xclarity controller' in mgrinfo.get('Model', '').lower():
+        if mgrinfo['Model'].endswith('3'):
+            return await xcc3.OEMHandler.create(sysinfo, sysurl, webclient, cache,
+                                   gpool=cmd._gpool)
+        else:
+            return await xcc.OEMHandler.create(sysinfo, sysurl, webclient, cache,
+                                  gpool=cmd._gpool)
+    elif 'FrontPanelUSB' in leninf or 'USBManagementPortAssignment' in leninf or sysinfo.get('SKU', '').startswith('7X58'):
+        return await xcc.OEMHandler.create(sysinfo, sysurl, webclient, cache,
+                              gpool=cmd._gpool)
+    else:
+        leninv = sysinfo.get('Links', {}).get('OEM', {}).get(
+            'Lenovo', {}).get('Inventory', {})
+        if 'hdd' in leninv and 'hostMAC' in leninv and 'backPlane' in leninv:
+            return await tsma.TsmHandler.create(sysinfo, sysurl, webclient, cache,
+                                   gpool=cmd._gpool)
+    try:
+        devdesc = await webclient.grab_json_response_with_status('/DeviceDescription.json')
+        if devdesc[1] == 200:
+            if devdesc[0]['type'].lower() in ('lenovo-smm3', 'smm3'):
+                return smm3.OEMHandler(sysinfo, sysurl, webclient, cache,
+                                      gpool=cmd._gpool)
+    except Exception:
+        pass
+    return generic.OEMHandler(sysinfo, sysurl, webclient, cache,
+                            gpool=cmd._gpool)
diff --git a/confluent_server/aiohmi/redfish/oem/lenovo/smm3.py b/confluent_server/aiohmi/redfish/oem/lenovo/smm3.py
new file mode 100644
index 00000000..18b00026
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/lenovo/smm3.py
@@ -0,0 +1,277 @@
+# Copyright 2025 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import copy
+import os
+import aiohmi.redfish.oem.generic as generic
+import aiohmi.constants as pygconst
+import aiohmi.util.webclient as webclient
+import aiohmi.exceptions as exc
+import time
+import socket
+
+healthlookup = {
+    'ok': pygconst.Health.Ok,
+    'critical': pygconst.Health.Critical
+}
+
+def _baytonumber(bay):
+    try:
+        return int(bay)
+    except ValueError:
+        if len(bay) == 2:
+            # Treat a hexadecimal system as a leading decimal digit and letter compile
+            # 1a == slot 1, 1b == slot 2, 2a == slot 1, etc..
+            try:
+                tmp = int(bay, 16)
+                return (2 * (tmp >> 4) - 1) + ((tmp & 15) % 10)
+            except ValueError:
+                return None
+    return None
+
+
+def _baytolabel(bay):
+    try:
+        baynum =  int(bay)
+        if baynum < 1:
+            raise exc.UnsupportedFunctionality(
+                    'Reseat not supported for whole chassis')
+        # need to convert to 1a, 1b, etc...
+        vertidx = ((baynum - 1) // 2 + 1) << 4
+        horizidx = (baynum - 1) % 2 + 10
+        bayid = vertidx | horizidx
+        return '{:02x}'.format(bayid)
+    except ValueError:
+        return bay
+    return None
+
+class OEMHandler(generic.OEMHandler):
+    async def get_health(self, fishclient, verbose=True):
+        rsp = await self._do_web_request('/redfish/v1/Chassis/chassis1')
+        health = rsp.get('Status', {}).get('Health', 'Unknown').lower()
+        health = healthlookup.get(health, pygconst.Health.Critical)
+        return {'health': health}
+
+    async def set_identify(self, on=True, blink=False):
+        if on:
+            state = 'On'
+        elif blink:
+            state = 'Blinking'
+        else:
+            state = 'Off'
+        await self._do_web_request('/redfish/v1/Chassis/chassis1', {
+            'Oem': {'Lenovo': {'LED': {'IdentifyLED': {
+                'State': state
+                }}}
+            }}, method='PATCH')
+
+    async def get_system_configuration(self, hideadvanced=True, fishclient=None):
+        return {}
+
+    async def set_bmc_configuration(self, changeset):
+        chassisparms = {}
+        nodeparms = {}
+        for setting, value in changeset.items():
+            if setting == 'chassis_user_cap':
+                chassisparms.setdefault('Oem', {}).setdefault('Lenovo', {}).setdefault('PowerCap', {})['UserPowerCap'] = int(value)
+            elif setting == 'chassis_user_cap_active':
+                capstate = value.lower().startswith('enable')
+                chassisparms.setdefault('Oem', {}).setdefault('Lenovo', {}).setdefault('PowerCap', {})['UserPowerCapEnabled'] = capstate
+            elif setting.startswith('node_') and setting.endswith('_user_cap'):
+                nodeid = setting[5:-13]
+                nodeparms.setdefault(nodeid, {}).setdefault('PowerCap', {})['UserPowerCap'] = int(value)
+            elif setting.startswith('node_') and setting.endswith('_user_cap_active'):
+                nodeid = setting[5:-20]
+                capstate = value.lower().startswith('enable')
+                nodeparms.setdefault(nodeid, {}).setdefault('PowerCap', {})['UserPowerCapEnabled'] = capstate
+        if chassisparms:
+            await self._do_web_request('/redfish/v1/Chassis/chassis1', chassisparms, method='PATCH')
+        for nodeid, parms in nodeparms.items():
+            url = '/redfish/v1/Chassis/chassis1/Oem/Lenovo/Nodes/{}'.format(nodeid)
+            await self._do_web_request(url, parms, method='PATCH')
+
+    async def _get_cpu_inventory(self, withids=False):
+        # Empty generator: no CPU inventory items for this OEM handler.
+        if False:
+            yield None
+
+    async def _get_mem_inventory(self, withids=False):
+        # Empty generator: no memory inventory items for this OEM handler.
+        if False:
+            yield None
+
+    async def _get_adp_inventory(self, withids=False, urls=None):
+        # Empty generator: no adapter inventory items for this OEM handler.
+        if False:
+            yield None
+
+    async def _get_disk_inventory(self, withids=False, urls=None):
+        # Empty generator: no disk inventory items for this OEM handler.
+        if False:
+            yield None
+
+    async def get_bmc_configuration(self):
+        settings = {}
+        rsp = await self._do_web_request('/redfish/v1/Chassis/chassis1')
+        chassiscap = rsp.get('Oem', {}).get('Lenovo', {}).get('PowerCap', {})
+        usercap = chassiscap.get('UserPowerCap', None)
+        capstate = chassiscap.get('UserPowerCapEnabled', False)
+        mincap = chassiscap.get('MinimumPowerCap', None)
+        maxcap = chassiscap.get('MaximumPowerCap', None)
+        settings['chassis_user_cap'] = {
+            'value': usercap,
+            'help': 'Specify a maximum wattage to consume, this specific '
+                    'system implements a range from {0} to {1}.'.format(
+                        mincap, maxcap)
+        }
+        settings['chassis_user_cap_active'] = {
+            'value': 'Enable' if capstate else 'Disable',
+            'help': 'Specify whether the user capping setting should be '
+                    'used or not at the chassis level.',
+        }
+        rsp = await self._get_expanded_data('/redfish/v1/Chassis/chassis1/Oem/Lenovo/Nodes')
+        for noderesp in rsp.get('Members', []):
+            nodeid = noderesp.get('Id', 'unknown')
+            nodecap = noderesp.get('PowerCap', {})
+            usercap = nodecap.get('UserPowerCap', None)
+            capstate = nodecap.get('UserPowerCapEnabled', False)
+            mincap = nodecap.get('MinimumPowerCap', None)
+            maxcap = nodecap.get('MaximumPowerCap', None)
+            settings['node_{}_user_cap'.format(nodeid)] = {
+                'value': usercap,
+                'help': 'Specify a maximum wattage to consume for node '
+                        '{}, this specific node implements a range from '
+                        '{} to {}.'.format(
+                            nodeid, mincap, maxcap)
+            }
+            settings['node_{}_user_cap_active'.format(nodeid)] = {
+                'value': 'Enable' if capstate else 'Disable',
+                'help': 'Specify whether the user capping setting should be '
+                        'used or not at the node {} level.'.format(nodeid),
+            }
+        return settings
+
+    async def retrieve_firmware_upload_url(self):
+        # SMMv3 needs to do the non-multipart upload
+        usd = await self._do_web_request('/redfish/v1/UpdateService', cache=False)
+        if usd.get('HttpPushUriTargetsBusy', False):
+                raise exc.TemporaryError('Cannot run multtiple updates to '
+                                            'same target concurrently')
+        try:
+            upurl = usd['HttpPushUri']
+        except KeyError:
+            raise exc.UnsupportedFunctionality('Redfish firmware update only supported for implementations with push update support')
+        if 'HttpPushUriTargetsBusy' in usd:
+            await self._do_web_request(
+                '/redfish/v1/UpdateService',
+                {'HttpPushUriTargetsBusy': True}, method='PATCH')
+        return usd,upurl,False
+
+    async def continue_update(self, rsp, progress):
+        # SMMv3 does not provide a response, must hardcode the continuation
+        # /redfish/v1/UpdateService/FirmwareInventory/fwuimage
+        rsp = await self._do_web_request('/redfish/v1/UpdateService/FirmwareInventory/fwuimage')
+        for ri in rsp.get('RelatedItem', []):
+            targ = ri.get('@odata.id', None)
+        parms = {'Oem': {'Lenovo': {'SecureRollBack': False}}}
+        rsp = await self._do_web_request('/redfish/v1/UpdateService', parms, method='PATCH')
+        targspec = {'target': targ}
+        rsp = await self._do_web_request('/redfish/v1/UpdateService/Actions/UpdateService.StartUpdate', targspec)
+        monitorurl = rsp.get('@odata.id', None)
+        return await self.monitor_update_progress(monitorurl, progress)
+        
+
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        tsk = await self._do_web_request(
+            '/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.CollectDiagnosticData',
+            {"DiagnosticDataType": "Manager"})
+        taskrunning = True
+        taskurl = tsk.get('@odata.id', None)
+        pct = 0 if taskurl else 100
+        durl = None
+        while pct < 100 and taskrunning:
+            status = await self._do_web_request(taskurl)
+            durl = status.get('AdditionalDataURI', '')
+            pct = status.get('PercentComplete', 0)
+            taskrunning = status.get('TaskState', 'Complete') == 'Running'
+            if progress:
+                progress({'phase': 'initializing', 'progress': float(pct)})
+            if taskrunning:
+                await asyncio.sleep(3)
+        if not durl:
+            for hdr in status.get('Payload', {}).get('HttpHeaders', []):
+                if hdr.startswith('Location: '):
+
+                    enturl = hdr.replace('Location: ', '')
+                    entryinfo = await self._do_web_request(enturl)
+                    durl = entryinfo.get('AdditionalDataURI', None)
+                    break
+        if not durl:
+            raise Exception("Failed getting service data url")
+        fname = os.path.basename(durl)
+        if autosuffix and not savefile.endswith('.tar.xz'):
+            savefile += time.strftime('-SMM3_%Y%m%d_%H%M%S.tar.xz')
+        fd = webclient.make_downloader(self.webclient, durl, savefile)
+        while not fd.completed():
+            try:
+                await fd.join(1)
+            except asyncio.TimeoutError:
+                pass
+            if progress and await fd.get_progress():
+                progress({'phase': 'download',
+                          'progress': 100 * await fd.get_progress()})
+        if fd.exc:
+            raise fd.exc
+        if progress:
+            progress({'phase': 'complete'})
+        return savefile
+
+    def _extract_fwinfo(self, inf):
+        fwi, url = inf
+        currinf = {}
+        buildid = fwi.get('Oem', {}).get('Lenovo', {}).get('ExtendedVersion', None)
+        if buildid:
+            currinf['build'] = buildid
+        return currinf
+
+
+    async def _get_node_info(self):
+        nodeinfo = self._varsysinfo
+        if not nodeinfo:
+            overview = await self._do_web_request('/redfish/v1/')
+            chassismembs = overview.get('Chassis', {}).get('@odata.id', None)
+            if not chassismembs:
+                return nodeinfo
+            chassislist = await self._do_web_request(chassismembs)
+            chassismembs = chassislist.get('Members', [])
+            if len(chassismembs) == 1:
+                chassisurl = chassismembs[0]['@odata.id']
+                nodeinfo = await self._do_web_request(chassisurl)
+        newnodeinfo = copy.deepcopy(nodeinfo)
+        newnodeinfo['SKU'] = nodeinfo['Model']
+        newnodeinfo['Model'] = 'N1380 Enclosure'
+        return newnodeinfo
+
+    async def reseat_bay(self, bay):
+        bayid = _baytolabel(bay)
+        url = '/redfish/v1/Chassis/chassis1/Oem/Lenovo/Nodes/{}/Actions/Node.Reseat'.format(bayid)
+        rsp = await self._do_web_request(url, method='POST')
+
+    async def get_event_log(self, clear=False, fishclient=None):
+        return await super().get_event_log(clear, fishclient, extraurls=[{'@odata.id':'/redfish/v1/Chassis/chassis1/LogServices/EventLog'}])
+
+    async def get_description(self, fishclient):
+        return {'height': 13, 'slot': 0, 'slots': [8, 2]}
diff --git a/confluent_server/aiohmi/redfish/oem/lenovo/tsma.py b/confluent_server/aiohmi/redfish/oem/lenovo/tsma.py
new file mode 100644
index 00000000..7e2b6fac
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/lenovo/tsma.py
@@ -0,0 +1,888 @@
+# Copyright 2015-2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import os
+import struct
+import time
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+
+import aiohmi.exceptions as exc
+import aiohmi.media as media
+import aiohmi.redfish.oem.generic as generic
+import aiohmi.util.webclient as webclient
+
+hpm_by_filename = {}
+
+
+class HpmSection(object):
+    __slots__ = ['comp_id', 'comp_ver', 'comp_name', 'section_flash', 'data',
+                 'hash_size', 'combo_image']
+
+
+def cstr_to_str(cstr):
+    try:
+        endidx = cstr.index(b'\x00')
+        cstr = cstr[:endidx]
+    except Exception:
+        pass
+    if not isinstance(cstr, str):
+        cstr = cstr.decode('utf8')
+    return cstr
+
+
+def read_hpm(filename, data):
+    hpminfo = []
+    if data:
+        hpmfile = data
+        hpmfile.seek(0)
+    else:
+        hpmfile = open(filename, 'rb')
+    try:
+        hpmfile.seek(0x20)
+        skip = struct.unpack('>H', hpmfile.read(2))[0]
+        hpmfile.seek(skip + 1, 1)
+        sectype, compid = struct.unpack('BB', hpmfile.read(2))
+        while sectype == 2:
+            currsec = HpmSection()
+            currsec.comp_id = compid
+            hpmfile.seek(1, 1)
+            major, minor, pat = struct.unpack('<BBI', hpmfile.read(6))
+            currsec.comp_ver = '{0}.{1}.{2}'.format(major, minor, pat)
+            currsec.comp_name = hpmfile.read(21).rstrip(b'\x00')
+            currlen = struct.unpack('<I', hpmfile.read(4))[0] - 16
+            oemstr = hpmfile.read(4)
+            if oemstr != b'OEM\x00':
+                raise Exception(
+                    'Unrecognized HPM field near {0}'.format(hpmfile.tell()))
+            currsec.section_flash = struct.unpack('<I', hpmfile.read(4))[0]
+            hashpresent, hdrsize, blocks = struct.unpack('BBB',
+                                                         hpmfile.read(3))
+            if hashpresent != 1:
+                hashpresent = 0
+            currsec.hash_size = hashpresent * (256 * blocks + hdrsize)
+            hpmfile.seek(5, 1)
+            currsec.data = hpmfile.read(currlen)
+            hpminfo.append(currsec)
+            sectype, compid = struct.unpack('BB', hpmfile.read(2))
+        upimg = (hpminfo[1].data[:-hpminfo[1].hash_size]
+                 + hpminfo[2].data[:-hpminfo[2].hash_size])
+        hpminfo[2].combo_image = upimg
+        hpminfo[1].combo_image = upimg
+        currpos = hpmfile.tell()
+        hpmfile.seek(0, 2)
+        endpos = hpmfile.tell()
+        if currpos < (endpos - 512):
+            raise Exception("Unexpected end of HPM file")
+    finally:
+        if not data:
+            hpmfile.close()
+    return hpminfo
+
+
+class TsmHandler(generic.OEMHandler):
+    hostnic = 'usb0'
+
+    @classmethod
+    async def create(cls, sysinfo, sysurl, webclient, cache=None, fish=None,
+                 gpool=None):
+        self = await super(TsmHandler, cls).create(sysinfo, sysurl, webclient, cache, fish,
+                                         gpool)
+        if cache is None:
+            cache = {}
+        self._wc = None
+        self.username = None
+        self.password = None
+        self.csrftok = None
+        self.isipmi = bool(fish)
+        self.fish = fish
+        self.fishclient = None
+        self.tsm = webclient.thehost
+        self._certverify = webclient.verifycallback
+        return self
+
+    async def clear_bmc_configuration(self):
+        wc = await self.get_wc()
+        rsp, status = await wc.grab_json_response_with_status(
+                '/api/maintenance/restore_defaults',
+                {"id": 1,
+                 "sdr": 0,
+                 "fru": 1,
+                 "sel": 1,
+                 "ipmi": 1,
+                 "network": 1,
+                 "ntp": 1,
+                 "snmp": 1,
+                 "ssh": 1,
+                 "kvm": 1,
+                 "authentication": 1,
+                 "syslog": 0,
+                 "web": 1,
+                 "extlog": 0,
+                 "redfish": 1},
+                method='PUT')
+
+    async def get_bmc_configuration(self):
+        wc = await self.get_wc()
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/dns-info')
+        if status != 200:
+            raise Exception(repr(rsp))
+        settings = {}
+        settings['dns_domain'] = {
+            'value': rsp['domain_name']
+        }
+        dnssrvs = []
+        for idx in range(3):
+            currsrv = rsp.get('dns_server{0}'.format(idx + 1), '::')
+            if currsrv and currsrv != '::':
+                dnssrvs.append(currsrv)
+        settings['dns_servers'] = {'value': ','.join(dnssrvs)}
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/LockoutPolicystatus')
+        if status == 200:
+            isenabled = rsp.get('Status', 0) == 1
+            if isenabled:
+                settings['password_login_failures'] = {'value': rsp.get(
+                    'Attemptstimes', 0)}
+            else:
+                settings['password_login_failures'] = {'value': 0}
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/GetPWComplex')
+        if status == 200:
+            settings['password_complexity'] = {'value': rsp.get(
+                'pw_complex', 0)}
+        return settings
+
+    async def set_bmc_configuration(self, changeset):
+        dnschgs = {}
+        wc = await self.get_wc()
+        for key in changeset:
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            currval = changeset[key].get('value', None)
+            if 'dns_servers'.startswith(key.lower()):
+                srvs = currval.split(',')
+                for idx in range(3):
+                    if idx < len(srvs):
+                        dnschgs['dns_server{0}'.format(idx + 1)] = srvs[idx]
+                    else:
+                        dnschgs['dns_server{0}'.format(idx + 1)] = ''
+            if 'dns_domain'.startswith(key.lower()):
+                dnschgs['domain_name'] = currval
+            if 'password_complexity'.startswith(key.lower()):
+                self._set_pass_complexity(currval, wc)
+            if 'password_login_failures'.startswith(key.lower()):
+                await self._set_pass_lockout(currval, wc)
+        if dnschgs:
+            await self._set_dns_config(dnschgs, wc)
+
+    async def _set_pass_complexity(self, currval, wc):
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/SetPWComplex', {'Enable': currval})
+        if status != 200:
+            raise Exception(repr(rsp))
+
+    async def _set_pass_lockout(self, currval, wc):
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/LockoutPolicystatus')
+        if status != 200:
+            raise Exception(repr(rsp))
+        request = {
+            'SameStatus': 0,
+            'Lock_min': rsp.get('Locktime', 5),
+            'Rest_min': rsp.get('Resettime', 1),
+            'Attemptstimes': rsp.get('Attemptstimes', 3)
+        }
+        if currval == 0:
+            request['Enable'] = 0
+        else:
+            request['Enable'] = 1
+            request['Attemptstimes'] = currval
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/SetLockoutPolicy', request)
+        if status != 200:
+            raise Exception(repr(rsp))
+
+    async def _set_dns_config(self, dnschgs, wc):
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/dns-info')
+        if status != 200:
+            raise Exception(repr(rsp))
+        rsp['domain_manual'] = 1
+        for i in range(3):
+            keyn = 'dns_server{0}'.format(i + 1)
+            if rsp[keyn] == '::':
+                rsp[keyn] = ''
+        for chg in dnschgs:
+            rsp[chg] = dnschgs[chg]
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/dns-info', rsp, method='PUT')
+        if status != 200:
+            raise Exception(repr(rsp))
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/dns/restart', {'dns_status': 1}, method='PUT')
+        if status != 200:
+            raise Exception(repr(rsp))
+
+    async def clear_uefi_configuration(self):
+        if not self.fishclient:
+            await self.init_redfish()
+        return await self.fishclient.clear_system_configuration()
+
+    async def get_uefi_configuration(self, hideadvanced=True):
+        if not self.fishclient:
+            await self.init_redfish()
+        return await self.fishclient.get_system_configuration(hideadvanced)
+
+    async def set_uefi_configuration(self, changeset):
+        if not self.fishclient:
+            await self.init_redfish()
+        return await self.fishclient.set_system_configuration(changeset)
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        wc = await self.get_wc()
+        await wc.grab_json_response('/api/mini_ffdc', {'action': 'trigger'})
+        status = 1
+        percent = 0
+        while status == 1:
+            await asyncio.sleep(5)
+            check = await wc.grab_json_response('/api/mini_ffdc',
+                                          {'action': 'check'})
+            status = check.get('status', -1)
+            if progress:
+                progress({'phase': 'initializing', 'progress': float(percent)})
+            percent += 1
+        if status != 2:
+            raise Exception(
+                "Unknown error generating service data: " + repr(check))
+        if autosuffix and not savefile.endswith('.tar'):
+            savefile += '.tar'
+        fd = webclient.make_downloader(wc, '/api/mini_ffdc/package', savefile)
+        while not fd.completed():
+            try:
+                await fd.join(1)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                currprog = await fd.get_progress()
+                if currprog:
+                    progress({'phase': 'download',
+                              'progress': 100 * currprog})
+        if fd.exc:
+            raise fd.exc
+        if progress:
+            progress({'phase': 'complete'})
+        return savefile
+
+    async def init_redfish(self):
+        self.fishclient = await self.fish.Command.create(
+            self.tsm, self.username, self.password,
+            verifycallback=self._certverify)
+
+    async def get_ntp_enabled(self):
+        wc = await self.get_wc()
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/date-time')
+        if status != 200:
+            raise Exception(repr(rsp))
+        return rsp.get('ntp_auto_date', 0) > 0
+
+    async def set_ntp_enabled(self, enabled):
+        wc = await self.get_wc()
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/date-time')
+        if status != 200:
+            raise Exception(repr(rsp))
+        rsp['ntp_auto_date'] = 1 if enabled else 0
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/date-time', rsp, method='PUT')
+        if status != 200:
+            raise Exception(repr(rsp))
+
+    async def get_ntp_servers(self):
+        wc = await self.get_wc()
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/date-time')
+        if status != 200:
+            raise Exception(repr(rsp))
+        srvs = []
+        pntp = rsp.get('primary_ntp', None)
+        if pntp:
+            srvs.append(pntp)
+        pntp = rsp.get('secondary_ntp', None)
+        if pntp:
+            srvs.append(pntp)
+        return srvs
+
+    async def set_ntp_server(self, server, index=0):
+        wc = await self.get_wc()
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/date-time')
+        if status != 200:
+            raise Exception(repr(rsp))
+        if index == 0:
+            rsp['primary_ntp'] = server
+        elif index == 1:
+            rsp['secondary_ntp'] = server
+        rsp['ntp_auto_date'] = 1
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/settings/date-time', rsp, method='PUT')
+        if status != 200:
+            raise Exception(repr(rsp))
+
+    async def get_firmware_inventory(self, components, raisebypass=True,
+                               ipmicmd=None):
+        wc = await self.get_wc()
+        fwinf, status = await wc.grab_json_response_with_status(
+            '/api/DeviceVersion')
+        gotinfo = False
+        if status < 200 or status >= 300:
+            raise Exception('Error connecting to HTTP API')
+        for biosinf in fwinf:
+            if biosinf.get('device', None) != 1:
+                continue
+            if not biosinf.get('buildname', False):
+                break
+            biosres = {
+                'build': biosinf['buildname']
+            }
+            if biosinf.get('main', False):
+                biosres['version'] = '{0}.{1}'.format(
+                    biosinf['main'][0], biosinf['main'][1:])
+            yield ('UEFI', biosres)
+            gotinfo = True
+            break
+        for lxpminf in fwinf:
+            if lxpminf.get('device', None) != 2:
+                continue
+            if not lxpminf.get('buildname', False):
+                break
+            lxpmres = {
+                'build': lxpminf['buildname']
+            }
+            if lxpminf.get('main', False):
+                subver = lxpminf.get('sub', 0)
+                lxpmres['version'] = '{0}.{1:02x}'.format(
+                    lxpminf['main'], subver)
+            yield ('LXPM', lxpmres)
+        if ipmicmd:
+            rsp = await ipmicmd.raw_command(0x3c, 0x40, data=(7, 2))
+            buildid = cstr_to_str(bytes(rsp['data']))
+            yield ('LXPM Windows Driver Bundle', {'build': buildid})
+            rsp = await ipmicmd.raw_command(0x3c, 0x40, data=(7, 3))
+            buildid = cstr_to_str(bytes(rsp['data']))
+            yield ('LXPM Linux Driver Bundle', {'build': buildid})
+        name = 'TSM'
+        fwinf, status = await wc.grab_json_response_with_status('/api/get-sysfwinfo')
+        if status != 200:
+            raise Exception('Error {0} retrieving TSM version: {1}'.format(
+                status, fwinf))
+        for cinf in fwinf:
+            if 'fw_ver' not in cinf:
+                continue
+            if cinf.get('buildname', None) == 'N/A':
+                continue
+            if '.' not in cinf['fw_ver']:
+                continue
+            bmcinf = {
+                'version': cinf['fw_ver'],
+                'build': cinf['buildname'],
+                'date': cinf['builddate'],
+            }
+            yield (name, bmcinf)
+            gotinfo = True
+            name += ' Backup'
+        if not gotinfo:
+            raise Exception("Unable to retrieve firmware information")
+        if raisebypass:
+            raise exc.BypassGenericBehavior()
+
+    async def get_wc(self):
+        self.fwid = None
+        if self._wc:
+            rsp, status = await self._wc.grab_json_response_with_status(
+                '/api/chassis-status')
+            if status == 200:
+                return self._wc
+        authdata = {
+            'username': self.username,
+            'password': self.password,
+        }
+        wc = webclient.WebConnection(self.tsm, 443,
+                                            verifycallback=self._certverify,
+                                            timeout=180)
+        wc.set_header('Content-Type', 'application/json')
+        rsp, status = await wc.grab_json_response_with_status('/api/session',
+                                                        authdata)
+        if status == 403:
+            wc.set_header('Content-Type', 'application/x-www-form-urlencoded')
+            rsp, status = await wc.grab_json_response_with_status(
+                '/api/session', urlencode(authdata))
+
+        if status < 200 or status >= 300:
+            raise Exception('Error establishing web session')
+        self.csrftok = rsp['CSRFToken']
+        wc.set_header('X-CSRFTOKEN', self.csrftok)
+        self._wc = wc
+        return wc
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        wc = await self.get_wc()
+        wc.set_header('Content-Type', 'application/json')
+        basefilename = os.path.basename(filename)
+        if filename.endswith('.hpm'):
+            return await self.update_hpm_firmware(filename, progress, wc, data)
+        elif 'uefi' in basefilename and filename.endswith('.rom'):
+            return await self.update_sys_firmware(filename, progress, wc, data=data)
+        elif 'amd-sas' in basefilename and filename.endswith('.bin'):
+            return await self.update_sys_firmware(filename, progress, wc, data=data,
+                                            type='bp')
+        elif (('lxpm' in basefilename or 'fw_drv' in basefilename)
+                and filename.endswith('.img')):
+            return await self.update_lxpm_firmware(filename, progress, wc, data)
+        else:
+            raise Exception('Unsupported filename {0}'.format(filename))
+
+    async def update_lxpm_firmware(self, filename, progress, wc, data):
+        hdrs = wc.stdheaders.copy()
+        hdrs['Content-Length'] = 0
+        rsp = await wc.grab_json_response_with_status(
+            '/api/maintenance/LXPMUploadMode',
+            method='PUT', headers=hdrs)
+        # name fwimage filname filename application/x-raw-disk-image...
+        fu = await webclient.make_uploader(
+            wc, '/api/maintenance/LXPMUpload',
+            filename, data, formname='fwimage')
+        while not fu.completed():
+            try:
+                await fu.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({
+                    'phase': 'upload',
+                    'progress': 100 * await fu.get_progress()})
+        if progress:
+            progress({
+                'phase': 'apply',
+                'progress': 0.0}
+            )
+        await wc.grab_json_response('/api/maintenance/LXPMImageSplit', {'type': 3})
+        completion = False
+        while not completion:
+            rsp = await wc.grab_json_response('/api/maintenance/LXPMstatus')
+            if rsp.get('state') == 0 and rsp.get('progress') == 4:
+                break
+        await wc.grab_json_response_with_status(
+            '/api/maintenance/Outofflash', method='PUT', headers=hdrs)
+        return 'complete'
+
+    async def update_sys_firmware(self, filename, progress, wc, type='uefi',
+                            data=None):
+        if type == 'bp':
+            rsp = await wc.grab_json_response_with_status('/api/chassis-status')
+            if rsp[0]['power_status'] == 1:
+                raise Exception("Cannot update BP firmware while system is on")
+            updatemode = 'BPUploadMode'
+            fileupload = 'BPfileUpload'
+            startit = 'BPUpgradeStart'
+            statusname = 'BPstatus'
+        else:
+            updatemode = 'flash'
+            rsp = await wc.grab_json_response_with_status(
+                '/api/maintenance/BIOSremoteSave',
+                {"tftpip": "",
+                 "tftpfile": ""}
+            )
+            fileupload = 'firmware/BIOS'
+            startit = 'BIOSstart'
+            statusname = 'BIOSstatus'
+        hdrs = wc.stdheaders.copy()
+        hdrs['Content-Length'] = 0
+        rsp = await wc.grab_json_response_with_status(
+            '/api/maintenance/{0}'.format(updatemode),
+            method='PUT', headers=hdrs)
+        fu = await webclient.make_uploader(
+            wc, '/api/maintenance/{0}'.format(fileupload), filename, data,
+            formname='fwimage')
+        while not fu.completed():
+            try:
+                await fu.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({
+                    'phase': 'upload',
+                    'progress': 100 * await fu.get_progress()})
+        if progress:
+            progress({
+                'phase': 'apply',
+                'progress': 0.0}
+            )
+        rsp = await wc.grab_json_response_with_status(
+            '/api/maintenance/{0}'.format(startit))
+        applypct = 0.0
+        if rsp[1] >= 200 and rsp[1] < 300 and rsp[0]['wRet'] == 0:
+            updone = False
+            while not updone:
+                rsp = await wc.grab_json_response(
+                    '/api/maintenance/{0}'.format(statusname))
+                if rsp.get('state', 0) == 9:
+                    break
+                if rsp.get('state', 0) in (6, 10):
+                    raise Exception('Update Failure')
+                if (rsp.get('state', 0) == 8
+                        and rsp.get('progress', 0) > 0 and progress):
+                    progress({
+                        'phase': 'apply',
+                        'progress': 70 + float(rsp.get(
+                            'progress', 0)) / 100 * 30})
+                elif type == 'bp' and rsp.get('state', 0) == 1:
+                    break
+                elif progress and applypct < 70:
+                    applypct += 1.4
+                    progress({'phase': 'apply', 'progress': applypct})
+            if type == 'bp':
+                rsp = await wc.grab_json_response('/api/maintenance/BPfinish')
+                hdrs = wc.stdheaders.copy()
+                hdrs['Content-Length'] = 0
+                rsp = await wc.grab_json_response_with_status(
+                    '/api/maintenance/Outofflash', method='PUT', headers=hdrs)
+                return 'complete'
+            return 'pending'
+        raise Exception('Update Failure')
+
+    async def update_hpm_firmware(self, filename, progress, wc, data):
+        rsp = await wc.grab_json_response('/api/maintenance/hpm/freemem')
+        if 'MemFree' not in rsp:
+            raise Exception('System Not Ready for update')
+        if filename not in hpm_by_filename:
+            hpminfo = read_hpm(filename, data)
+            if len(hpminfo) != 3:
+                raise Exception(
+                    'This HPM update is currently not supported')
+            hpm_by_filename[filename] = read_hpm(filename, data)
+        else:
+            hpminfo = hpm_by_filename[filename]
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/hpm/updatemode', method='PUT')
+        # first segment, make sure it is mmc,
+        # then do the preparecomponents with the following payload
+        if status != 200:
+            raise Exception(rsp)
+        uid = rsp['unique_id']
+        self.fwid = uid
+        payload = {
+            'FWUPDATEID': uid,
+            'COMPONENT_ID': 1,
+            'COMPONENT_DATA_LEN': len(hpminfo[0].data),
+            'IS_MMC': 1,
+        }
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/hpm/preparecomponents', payload, method='PUT')
+        if status < 200 or status >= 300:
+            await wc.grab_json_response_with_status(
+                '/api/maintenance/hpm/exitupdatemode', {'FWUPDATEID': uid},
+                method='PUT')
+            raise Exception(rsp)
+        fu = await webclient.make_uploader(
+            wc, '/api/maintenance/hpm/mmcfw', 'blob', hpminfo[0].data, 'mmc')
+        if progress:
+            progress({'phase': 'upload', 'progress': 0.0})
+        fu.start()
+        while not fu.completed():
+            try:
+                await fu.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({
+                    'phase': 'upload',
+                    'progress': 50 * await fu.get_progress()})
+        del payload['IS_MMC']
+        payload['SECTION_FLASH'] = hpminfo[0].section_flash
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/hpm/flash', payload, method='PUT')
+        percent = 0
+        while percent < 100:
+            rsp, status = await wc.grab_json_response_with_status(
+                '/api/maintenance/hpm/upgradestatus?COMPONENT_ID=1')
+            if status < 200 or status >= 300:
+                raise Exception(rsp)
+            percent = rsp['PROGRESS']
+            if progress:
+                progress({
+                    'phase': 'apply',
+                    'progress': .5 * percent})
+            if percent < 100:
+                await asyncio.sleep(3)
+        if progress:
+            progress({'phase': 'validating', 'progress': 0.0})
+        del payload['SECTION_FLASH']
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/hpm/verifyimage', payload, method='PUT')
+        percent = 0
+        while percent < 100:
+            rsp, status = await wc.grab_json_response_with_status(
+                '/api/maintenance/hpm/verifyimagestatus?COMPONENT_ID=1')
+            if status < 200 or status >= 300:
+                raise Exception(rsp)
+            percent = rsp['PROGRESS']
+            if progress:
+                progress({
+                    'phase': 'validating',
+                    'progress': 0.5 * percent})
+            if percent < 100:
+                await asyncio.sleep(3)
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/hpm/exitupdatemode', {'FWUPDATEID': uid},
+            method='PUT')
+        fu = await webclient.make_uploader(wc, '/api/maintenance/firmware/firmware',
+                                          'blob', hpminfo[1].combo_image, 'fwimage')
+        fu.start()
+        while not fu.completed():
+            try:
+                await fu.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({
+                    'phase': 'upload',
+                    'progress': 50 * await fu.get_progress() + 50})
+        rsp = await wc.grab_json_response('/api/maintenance/firmware/verification')
+        upgradeparms = {
+            'preserve_config': 1,
+            'flash_status': 1,
+        }
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/firmware/upgrade',
+            upgradeparms, method='PUT')
+        if progress:
+            progress({'phase': 'apply', 'progress': 50.0})
+        applied = False
+        while not applied:
+            rsp = await wc.grab_json_response(
+                '/api/maintenance/firmware/flash-progress')
+            percent = float(rsp['progress'].split('%')[0])
+            percent = percent * 0.5 + 50
+            if progress:
+                progress({'phase': 'apply', 'progress': percent})
+            if rsp['progress'] == '100% done' and rsp['state'] == 0:
+                applied = True
+                break
+            await asyncio.sleep(3)
+        hdrs = wc.stdheaders.copy()
+        hdrs['Content-Length'] = 0
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/maintenance/reset', method='POST', headers=hdrs)
+        self._wc = None
+        return 'complete'
+
+    async def _detach_all_media(self, wc, slots):
+        for slot in slots:  # Stop all active redirections to reconfigure
+            if slot['redirection_status'] != 0:
+                await wc.grab_json_response(
+                    '/api/settings/media/remote/stop-media',
+                    {'image_name': slot['image_name'],
+                     'image_type': slot['media_type'],
+                     'image_index': slot['media_index']})
+
+    async def detach_remote_media(self):
+        wc = await self.get_wc()
+        slots = await wc.grab_json_response(
+            '/api/settings/media/remote/configurations')
+        await self._detach_all_media(wc, slots)
+        if not self.isipmi:
+            raise exc.BypassGenericBehavior()
+
+    async def _allocate_slot(self, slots, filetype, wc, server, path):
+        currhdds = []
+        currisos = []
+        for slot in slots:
+            if slot['image_name']:
+                if slot['media_type'] == 1:
+                    currisos.append(slot['image_name'])
+                elif slot['media_type'] == 4:
+                    currhdds.append(slot['image_name'])
+                else:
+                    raise exc.UnsupportedFunctionality(
+                        'Unrecognized mounted image: ' + repr(slot))
+        hddslots = len(currhdds)
+        cdslots = len(currisos)
+        if filetype == 1:
+            cdslots += 1
+        elif filetype == 4:
+            hddslots += 1
+        else:
+            raise exc.UnsupportedFunctionality('Unknown slot type requested')
+        gensettings = wc.grab_json_response('/api/settings/media/general')
+        samesettings = gensettings['same_settings'] == 1
+        if samesettings:
+            hds = gensettings['cd_remote_server_address']
+            hdp = gensettings['cd_remote_source_path'].replace('\\/', '/')
+        else:
+            hds = gensettings['hd_remote_server_address']
+            hdp = gensettings['hd_remote_source_path'].replace('\\/', '/')
+        if filetype == 1 and (currisos or (samesettings and currhdds)):
+            if gensettings['cd_remote_server_address'] != server:
+                raise exc.UnsupportedFunctionality(
+                    'Cannot mount ISO images from multiple '
+                    'servers at a time')
+            if gensettings['cd_remote_source_path'].replace(
+                    '\\/', '/') != path:
+                raise exc.UnsupportedFunctionality(
+                    'Cannot mount ISO images from different '
+                    'directories at a time')
+        if filetype == 4 and currhdds:
+            if hds != server:
+                raise exc.UnsupportedFunctionality(
+                    'Cannot mount IMG images from multiple servers at a time')
+            if hdp != path:
+                raise exc.UnsupportedFunctionality(
+                    'Cannot mount IMG images from muliple directories at a '
+                    'time')
+        await self._detach_all_media(wc, slots)
+        if filetype == 1 or (samesettings and currhdds):
+            gensettings['cd_remote_server_address'] = server
+            gensettings['cd_remote_source_path'] = path
+            gensettings['cd_remote_share_type'] = 'nfs'
+            gensettings['mount_cd'] = 1
+        elif filetype == 4:
+            gensettings['same_settings'] = 0
+            gensettings['hd_remote_server_address'] = server
+            gensettings['hd_remote_source_path'] = path
+            gensettings['hd_remote_share_type'] = 'nfs'
+            gensettings['mount_hd'] = 1
+        gensettings['remote_media_support'] = 1
+        gensettings['cd_remote_password'] = ''
+        gensettings['hd_remote_password'] = ''
+        wc.grab_json_response_with_status('/api/settings/media/general',
+                                          gensettings, method='PUT')
+        # need to calibrate instances correctly
+        currinfo, status = wc.grab_json_response_with_status(
+            '/api/settings/media/instance')
+        currinfo['num_cd'] = cdslots
+        currinfo['num_hd'] = hddslots
+        if currinfo['kvm_num_cd'] > cdslots:
+            currinfo['kvm_num_cd'] = cdslots
+        if currinfo['kvm_num_hd'] > hddslots:
+            currinfo['kvm_num_hd'] = hddslots
+        wc.grab_json_response_with_status(
+            '/api/settings/media/instance', currinfo, method='PUT')
+        images = wc.grab_json_response('/api/settings/media/remote/images')
+        tries = 20
+        while tries and not images:
+            tries -= 1
+            await asyncio.sleep(1)
+            images = await wc.grab_json_response('/api/settings/media/remote/images')
+        for iso in currisos:
+            await self._exec_mount(iso, images, wc)
+        for iso in currhdds:
+            await self._exec_mount(iso, images, wc)
+
+    async def _exec_mount(self, name, images, wc):
+        for img in images:
+            if img['image_name'] == name:
+                break
+        else:
+            raise exc.InvalidParameterValue(
+                'Unable to locate image {0}'.format(name))
+        await wc.grab_json_response(
+            '/api/settings/media/remote/start-media',
+            {'image_name': name, 'image_type': img['image_type'],
+             'image_index': img['image_index']})
+
+    async def upload_media(self, filename, progress=None, data=None):
+        raise exc.UnsupportedFunctionality(
+            'Remote media upload not supported on this system')
+
+    async def list_media(self, fishclient=None, cache=True):
+        wc = await self.get_wc()
+        rsp = await wc.grab_json_response('/api/settings/media/general')
+        cds = rsp['cd_remote_server_address']
+        cdpath = rsp['cd_remote_source_path']
+        cdproto = rsp['cd_remote_share_type']
+        if rsp['same_settings'] == 1:
+            hds = cds
+            hdpath = cdpath
+            hdproto = cdproto
+        else:
+            hds = rsp['hd_remote_server_address']
+            hdpath = rsp['hd_remote_source_path']
+            hdproto = rsp['hd_remote_share_type']
+        slots = await wc.grab_json_response(
+            '/api/settings/media/remote/configurations')
+        for slot in slots:
+            if slot['redirection_status'] == 1:
+                url = None
+                if slot['media_type'] == 1:
+                    url = '{0}://{1}{2}'.format(
+                        cdproto, cds, cdpath)
+                elif slot['media_type'] == 4:
+                    url = '{0}://{1}{2}'.format(
+                        hdproto, hds, hdpath)
+                if url:
+                    yield media.Media(slot['image_name'], url)
+
+    async def attach_remote_media(self, url, user, password, vmurls):
+        if not url.startswith('nfs://'):
+            raise exc.UnsupportedFunctionality(
+                'Only nfs:// urls are supported by this system')
+        path = url.replace('nfs://', '')
+        server, path = path.split('/', 1)
+        path, filename = path.rsplit('/', 1)
+        path = '/' + path
+        filetype = filename.rsplit('.')[-1]
+        if filetype == 'iso':
+            filetype = 1
+        elif filetype == 'img':
+            filetype = 4
+        else:
+            raise exc.UnsupportedFunctionality(
+                'Only iso and img files supported')
+        wc = await self.get_wc()
+        mountslots = await wc.grab_json_response(
+            '/api/settings/media/remote/configurations')
+        images = await wc.grab_json_response('/api/settings/media/remote/images')
+        currtypeenabled = False
+        for slot in mountslots:
+            if slot['image_name'] == filename:
+                return  # Already mounted...
+        for img in images:
+            if img['image_name'] == filename:
+                break
+            if img['image_type'] == filetype:
+                currtypeenabled = True
+        else:
+            if currtypeenabled:
+                raise exc.UnsupportedFunctionality(
+                    'This system cannot mount images '
+                    'from different locations at the same time')
+            img = None
+        for slot in mountslots:
+            if slot['media_type'] != filetype:
+                continue
+            if slot['redirection_status'] == 0:
+                break
+        else:
+            await self._allocate_slot(mountslots, filetype, wc, server, path)
+        images = await wc.grab_json_response('/api/settings/media/remote/images')
+        await self._exec_mount(filename, images, wc)
+        if not self.isipmi:
+            raise exc.BypassGenericBehavior()
diff --git a/confluent_server/aiohmi/redfish/oem/lenovo/xcc.py b/confluent_server/aiohmi/redfish/oem/lenovo/xcc.py
new file mode 100644
index 00000000..dcf079dc
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/lenovo/xcc.py
@@ -0,0 +1,1980 @@
+# Copyright 2019 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import asyncio
+import errno
+import fnmatch
+import json
+import math
+import os
+import random
+import re
+import socket
+import time
+
+import zipfile
+
+import aiohmi.constants as pygconst
+import aiohmi.exceptions as pygexc
+import aiohmi.ipmi.private.util as util
+import aiohmi.ipmi.oem.lenovo.config as config
+import aiohmi.media as media
+import aiohmi.redfish.oem.generic as generic
+import aiohmi.storage as storage
+from aiohmi.util.parse import parse_time
+import aiohmi.util.webclient as webclient
+
+class SensorReading(object):
+    def __init__(self, healthinfo, sensor=None, value=None, units=None,
+                 unavailable=False):
+        if sensor:
+            self.name = sensor['name']
+        else:
+            self.name = healthinfo['name']
+            self.health = healthinfo['health']
+            self.states = healthinfo['states']
+            self.state_ids = healthinfo.get('state_ids', None)
+        self.value = value
+        self.imprecision = None
+        self.units = units
+        self.unavailable = unavailable
+
+numregex = re.compile('([0-9]+)')
+funtypes = {
+    0: 'RAID Controller',
+    1: 'Ethernet',
+    2: 'Fibre Channel',
+    3: 'Infiniband',
+    4: 'GPU',
+    10: 'NVMe Controller',
+    12: 'Fabric Controller',
+}
+
+tls_ver = {
+    1: 'TLS1.1',
+    2: 'TLS1.2',
+    3: 'TLS1.3'
+}
+
+sec_mode = {
+    0: ('Compatible',
+        'Maximum compatibility of cipher suites, without NIST compliance'),
+    1: ('NIST',
+        'Maximum compatibility within the constraints of being NIST '
+        'compliant with perfect forward secrecy'),
+    2: ('High', 'Support only modern and strong ciphers, NIST '
+                'compliant with perfect forward security'),
+}
+
+
+def naturalize_string(key):
+    """Analyzes string in a human way to enable natural sort
+
+    :param key: string for the split
+    :returns: A structure that can be consumed by 'sorted'
+    """
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(numregex, key)]
+
+
+def natural_sort(iterable):
+    """Return a sort using natural sort if possible
+
+    :param iterable:
+    :return:
+    """
+    try:
+        return sorted(iterable, key=naturalize_string)
+    except TypeError:
+        # The natural sort attempt failed, fallback to ascii sort
+        return sorted(iterable)
+
+
+def str_to_size(sizestr):
+    if 'GB' in sizestr:
+        sizestr = sizestr.replace('GB', '')
+        sizestr = int(float(sizestr) * 1000)
+    elif 'GiB' in sizestr:
+        sizestr = sizestr.replace('GiB', '')
+        sizestr = int(float(sizestr) * 1024)
+    elif 'TB' in sizestr:
+        sizestr = sizestr.replace('TB', '')
+        sizestr = int(float(sizestr) * 1000 * 1000)
+    elif 'TiB' in sizestr:
+        sizestr = sizestr.replace('TiB', '')
+        sizestr = int(float(sizestr) * 1024 * 1024)
+    return sizestr
+
+
+class OEMHandler(generic.OEMHandler):
+    usegenericsensors = False
+    logouturl = '/api/providers/logout'
+    bmcname = 'XCC'
+    ADP_URL = '/api/dataset/imm_adapters?params=pci_GetAdapters'
+    ADP_NAME = 'adapterName'
+    ADP_FUN = 'functions'
+    ADP_FU_URL = '/api/function/adapter_update?params=pci_GetAdapterListAndFW'
+    ADP_LABEL = 'connectorLabel'
+    ADP_SLOTNO = 'slotNo'
+    ADP_OOB = 'oobSupported'
+    ADP_PARTNUM = 'vpd_partNo'
+    ADP_SERIALNO = 'vpd_serialNo'
+    ADP_VENID = 'generic_vendorId'
+    ADP_SUBVENID = 'generic_subVendor'
+    ADP_DEVID = 'generic_devId'
+    ADP_SUBDEVID = 'generic_subDevId'
+    ADP_FRU = 'vpd_cardSKU'
+    BUSNO = 'generic_busNo'
+    PORTS = 'network_pPorts'
+    DEVNO = 'generic_devNo'
+
+    @classmethod
+    async def create(cls, sysinfo, sysurl, webclient, cache, gpool=None):
+        self = await super(OEMHandler, cls).create(sysinfo, sysurl, webclient, cache,
+                                         gpool)
+        self._wc = None
+        self.weblogging = False
+        self.updating = False
+        self.datacache = {}
+        self.fwc = None
+        self.fwo = None
+        return self
+
+    async def get_screenshot(self, outfile):
+        wc = await self.wc()
+        await wc.grab_json_response('/api/providers/rp_screenshot')
+        url = '/download/HostScreenShot.png'
+        fd = webclient.make_downloader(wc, url, outfile)
+        await fd.join()
+
+    async def get_extended_bmc_configuration(self, fishclient, hideadvanced=True):
+        immsettings = await self.get_system_configuration(fetchimm=True, hideadvanced=hideadvanced)
+        for setting in list(immsettings):
+            if not setting.startswith('IMM.'):
+                del immsettings[setting]
+        return immsettings
+
+    async def get_ikvm_methods(self):
+        return ['url']
+
+    async def get_ikvm_launchdata(self):
+        access = await self._do_web_request('/redfish/v1/Managers/1/Oem/Lenovo/RemoteControl/Actions/LenovoRemoteControlService.GetRemoteConsoleToken', {})
+        if access.get('Token', None):
+            accessinfo = {
+                'url': '/#/login?{}&context=remote&mode=multi'.format(access['Token'])
+                }
+            return accessinfo
+
+    async def get_system_configuration(self, hideadvanced=True, fishclient=None,
+                                 fetchimm=False):
+        if not self.fwc:
+            self.fwc = config.LenovoFirmwareConfig(self, useipmi=False)
+        try:
+            self.fwo = await self.fwc.get_fw_options(fetchimm=fetchimm)
+        except config.Unsupported:
+            return super(OEMHandler, self).get_system_configuration(
+                hideadvanced, fishclient)
+        except Exception:
+            raise Exception('%s failed to retrieve UEFI configuration'
+                            % self.bmcname)
+        self.fwovintage = util._monotonic_time()
+        retcfg = {}
+        for opt in self.fwo:
+            if 'MegaRAIDConfigurationTool' in opt:
+                # Suppress the Avago configuration to be consistent with
+                # other tools.
+                continue
+            if (hideadvanced and self.fwo[opt]['lenovo_protect']
+                    or self.fwo[opt]['hidden']):
+                # Do not enumerate hidden settings
+                continue
+            retcfg[opt] = {}
+            retcfg[opt]['value'] = self.fwo[opt]['current']
+            retcfg[opt]['default'] = self.fwo[opt]['default']
+            retcfg[opt]['help'] = self.fwo[opt]['help']
+            retcfg[opt]['possible'] = self.fwo[opt]['possible']
+            retcfg[opt]['sortid'] = self.fwo[opt]['sortid']
+        return retcfg
+
+    def set_system_configuration(self, changeset, fishclient):
+        if not self.fwc:
+            self.fwc = config.LenovoFirmwareConfig(self, useipmi=False)
+        fetchimm = False
+        if not self.fwo or util._monotonic_time() - self.fwovintage > 30:
+            try:
+                self.fwo = self.fwc.get_fw_options(fetchimm=fetchimm)
+            except config.Unsupported:
+                return super(OEMHandler, self).set_system_configuration(
+                    changeset, fishclient)
+            self.fwovintage = util._monotonic_time()
+        for key in list(changeset):
+            if key not in self.fwo:
+                found = False
+                for rkey in self.fwo:
+                    if fnmatch.fnmatch(rkey.lower(), key.lower()):
+                        changeset[rkey] = changeset[key]
+                        found = True
+                    elif self.fwo[rkey].get('alias', None) != rkey:
+                        calias = self.fwo[rkey]['alias']
+                        if fnmatch.fnmatch(calias.lower(), key.lower()):
+                            changeset[rkey] = changeset[key]
+                            found = True
+                if not found and not fetchimm:
+                    fetchimm = True
+                    self.fwo = self.fwc.get_fw_options(fetchimm=fetchimm)
+                    if key in self.fwo:
+                        continue
+                    else:
+                        found = False
+                        for rkey in self.fwo:
+                            if fnmatch.fnmatch(rkey.lower(), key.lower()):
+                                changeset[rkey] = changeset[key]
+                                found = True
+                            elif self.fwo[rkey].get('alias', None) != rkey:
+                                calias = self.fwo[rkey]['alias']
+                                if fnmatch.fnmatch(
+                                        calias.lower(), key.lower()):
+                                    changeset[rkey] = changeset[key]
+                                    found = True
+                if found:
+                    del changeset[key]
+                else:
+                    raise pygexc.InvalidParameterValue(
+                        '{0} not a known setting'.format(key))
+        self.merge_changeset(changeset)
+        if changeset:
+            try:
+                self.fwc.set_fw_options(self.fwo)
+            finally:
+                self.fwo = None
+                self.fwovintage = 0
+
+    def merge_changeset(self, changeset):
+        for key in changeset:
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            newvalue = changeset[key]['value']
+            if self.fwo[key]['is_list'] and not isinstance(newvalue, list):
+                if '=' in newvalue:
+                    # ASU set a precedent of = delimited settings
+                    # for now, honor that delimiter as well
+                    newvalues = newvalue.split('=')
+                else:
+                    newvalues = newvalue.split(',')
+            else:
+                newvalues = [newvalue]
+            newnewvalues = []
+            for newvalue in newvalues:
+                newv = re.sub(r'\s+', ' ', newvalue)
+                if (self.fwo[key]['possible']
+                        and newvalue not in self.fwo[key]['possible']):
+                    candlist = []
+                    for candidate in self.fwo[key]['possible']:
+                        candid = re.sub(r'\s+', ' ', candidate)
+                        if newv.lower().startswith(candid.lower()):
+                            newvalue = candidate
+                            break
+                        if candid.lower().startswith(newv.lower()):
+                            candlist.append(candidate)
+                    else:
+                        if len(candlist) == 1:
+                            newvalue = candlist[0]
+                        else:
+                            raise pygexc.InvalidParameterValue(
+                                '{0} is not a valid value for {1} '
+                                '({2})'.format(
+                                    newvalue, key,
+                                    ','.join(self.fwo[key]['possible'])))
+                elif self.fwo[key]['validexpression']:
+                    if not re.match(self.fwo[key]['validexpression'], newvalue):
+                        raise pygexc.InvalidParameterValue(
+                            '"{0}" does not match expression "{1}"'.format(
+                                newvalue, self.fwo[key]['validexpression']))
+                newnewvalues.append(newvalue)
+            if len(newnewvalues) == 1:
+                self.fwo[key]['new_value'] = newnewvalues[0]
+            else:
+                self.fwo[key]['new_value'] = newnewvalues
+
+    async def reseat_bay(self, bay):
+        if bay != -1:
+            raise pygexc.UnsupportedFunctionality(
+                'This is not an enclosure manager')
+        wc = await self.wc()
+        wc = wc.dupe(timeout=5)
+        try:
+            rsp = await wc.grab_json_response_with_status(
+                '/api/providers/virt_reseat', '{}')
+        except socket.timeout:
+            # Can't be certain, but most likely a timeout'
+            return
+        if rsp[1] == 500 and rsp[0] == 'Target Unavailable':
+            return
+        if rsp[1] != 200 or rsp[0].get('return', 1) != 0:
+            raise pygexc.UnsupportedFunctionality(
+                'This platform does not support AC reseat.')
+
+    def get_cached_data(self, attribute, age=30):
+        try:
+            kv = self.datacache[attribute]
+            if kv[1] > util._monotonic_time() - age:
+                return kv[0]
+        except KeyError:
+            return None
+
+    async def get_bmc_configuration(self):
+        settings = {}
+        wc = await self.wc()
+        passrules = await wc.grab_json_response('/api/dataset/imm_users_global')
+        passrules = passrules.get('items', [{}])[0]
+        settings['password_reuse_count'] = {
+            'value': passrules.get('pass_min_resuse')}
+        settings['password_change_interval'] = {
+            'value': passrules.get('pass_change_interval')}
+        settings['password_expiration'] = {
+            'value': passrules.get('pass_expire_days')}
+        settings['password_login_failures'] = {
+            'value': passrules.get('max_login_failures')}
+        settings['password_complexity'] = {
+            'value': passrules.get('pass_complex_required')}
+        settings['password_min_length'] = {
+            'value': passrules.get('pass_min_length')}
+        settings['password_lockout_period'] = {
+            'value': passrules.get('lockout_period')}
+        presassert = await wc.grab_json_response('/api/dataset/imm_rpp')
+        asserted = presassert.get('items', [{}])[0].get('rpp_Assert', None)
+        if asserted is not None:
+            settings['presence_assert'] = {
+                'value': 'Enable' if asserted else 'Disable'
+            }
+        secparms = await wc.grab_json_response('/api/providers/imm_tls_mode')
+        if secparms and secparms.get('return', 1) == 0:
+            tlsmode = secparms.get('tls_ver', -1)
+            if tlsmode in tls_ver:
+                settings['minimum_tls_version'] = {
+                    'value': tls_ver[tlsmode],
+                    'help': 'The minimum TLS level allowed by the XCC when '
+                            'communicating',
+                    'possible': [tls_ver[x] for x in tls_ver],
+                }
+            secmode = secparms.get('sec_mode', -1)
+            if secmode in sec_mode:
+                settings['cryptography_mode'] = {
+                    'value': sec_mode[secmode][0],
+                    'help': 'Select cryptography mode, compatible allows all '
+                            'supported ciphers, NIST restricts to NIST '
+                            'compliant ciphers, and High further restricts '
+                            'to a modern subset of NIST compliance',
+                    'possible': [sec_mode[x][0] for x in sec_mode],
+                }
+        usbparms = await wc.grab_json_response('/api/dataset/imm_usb')
+        if usbparms:
+            usbparms = usbparms.get('items', [{}])[0]
+            if usbparms['usb_eth_over_usb_enabled'] == 1:
+                usbeth = 'Enable'
+            else:
+                usbeth = 'Disable'
+            settings['usb_ethernet'] = {
+                'value': usbeth
+            }
+            if usbparms['usb_eth_to_eth_enabled'] == 1:
+                fwd = 'Enable'
+            else:
+                fwd = 'Disable'
+            settings['usb_ethernet_port_forwarding'] = {
+                'value': fwd
+            }
+            mappings = []
+            for mapping in usbparms['usb_mapped_ports']:
+                src = mapping['ext_port']
+                dst = mapping['eth_port']
+                if src != 0 and dst != 0:
+                    mappings.append('{0}:{1}'.format(src, dst))
+            settings['usb_forwarded_ports'] = {'value': ','.join(mappings)}
+        return settings
+
+    rulemap = {
+        'password_change_interval': 'USER_GlobalMinPassChgInt',
+        'password_reuse_count': 'USER_GlobalMinPassReuseCycle',
+        'password_expiration': 'USER_GlobalPassExpPeriod',
+        'password_login_failures': 'USER_GlobalMaxLoginFailures',
+        'password_complexity': 'USER_GlobalPassComplexRequired',
+        'password_min_length': 'USER_GlobalMinPassLen',
+        'password_lockout_period': 'USER_GlobalLockoutPeriod',
+    }
+
+    async def set_bmc_configuration(self, changeset):
+        ruleset = {}
+        usbsettings = {}
+        secparms = {}
+        wc = await self.wc()
+        for key in changeset:
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            currval = changeset[key].get('value', None)
+            if key.lower() in self.rulemap:
+                ruleset[self.rulemap[key.lower()]] = currval
+                if key.lower() == 'password_expiration':
+                    warntime = str(int(int(currval) * 0.08))
+                    ruleset['USER_GlobalPassExpWarningPeriod'] = warntime
+            elif 'presence_asserted'.startswith(key.lower()):
+                if 'enabled'.startswith(currval.lower()):
+                    await wc.grab_json_response('/api/dataset',
+                                               {'IMM_RPPAssert': '0'})
+                    await wc.grab_json_response('/api/dataset',
+                                               {'IMM_RPPAssert': '1'})
+                elif 'disabled'.startswith(currval.lower()):
+                    await wc.grab_json_response('/api/dataset',
+                                               {'IMM_RPPAssert': '0'})
+                else:
+                    raise pygexc.InvalidParameterValue(
+                        '"{0}" is not a recognized value for {1}'.format(
+                            currval, key))
+            elif key.lower() in (
+                    'usb_ethernet', 'usb_ethernet_port_forwarding',
+                    'usb_forwarded_ports'):
+                usbsettings[key] = changeset[key]['value']
+            elif key.lower() in ('cryptography_mode', 'minimum_tls_version'):
+                secparms[key] = changeset[key]['value']
+            else:
+                raise pygexc.InvalidParameterValue(
+                    '{0} not a known setting'.format(key))
+        if usbsettings:
+            await self.apply_usb_configuration(usbsettings)
+        if secparms:
+            await self.apply_sec_configuration(secparms)
+        if ruleset:
+            await wc.grab_json_response('/api/dataset', ruleset)
+
+    async def apply_sec_configuration(self, secparms):
+        secmode = None
+        tlsver = None
+        wc = await self.wc()
+        if 'cryptography_mode' in secparms:
+            secmode = secparms['cryptography_mode'].lower()
+            for sm in sec_mode:
+                if sec_mode[sm][0].lower().startswith(secmode):
+                    secmode = sm
+                    break
+            else:
+                raise pygexc.InvalidParameterValue(
+                    '"{0}" is not a recognized cryptography mode'.format(
+                        secparms['cryptography_mode']
+                    )
+                )
+        if 'minimum_tls_version' in secparms:
+            tlsver = secparms['minimum_tls_version'].lower()
+            for tv in tls_ver:
+                if tls_ver[tv].lower() == tlsver:
+                    tlsver = tv
+                    break
+            else:
+                raise pygexc.InvalidParameterValue(
+                    '"{0}" is not a recognized TLS version'.format(
+                        secparms['minimum_tls_version'])
+                )
+        if len(secparms) < 2:
+            currsecparms = await wc.grab_json_response(
+                '/api/providers/imm_tls_mode')
+            del currsecparms['return']
+        else:
+            currsecparms = {}
+        if secmode is not None:
+            currsecparms['sec_mode'] = secmode
+        if tlsver is not None:
+            currsecparms['tls_ver'] = tlsver
+        await wc.grab_json_response('/api/providers/imm_tls_mode',
+                                   currsecparms)
+
+    async def apply_usb_configuration(self, usbsettings):
+        def numify(val):
+            if 'enabled'.startswith(val.lower()):
+                return '1'
+            if 'disabled'.startswith(val.lower()):
+                return '0'
+            raise Exception('Usupported value')
+        wc = await self.wc()
+        usbparms = await wc.grab_json_response('/api/dataset/imm_usb')
+        usbparms = usbparms.get('items', [{}])[0]
+        addrmode = '{0}'.format(usbparms['lan_over_usb_addr_mode'])
+        ethena = '{0}'.format(usbparms['usb_eth_over_usb_enabled'])
+        fwdena = '{0}'.format(usbparms['usb_eth_to_eth_enabled'])
+        newena = usbsettings.get('usb_ethernet', None)
+        newfwd = usbsettings.get('usb_ethernet_port_forwarding', None)
+        newsettings = {
+            'USB_LANOverUSBAddrMode': addrmode,
+            'USB_EthOverUsbEna': ethena,
+            'USB_PortForwardEna': fwdena,
+            'USB_IPChangeEna': '0',
+        }
+        needsettings = False
+        if newena is not None:
+            needsettings = True
+            newsettings['USB_EthOverUsbEna'] = numify(newena)
+        if newfwd is not None:
+            needsettings = True
+            newsettings['USB_PortForwardEna'] = numify(newfwd)
+        if needsettings:
+            await wc.grab_json_response('/api/dataset', newsettings)
+        if 'usb_forwarded_ports' in usbsettings:
+            oldfwds = {}
+            usedids = set([])
+            newfwds = usbsettings['usb_forwarded_ports'].split(',')
+            for mapping in usbparms['usb_mapped_ports']:
+                rule = '{0}:{1}'.format(
+                    mapping['ext_port'], mapping['eth_port'])
+                if rule not in newfwds:
+                    await wc.grab_json_response(
+                        '/api/function', {
+                            'USB_RemoveMapping': '{0}'.format(mapping['id'])})
+                else:
+                    usedids.add(mapping['id'])
+                    oldfwds[rule] = mapping['id']
+            for mapping in usbsettings['usb_forwarded_ports'].split(','):
+                if mapping not in oldfwds:
+                    newid = 1
+                    while newid in usedids:
+                        newid += 1
+                    if newid > 11:
+                        raise Exception('Too Many Port Forwards')
+                    usedids.add(newid)
+                    newmapping = '{0},{1}'.format(
+                        newid, mapping.replace(':', ','))
+                    await wc.grab_json_response(
+                        '/api/function', {'USB_AddMapping': newmapping})
+
+    async def get_health(self, fishclient, verbose=True):
+        rsp = await self._do_web_request('/api/providers/imm_active_events')
+        summary = {'badreadings': [], 'health': pygconst.Health.Ok}
+        fallbackdata = []
+        hmap = {
+            'I': pygconst.Health.Ok,
+            'E': pygconst.Health.Critical,
+            'W': pygconst.Health.Warning,
+        }
+        infoevents = False
+        existingevts = set([])
+        for item in rsp.get('items', ()):
+            # while usually the ipmi interrogation shall explain things,
+            # just in case there is a gap, make sure at least the
+            # health field is accurately updated
+            itemseverity = hmap.get(item.get('severity', 'E'),
+                                    pygconst.Health.Critical)
+            if itemseverity == pygconst.Health.Ok:
+                infoevents = True
+                continue
+            if (summary['health'] < itemseverity):
+                summary['health'] = itemseverity
+            if item['cmnid'] == 'FQXSPPW0104J':
+                # This event does not get modeled by the sensors
+                # add a made up sensor to explain
+                fallbackdata.append(
+                    SensorReading({'name': item['source'],
+                                       'states': ['Not Redundant'],
+                                       'state_ids': [3],
+                                       'health': pygconst.Health.Warning,
+                                       'type': 'Power'}, ''))
+            elif item['cmnid'] == 'FQXSFMA0041K':
+                fallbackdata.append(
+                    SensorReading({
+                        'name': 'Optane DCPDIMM',
+                        'health': pygconst.Health.Warning,
+                        'type': 'Memory',
+                        'states': [item['message']]},
+                        '')
+                )
+            else:
+                currevt = '{}:{}'.format(item['source'], item['message'])
+                if currevt in existingevts:
+                    continue
+                existingevts.add(currevt)
+                fallbackdata.append(SensorReading({
+                    'name': item['source'],
+                    'states': [item['message']],
+                    'health': itemseverity,
+                    'type': item['source'],
+                }, ''))
+        summary['badreadings'] = fallbackdata
+        return summary
+
+    async def get_description(self, fishclient):
+        description = await self._do_web_request('/DeviceDescription.json')
+        if description:
+            description = description[0]
+        u_height = description.get('u-height', '')
+        if not u_height and description.get(
+                'enclosure-machinetype-model', '').startswith('7Y36'):
+            u_height = '2'
+        if not u_height:
+            return {}
+        u_height = int(u_height)
+        slot = description.get('slot', '0')
+        slot = int(slot)
+        return {'height': u_height, 'slot': slot}
+
+    async def _get_agentless_firmware(self, components):
+        skipkeys = set([])
+        wc = await self.wc()
+        adata = await wc.grab_json_response(
+            '/api/dataset/imm_adapters?params=pci_GetAdapters')
+        fdata = await wc.grab_json_response(
+            '/api/function/adapter_update?params=pci_GetAdapterListAndFW')
+        anames = set()
+        for adata in adata.get('items', []):
+            baseaname = adata['adapterName']
+            aname = baseaname
+            idx = 1
+            while aname in anames:
+                aname = '{0} {1}'.format(baseaname, idx)
+                idx += 1
+            anames.add(aname)
+            donenames = set()
+            for fundata in adata['functions']:
+                for firm in fundata.get('firmwares', []):
+                    fname = firm['firmwareName'].rstrip()
+                    if '.' in fname:
+                        fname = firm['description'].rstrip()
+                    if fname in donenames:
+                        # ignore redundant entry
+                        continue
+                    if not fname:
+                        continue
+                    donenames.add(fname)
+                    bdata = {}
+                    if 'versionStr' in firm and firm['versionStr']:
+                        bdata['version'] = firm['versionStr']
+                    if ('releaseDate' in firm
+                            and firm['releaseDate']
+                            and firm['releaseDate'] != 'N/A'):
+                        try:
+                            bdata['date'] = parse_time(firm['releaseDate'])
+                        except ValueError:
+                            pass
+                    yield '{0} {1}'.format(aname, fname), bdata
+            for fwi in fdata.get('items', []):
+                if fwi.get('key', -1) == adata.get('key', -2):
+                    skipkeys.add(fwi['key'])
+                    if fwi.get('fw_status', 0) == 2:
+                        bdata = {}
+                        if 'fw_pkg_version' in fwi and fwi['fw_pkg_version']:
+                            bdata['version'] = fwi['fw_pkg_version']
+                        elif 'fw_version_pend' in fwi:                       
+                            bdata['version'] = fwi['fw_version_pend']
+                        yield '{0} Pending Update'.format(aname), bdata
+        for fwi in fdata.get('items', []):
+            if fwi.get('key', -1) > 0 and fwi['key'] not in skipkeys:
+                bdata = {}
+                bdata['version'] = fwi['fw_version']
+                yield fwi['adapterName'], bdata
+                if fwi.get('fw_status', 0) == 2:
+                    bdata = {}
+                    if 'fw_version_pend' in fwi:
+                        bdata['version'] = fwi['fw_version_pend']
+                    yield '{0} Pending Update'.format(fwi['adapterName']), bdata
+
+    def _get_disk_firmware_single(self, diskent, prefix=''):
+        bdata = {}
+        if not prefix:
+            location = diskent.get('location', '')
+            if location.startswith('M.2'):
+                prefix = 'M.2-'
+            elif location.startswith('7MM'):
+                prefix = '7MM-'
+        diskname = 'Disk {1}{0}'.format(diskent['slotNo'], prefix)
+        bdata['model'] = diskent[
+            'productName'].rstrip()
+        bdata['version'] = diskent['fwVersion']
+        return (diskname, bdata)
+
+    async def _get_disk_firmware(self, coponents):
+        wc = await self.wc()
+        storagedata = await wc.grab_json_response(
+            '/api/function/raid_alldevices?params=storage_GetAllDisks')
+        for adp in storagedata.get('items', []):
+            for diskent in adp.get('disks', ()):
+                yield self._get_disk_firmware_single(diskent)
+            for diskent in adp.get('aimDisks', ()):
+                yield self._get_disk_firmware_single(diskent)
+
+    async def get_firmware_inventory(self, components, fishclient, category=None):
+
+        if components and 'core' in components:
+            category = 'core'
+            components = components - set(['core'])
+        if not category:
+            category = 'all'
+        wc = await self.wc()
+        if category in ('all', 'core'):
+            sysinf = await wc.grab_json_response('/api/dataset/sys_info')
+            for item in sysinf.get('items', {}):
+                for firm in item.get('firmware', []):
+                    firminfo = {
+                        'version': firm['version'],
+                        'build': firm['build'],
+                        'date': parse_time(firm['release_date']),
+                    }
+                    if firm['type'] == 5:
+                        yield ('XCC', firminfo)
+                    elif firm['type'] == 6:
+                        yield ('XCC Backup', firminfo)
+                    elif firm['type'] == 0:
+                        yield ('UEFI', firminfo)
+                    elif firm['type'] == 7:
+                        yield ('LXPM', firminfo)
+                    elif firm['type'] == 8:
+                        yield ('LXPM Windows Driver Bundle', firminfo)
+                    elif firm['type'] == 9:
+                        yield ('LXPM Linux Driver Bundle', firminfo)
+                    elif firm['type'] == 10:
+                        yield ('LXUM', firminfo)
+        if components:
+            components = set([x.lower() for x in components])
+            components = components - set((
+                'core', 'uefi', 'bios', 'xcc', 'bmc', 'imm', 'fpga',
+                'lxpm'))
+            if not components:
+                return
+        if not components:
+            components = set(('all',))
+        needadapterfirmware = False
+        needdiskfirmware = False        
+        if category in ('all', 'adapters'):
+            needadapterfirmware = True
+        if category in ('all', 'disks'):
+            needdiskfirmware = True
+        if needadapterfirmware:
+            async for adpinfo in self._get_agentless_firmware(components):
+                yield adpinfo
+        if needdiskfirmware:
+            async for adpinfo in self._get_disk_firmware(components):
+                yield adpinfo
+        raise pygexc.BypassGenericBehavior()
+
+    async def get_storage_configuration(self, logout=True):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function/raid_alldevices?params=storage_GetAllDevices,0')
+        if not rsp:
+            rsp = await wc.grab_json_response(
+                '/api/function/raid_alldevices?params=storage_GetAllDevices')
+        standalonedisks = []
+        pools = []
+        for item in rsp.get('items', []):
+            for cinfo in item['controllerInfo']:
+                cid = '{0},{1},{2}'.format(
+                    cinfo['id'], cinfo.get('slotNo', -1), cinfo.get(
+                        'type', -1))
+                for pool in cinfo['pools']:
+                    volumes = []
+                    disks = []
+                    spares = []
+                    for volume in pool['volumes']:
+                        volumes.append(
+                            storage.Volume(name=volume['name'],
+                                           size=volume['capacity'],
+                                           status=volume['statusStr'],
+                                           id=(cid, volume['id'])))
+                    for disk in pool['disks']:
+                        diskinfo = storage.Disk(
+                            name=disk['name'], description=disk['type'],
+                            id=(cid, disk['id']), status=disk['RAIDState'],
+                            serial=disk['serialNo'], fru=disk['fruPartNo'])
+                        if disk['RAIDState'] == 'Dedicated Hot Spare':
+                            spares.append(diskinfo)
+                        else:
+                            disks.append(diskinfo)
+                    totalsize = str_to_size(pool['totalCapacityStr'])
+                    freesize = str_to_size(pool['freeCapacityStr'])
+                    pools.append(storage.Array(
+                        disks=disks, raid=pool['rdlvlstr'], volumes=volumes,
+                        id=(cid, pool['id']), hotspares=spares,
+                        capacity=totalsize, available_capacity=freesize))
+                for disk in cinfo.get('unconfiguredDisks', ()):
+                    # can be unused, global hot spare, or JBOD
+                    standalonedisks.append(
+                        storage.Disk(
+                            name=disk['name'], description=disk['type'],
+                            id=(cid, disk['id']), status=disk['RAIDState'],
+                            serial=disk['serialNo'], fru=disk['fruPartNo']))
+        return storage.ConfigSpec(disks=standalonedisks, arrays=pools)
+
+    async def _set_drive_state(self, disk, state):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function',
+            {'raidlink_DiskStateAction': '{0},{1}'.format(disk.id[1], state)})
+        if rsp.get('return', -1) != 0:
+            raise Exception(
+                'Unexpected return to set disk state: {0}'.format(
+                    rsp.get('return', -1)))
+
+    async def _refresh_token(self):
+        wc = await self.wc()
+        await self._refresh_token_wc(wc)
+
+    async def _refresh_token_wc(self, wc):
+        await wc.grab_json_response('/api/providers/identity')
+        for cookie in wc.cookies:
+            if cookie.key.lower() == '_csrf_token':
+                wc.set_header('X-XSRF-TOKEN', cookie.value)
+            wc.vintage = util._monotonic_time()
+
+    def _make_available(self, disk, realcfg):
+        # 8 if jbod, 4 if hotspare.., leave alone if already...
+        currstatus = self._get_status(disk, realcfg)
+        newstate = None
+        if currstatus == 'Unconfigured Good':
+            return
+        elif currstatus.lower() == 'global hot spare':
+            newstate = 4
+        elif currstatus.lower() == 'jbod':
+            newstate = 8
+        self._set_drive_state(disk, newstate)
+
+    def _make_jbod(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        if currstatus.lower() == 'jbod':
+            return
+        self._make_available(disk, realcfg)
+        self._set_drive_state(disk, 16)
+
+    def _make_global_hotspare(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        if currstatus.lower() == 'global hot spare':
+            return
+        self._make_available(disk, realcfg)
+        self._set_drive_state(disk, 1)
+
+    def _get_status(self, disk, realcfg):
+        for cfgdisk in realcfg.disks:
+            if disk.id == cfgdisk.id:
+                currstatus = cfgdisk.status
+                break
+        else:
+            raise pygexc.InvalidParameterValue('Requested disk not found')
+        return currstatus
+
+    async def _raid_number_map(self, controller):
+        themap = {}
+        cid = controller.split(',')
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function/raid_conf?'
+            'params=raidlink_GetDisksToConf,{0}'.format(cid[0]))
+        if rsp.get('return') == 22:  # New style firmware
+            if cid[2] == 2:
+                arg = '{0},{1}'.format(cid[1], cid[2])
+            else:
+                arg = '{0},{1}'.format(cid[0], cid[2])
+            arg = 'params=raidlink_GetDisksToConf,{0}'.format(arg)
+            rsp = await wc.grab_json_response(
+                '/api/function/raid_conf?{0}'.format(arg))
+        for lvl in rsp['items'][0]['supported_raidlvl']:
+            mapdata = (lvl['rdlvl'], lvl['maxSpan'])
+            raidname = lvl['rdlvlstr'].replace(' ', '').lower()
+            themap[raidname] = mapdata
+            raidname = raidname.replace('raid', 'r')
+            themap[raidname] = mapdata
+            raidname = raidname.replace('r', '')
+            themap[raidname] = mapdata
+        return themap
+
+    async def check_storage_configuration(self, cfgspec=None):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response(
+            '/api/function/raid_conf?params=raidlink_GetStatus')
+        if rsp['items'][0]['status'] not in (2, 3):
+            raise pygexc.TemporaryError('Storage configuration unavailable in '
+                                        'current state (try boot to setup or '
+                                        'an OS)')
+        if not cfgspec:
+            return True
+        for pool in cfgspec.arrays:
+            self._parse_storage_cfgspec(pool)
+        return True
+
+    async def _wait_storage_async(self):
+        rsp = {'items': [{'status': 0}]}
+        wc = await self.wc()
+        while rsp['items'][0]['status'] == 0:
+            await asyncio.sleep(1)
+            rsp = await wc.grab_json_response(
+                '/api/function/raid_conf?params=raidlink_QueryAsyncStatus')
+
+    async def _parse_array_spec(self, arrayspec):
+        controller = None
+        if arrayspec.disks:
+            for disk in list(arrayspec.disks) + list(arrayspec.hotspares):
+                if controller is None:
+                    controller = disk.id[0]
+                if controller != disk.id[0]:
+                    raise pygexc.UnsupportedFunctionality(
+                        'Cannot span arrays across controllers')
+            raidmap = await self._raid_number_map(controller)
+            if not raidmap:
+                raise pygexc.InvalidParameterValue(
+                    'There are no available drives for a new array')
+            requestedlevel = str(arrayspec.raid).lower()
+            if requestedlevel not in raidmap:
+                raise pygexc.InvalidParameterValue(
+                    'Requested RAID "{0}" not available on this '
+                    'system with currently available drives'.format(
+                        requestedlevel))
+            rdinfo = raidmap[str(arrayspec.raid).lower()]
+            rdlvl = str(rdinfo[0])
+            defspan = 1 if rdinfo[1] == 1 else 2
+            spancount = defspan if arrayspec.spans is None else arrayspec.spans
+            drivesperspan = str(len(arrayspec.disks) // int(spancount))
+            hotspares = arrayspec.hotspares
+            drives = arrayspec.disks
+            if hotspares:
+                hstr = '|'.join([str(x.id[1]) for x in hotspares]) + '|'
+            else:
+                hstr = ''
+            drvstr = '|'.join([str(x.id[1]) for x in drives]) + '|'
+            ctl = controller.split(',')
+            pth = '/api/function/raid_conf?params=raidlink_CheckConfisValid'
+            args = [pth, ctl[0], rdlvl, spancount, drivesperspan, drvstr,
+                    hstr]
+            url = ','.join([str(x) for x in args])
+            wc = await self.wc()
+            rsp = await wc.grab_json_response(url)
+            if rsp.get('return', -1) == 22:
+                args.append(ctl[1])
+                args = [pth, ctl[0], rdlvl, spancount, drivesperspan, drvstr,
+                        hstr, ctl[1]]
+                url = ','.join([str(x) for x in args])
+                rsp = await wc.grab_json_response(url)
+            if rsp['items'][0]['errcode'] == 16:
+                raise pygexc.InvalidParameterValue('Incorrect number of disks')
+            elif rsp['items'][0]['errcode'] != 0:
+                raise pygexc.InvalidParameterValue(
+                    'Invalid configuration: {0}'.format(
+                        rsp['items'][0]['errcode']))
+            return {
+                'capacity': rsp['items'][0]['freeCapacity'],
+                'controller': controller,
+                'drives': drvstr,
+                'hotspares': hstr,
+                'raidlevel': rdlvl,
+                'spans': spancount,
+                'perspan': drivesperspan,
+            }
+        else:
+            # TODO(Jarrod Johnson): adding new volume to
+            #  existing array would be here
+            pass
+
+    async def _create_array(self, pool):
+        params = self._parse_array_spec(pool)
+        cid = params['controller'].split(',')[0]
+        cslotno = params['controller'].split(',')[1]
+        url = '/api/function/raid_conf?params=raidlink_GetDefaultVolProp'
+        args = (url, cid, 0, params['drives'])
+        wc = await self.wc()
+        props = await wc.grab_json_response(','.join([str(x) for x in args]))
+        usesctrlslot = False
+        if not props:  # newer firmware requires raidlevel too
+            args = (url, cid, params['raidlevel'], 0, params['drives'])
+            props = await wc.grab_json_response(','.join([str(x) for x in args]))
+        elif 'return' in props and props['return'] == 22:
+            # Jan 2023 XCC FW - without controller slot number
+            args = (url, cid, params['raidlevel'], 0, params['drives'])
+            props = await wc.grab_json_response(','.join([str(x) for x in args]))
+            if 'return' in props and props['return'] == 22:
+                usesctrlslot = True
+                # Jan 2023 XCC FW - with controller slot number
+                args = (url, cid, params['raidlevel'], 0, params['drives'], cslotno)
+                props = await wc.grab_json_response(','.join([str(x) for x in args]))
+        props = props['items'][0]
+        volumes = pool.volumes
+        remainingcap = params['capacity']
+        nameappend = 1
+        vols = []
+        currvolnames = None
+        currcfg = None
+        for vol in volumes:
+            if vol.name is None:
+                # need to iterate while there exists a volume of that name
+                if currvolnames is None:
+                    currcfg = await self.get_storage_configuration(False)
+                    currvolnames = set([])
+                    for pool in currcfg.arrays:
+                        for volume in pool.volumes:
+                            currvolnames.add(volume.name)
+                name = props['name'] + '_{0}'.format(nameappend)
+                nameappend += 1
+                while name in currvolnames:
+                    name = props['name'] + '_{0}'.format(nameappend)
+                    nameappend += 1
+            else:
+                name = vol.name
+            if vol.stripsize is not None:
+                stripsize = int(math.log(vol.stripsize * 2, 2))
+            else:
+                stripsize = props['stripsize']
+            if vol.read_policy is not None:
+                read_policy = vol.read_policy
+            else:
+                read_policy = props["cpra"]
+            if vol.write_policy is not None:
+                write_policy = vol.write_policy
+            else:
+                write_policy = props["cpwb"]
+            if vol.default_init is not None:
+                default_init = vol.default_init
+            else:
+                default_init = props["initstate"]
+            strsize = 'remainder' if vol.size is None else str(vol.size)
+            if strsize in ('all', '100%'):
+                volsize = params['capacity']
+            elif strsize in ('remainder', 'rest'):
+                volsize = remainingcap
+            elif strsize.endswith('%'):
+                volsize = int(params['capacity']
+                              * float(strsize.replace('%', ''))
+                              / 100.0)
+            else:
+                try:
+                    volsize = int(strsize)
+                except ValueError:
+                    raise pygexc.InvalidParameterValue(
+                        'Unrecognized size ' + strsize)
+            remainingcap -= volsize
+            if remainingcap < 0:
+                raise pygexc.InvalidParameterValue(
+                    'Requested sizes exceed available capacity')
+            vols.append('{0};{1};{2};{3};{4};{5};{6};{7};{8};|'.format(
+                name, volsize, stripsize, write_policy, read_policy,
+                props['cpio'], props['ap'], props['dcp'], default_init))
+        url = '/api/function'
+        cid = params['controller'].split(',')
+        cnum = cid[0]
+        arglist = '{0},{1},{2},{3},{4},{5},'.format(
+            cnum, params['raidlevel'], params['spans'],
+            params['perspan'], params['drives'], params['hotspares'])
+        arglist += ''.join(vols)
+        parms = {'raidlink_AddNewVolWithNaAsync': arglist}
+        rsp = await wc.grab_json_response(url, parms)
+        if rsp['return'] == 14:  # newer firmware
+            if 'supported_cpwb' in props and not usesctrlslot: # no ctrl_type
+                arglist = '{0},{1},{2},{3},{4},{5},{6},'.format(
+                    cnum, params['raidlevel'], params['spans'],
+                    params['perspan'], 0, params['drives'], params['hotspares'])
+                arglist += ''.join(vols)
+                parms = {'raidlink_AddNewVolWithNaAsync': arglist}
+                rsp = await wc.grab_json_response(url, parms)
+            else: # with ctrl_type
+                if cid[2] == 2:
+                    cnum = cid[1]
+                arglist = '{0},{1},{2},{3},{4},{5},'.format(
+                    cnum, params['raidlevel'], params['spans'],
+                    params['perspan'], params['drives'], params['hotspares'])
+                arglist += ''.join(vols) + ',{0}'.format(cid[2])
+                parms = {'raidlink_AddNewVolWithNaAsync': arglist}
+                rsp = await wc.grab_json_response(url, parms)
+        if rsp['return'] != 0:
+            raise Exception(
+                'Unexpected response to add volume command: ' + repr(rsp))
+        await self._wait_storage_async()
+
+    async def remove_storage_configuration(self, cfgspec):
+        realcfg = await self.get_storage_configuration(False)
+        wc = await self.wc()
+        for pool in cfgspec.arrays:
+            for volume in pool.volumes:
+                cid = volume.id[0].split(',')
+                if cid[2] == 2:
+                    vid = '{0},{1},{2}'.format(volume.id[1], cid[1], cid[2])
+                else:
+                    vid = '{0},{1},{2}'.format(volume.id[1], cid[0], cid[2])
+                rsp = await wc.grab_json_response(
+                    '/api/function', {'raidlink_RemoveVolumeAsync': vid})
+                if rsp.get('return', -1) == 2:
+                    # older firmware
+                    vid = '{0},{1}'.format(volume.id[1], cid[0])
+                    rsp = await wc.grab_json_response(
+                        '/api/function', {'raidlink_RemoveVolumeAsync': vid})
+                if rsp.get('return', -1) != 0:
+                    raise Exception(
+                        'Unexpected return to volume deletion: ' + repr(rsp))
+                await self._wait_storage_async()
+        for disk in cfgspec.disks:
+            await self._make_available(disk, realcfg)
+
+    async def apply_storage_configuration(self, cfgspec):
+        realcfg = await self.get_storage_configuration(False)
+        for disk in cfgspec.disks:
+            if disk.status.lower() == 'jbod':
+                await self._make_jbod(disk, realcfg)
+            elif disk.status.lower() == 'hotspare':
+                await self._make_global_hotspare(disk, realcfg)
+            elif disk.status.lower() in ('unconfigured', 'available', 'ugood',
+                                         'unconfigured good'):
+                await self._make_available(disk, realcfg)
+        for pool in cfgspec.arrays:
+            if pool.disks:
+                await self._create_array(pool)
+
+    async def weblogout(self):
+        if self._wc:
+            try:
+                await self._wc.grab_json_response(self.logouturl)
+            except Exception:
+                pass
+            self._wc = None
+
+    
+    async def wc(self):
+        while self.weblogging:
+            await asyncio.sleep(0.25)
+        self.weblogging = True
+        try:
+            if (not self._wc or (self._wc.vintage
+                                and self._wc.vintage < util._monotonic_time()
+                                - 30)):
+                if not self.updating and self._wc:
+                    # in case the existing session is still valid
+                    # dispose of the session
+                    await self.weblogout()
+                self._wc = await self.get_webclient()
+        finally:
+            self.weblogging = False
+        return self._wc
+
+    async def get_webclient(self, login=True):
+        wc = self.webclient.dupe()
+        wc.vintage = util._monotonic_time()
+        if not login:
+            return wc
+        referer = 'https://xcc/'
+        adata = json.dumps({'username': self.username,
+                            'password': self.password
+                            })
+        headers = {'Connection': 'keep-alive',
+                   'Referer': referer,
+                   'Host': 'xcc',
+                   'Content-Type': 'application/json'}
+        rsp, status = await wc.grab_json_response_with_status(
+            '/api/providers/get_nonce', {})
+        if status == 200:
+            nonce = rsp.get('nonce', None)
+            headers['Content-Security-Policy'] = 'nonce={0}'.format(nonce)
+        rspdata, status = await wc.grab_json_response_with_status('/api/login', adata, headers=headers)
+        if status == 200:
+            wc.set_header('Content-Type', 'application/json')
+            wc.set_header('Authorization', 'Bearer ' + rspdata['access_token'])
+            wc.set_header('Referer', referer)
+            wc.set_header('Host', 'xcc')
+            for cookie in wc.cookies:
+                if cookie.key.lower() == '_csrf_token':
+                    wc.set_header('X-XSRF-TOKEN', cookie.value)
+                    break
+            return wc
+
+    async def grab_redfish_response_with_status(self, url, body=None, method=None):
+        wc = self.webclient
+        res = await wc.grab_json_response_with_status(url, body, method=method)
+        return res
+
+    async def list_media(self, fishclient, cache=True):
+        wc = await self.wc()
+        rt = await wc.grab_json_response('/api/providers/rp_vm_remote_getdisk')
+        if 'items' in rt:
+            for mt in rt['items']:
+                url = mt['remotepath']
+                if url.startswith('//'):
+                    url = 'smb:' + url
+                elif (not url.startswith('http://')
+                      and not url.startswith('https://')):
+                    url = url.replace(':', '')
+                    url = 'nfs://' + url
+                yield media.Media(mt['filename'], url)
+        async for rdoc in self._list_rdoc():
+            yield rdoc
+    
+    async def _list_rdoc(self):
+        wc = await self.wc()
+        rt = await wc.grab_json_response('/api/providers/rp_rdoc_imagelist')
+        if 'items' in rt:
+            for mt in rt['items']:
+                yield media.Media(mt['filename'])
+
+    async def attach_remote_media(self, url, user, password, vmurls):
+        for vmurl in vmurls:
+            if 'EXT' not in vmurl:
+                continue
+            vminfo = await self._do_web_request(vmurl, cache=False)
+            if vminfo['ConnectedVia'] != 'NotConnected':
+                continue
+            await self._do_web_request(vmurl, {'Image': url, 'Inserted': True},
+                                 'PATCH')
+            raise pygexc.BypassGenericBehavior()
+            break
+        else:
+            raise pygexc.InvalidParameterValue(
+                'XCC does not have required license for operation')
+
+    async def upload_media(self, filename, progress=None, data=None):
+        wc = await self.wc()
+        numrdocs = 0
+        await self._refresh_token()
+        async for rdoc in self._list_rdoc():
+            numrdocs += 1
+            if rdoc.name == os.path.basename(filename):
+                raise pygexc.InvalidParameterValue(
+                    'An image with that name already exists')
+        if numrdocs >= 2:
+            raise pygexc.InvalidParameterValue(
+                'Maximum number of uploaded media reached')
+        rsp, statu = await wc.grab_json_response_with_status('/rdocupload')
+        newmode = False
+        if statu == 404:
+            xid = random.randint(0, 1000000000)
+            uploadtask = await webclient.make_uploader(wc, '/upload?X-Progress-ID={0}'.format(xid), filename, data)
+        else:
+            newmode = True
+            uploadtask = await webclient.make_uploader(
+                wc, '/rdocupload', filename, data)
+        while not uploadtask.completed():
+            try:
+                await uploadtask.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if newmode:
+                if progress:
+                    progress({'phase': 'upload',
+                          'progress': 100 * await uploadtask.get_progress()})
+            else:
+                rsp = await wc.grab_json_response(
+                    '/upload/progress?X-Progress-ID={0}'.format(xid))
+                if progress and rsp['state'] == 'uploading':
+                    progress({'phase': 'upload',
+                            'progress': 100.0 * rsp['received'] / rsp['size']})
+            await self._refresh_token()
+        rspstatus, rsp, headers = uploadtask.get_response()    
+        if progress:
+            progress({'phase': 'upload',
+                      'progress': 100.0})
+        if 'items' not in rsp or len(rsp['items']) == 0:
+            errmsg = repr(rsp) if rsp else repr(rspstatus)
+            raise pygexc.PyghmiException('Failed to upload image: ' + errmsg)
+        thepath = rsp['items'][0]['path']
+        thename = rsp['items'][0]['name']
+        writeable = 1 if filename.lower().endswith('.img') else 0
+        addfile = {"Url": thepath, "Protocol": 6, "Write": writeable,
+                   "Credential": ":", "Option": "", "Domain": "",
+                   "WebUploadName": thename}
+        rsp = await wc.grab_json_response('/api/providers/rp_rdoc_addfile',
+                                         addfile)
+        await self._refresh_token()
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise pygexc.PyghmiException('Failed to upload image: ' + errmsg)
+        ready = False
+        while not ready:
+            rsp = await wc.grab_json_response('/api/providers/rp_rdoc_getfiles')
+            if 'items' not in rsp or len(rsp['items']) == 0:
+                raise Exception(
+                    'Image upload was not accepted, it may be too large')
+            ready = rsp['items'][0]['size'] != 0
+            if not ready:
+                await asyncio.sleep(2)
+        await self._refresh_token()
+        rsp = await wc.grab_json_response('/api/providers/rp_rdoc_mountall',
+                                         {})
+        await self._refresh_token()
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unrecognized return: ' + errmsg)
+        if progress:
+            progress({'phase': 'complete'})
+
+    async def redfish_update_firmware(self, usd, filename, data, progress, bank):
+        if usd['HttpPushUriTargetsBusy']:
+            raise pygexc.TemporaryError('Cannot run multtiple updates to '
+                                        'same target concurrently')
+        z = None
+        wrappedfilename = None
+        uxzcount = 0
+        needseek = False
+        if data and hasattr(data, 'read'):
+            if zipfile.is_zipfile(data):
+                needseek = True
+                z = zipfile.ZipFile(data)
+            else:
+                data.seek(0)
+        elif data is None and zipfile.is_zipfile(filename):
+            z = zipfile.ZipFile(filename)
+        if z:
+            for tmpname in z.namelist():
+                if tmpname.startswith('payloads/'):
+                    uxzcount += 1
+                    if tmpname.endswith('.uxz'):
+                        wrappedfilename = tmpname
+        if uxzcount == 1 and wrappedfilename:
+            filename = os.path.basename(wrappedfilename)
+            data = z.open(wrappedfilename)
+        elif needseek:
+            data.seek(0)
+        upurl = usd['HttpPushUri']
+        await self._do_web_request(
+            '/redfish/v1/UpdateService',
+            {'HttpPushUriTargetsBusy': True}, method='PATCH')
+        try:
+            if bank == 'backup':
+                await self._do_web_request(
+                    '/redfish/v1/UpdateService',
+                    {'HttpPushUriTargets':
+                        ['/redfish/v1/UpdateService'
+                         '/FirmwareInventory/BMC-Backup']}, method='PATCH')
+            uploadtask = await webclient.make_uploader(
+                self.webclient, upurl, filename, data, formwrap=False)
+            wc = self.webclient
+            while not uploadtask.completed():
+                try:
+                    await uploadtask.join(3)
+                except asyncio.TimeoutError:
+                    pass
+                if progress:
+                    progress(
+                        {'phase': 'upload',
+                         'progress': 100 * await uploadtask.get_progress()})
+            rspstatus, rsp, headers = uploadtask.get_response()
+            if not isinstance(rsp, dict):
+                rsp = json.loads(rsp)
+            if (rspstatus >= 300
+                    or rspstatus < 200):
+                errmsg = f'Update attempt resulted in response status {rspstatus}'
+                try:
+                    errmsg = (
+                        rsp['error'][
+                            '@Message.ExtendedInfo'][0]['Message'])
+                except Exception:
+                    errmsg = f'Update attempt resulted in response status {rspstatus}: "{repr(rsp)}"'
+                    raise Exception(errmsg)
+                raise Exception(errmsg)
+            monitorurl = rsp['@odata.id']
+            complete = False
+            phase = "apply"
+            statetype = 'TaskState'
+            # sometimes we get an empty pgress when transitioning from the apply phase to
+            # the validating phase; add a retry here so we don't exit the loop in this case
+            retry = 3
+            while not complete and retry > 0:
+                try:
+                    pgress = await self._do_web_request(monitorurl, cache=False)
+                except socket.socket:
+                    pgress = None
+                if not pgress:
+                    retry -= 1
+                    await asyncio.sleep(3)
+                    continue
+                retry = 3
+                for msg in pgress.get('Messages', []):
+                    if 'Verify failed' in msg.get('Message', ''):
+                        raise Exception(msg['Message'])
+                state = pgress[statetype]
+                if state in ('Cancelled', 'Exception', 'Interrupted',
+                             'Suspended'):
+                    raise Exception(
+                        json.dumps(json.dumps(pgress['Messages'])))
+                pct = float(pgress['PercentComplete'])
+                complete = state == 'Completed'
+                progress({'phase': phase, 'progress': pct})
+                if complete:
+                    msgs = pgress.get('Messages', [])
+                    if msgs and 'OperationTransitionedToJob' in msgs[0].get('MessageId', ''):
+                        monitorurl = pgress['Messages'][0]['MessageArgs'][0]
+                        phase = 'validating'
+                        statetype = 'JobState'
+                        complete = False
+                        await asyncio.sleep(3)
+                else:
+                    await asyncio.sleep(3)
+            if not retry:
+                raise Exception('Falied to monitor update progress due to excessive timeouts')
+            if bank == 'backup':
+                return 'complete'
+            return 'pending'
+        finally:
+            await self._do_web_request(
+                '/redfish/v1/UpdateService',
+                {'HttpPushUriTargetsBusy': False}, method='PATCH')
+            await self._do_web_request(
+                '/redfish/v1/UpdateService',
+                {'HttpPushUriTargets': []}, method='PATCH')
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None):
+        result = None
+        wc = await self.wc()
+        usd = await self._do_web_request('/redfish/v1/UpdateService')
+        rfishurl = usd.get('HttpPushUri', None)
+        if rfishurl:
+            return await self.redfish_update_firmware(
+                usd, filename, data, progress, bank)
+        if self.updating:
+            raise pygexc.TemporaryError('Cannot run multiple updates to same '
+                                        'target concurrently')
+        self.updating = True
+        try:
+            result = await self.update_firmware_backend(filename, data, progress,
+                                                  bank)
+        except Exception:
+            self.updating = False
+            await self._refresh_token()
+            await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+                {'UPD_WebCancel': 1}))
+            raise
+        self.updating = False
+        return result
+
+    async def update_firmware_backend(self, filename, data=None, progress=None,
+                                bank=None):
+        self._refresh_token()
+        wc = await self.wc()
+        rsv = await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+            {'UPD_WebReserve': 1}))
+        if rsv['return'] == 103:
+            raise Exception('Update already in progress')
+        if rsv['return'] != 0:
+            raise Exception('Unexpected return to reservation: ' + repr(rsv))
+        xid = random.randint(0, 1000000000)
+        uploadthread = await webclient.make_uploader(
+            wc, '/upload?X-Progress-ID={0}'.format(xid), filename, data)
+        while not uploadthread.completed():
+            try:
+                await uploadthread.join(3)
+            except asyncio.TimeoutError:
+                pass
+            rsp = await wc.grab_json_response(
+                '/upload/progress?X-Progress-ID={0}'.format(xid))
+            if rsp['state'] == 'uploading':
+                progress({'phase': 'upload',
+                          'progress': 100.0 * rsp['received'] / rsp['size']})
+            elif rsp['state'] != 'done':
+                if (rsp.get('status', None) == 413
+                        or uploadthread.rspstatus == 413):
+                    raise Exception('File is larger than supported')
+                raise Exception('Unexpected result:' + repr(rsp))
+            uploadstate = rsp['state']
+            self._refresh_token()
+        while uploadstate != 'done':
+            rsp = await wc.grab_json_response(
+                '/upload/progress?X-Progress-ID={0}'.format(xid))
+            uploadstate = rsp['state']
+            await self._refresh_token()
+        rspstatus, rsp, headers = uploadthread.get_response()
+        if rsp['items'][0]['name'] != os.path.basename(filename):
+            raise Exception('Unexpected response: ' + repr(rsp))
+        progress({'phase': 'validating',
+                  'progress': 0.0})
+        await asyncio.sleep(3)
+        # aggressive timing can cause the next call to occasionally
+        # return 25 and fail
+        await self._refresh_token()
+        rsp = await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+            {'UPD_WebSetFileName': rsp['items'][0]['path']}))
+        if rsp.get('return', 0) in (25, 108):
+            raise Exception('Temporary error validating update, try again')
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unexpected return to set filename: ' + errmsg)
+        await self._refresh_token()
+        progress({'phase': 'validating',
+                  'progress': 25.0})
+        rsp = await wc.grab_json_response('/api/providers/fwupdate', json.dumps(
+            {'UPD_WebVerifyUploadFile': 1}))
+        if rsp.get('return', 0) == 115:
+            raise Exception('Update image not intended for this system')
+        elif rsp.get('return', -1) == 108:
+            raise Exception('Temporary error validating update, try again')
+        elif rsp.get('return', -1) == 109:
+            raise Exception('Invalid update file or component '
+                            'does not support remote update')
+        elif rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unexpected return to verify: ' + errmsg)
+        verifystatus = 0
+        verifyuploadfilersp = None
+        while verifystatus != 1:
+            await self._refresh_token()
+            rsp, status = await wc.grab_json_response_with_status(
+                '/api/providers/fwupdate',
+                json.dumps({'UPD_WebVerifyUploadFileStatus': 1}))
+            if not rsp or status != 200 or rsp.get('return', -1) == 2:
+                # The XCC firmware predates the FileStatus api
+                verifyuploadfilersp = rsp
+                break
+            if rsp.get('return', -1) == 109:
+                raise Exception('Invalid update file or component '
+                                'does not support remote update')
+            if rsp.get('return', -1) != 0:
+                errmsg = repr(rsp) if rsp else wc.lastjsonerror
+                raise Exception(
+                    'Unexpected return to verifystate: {0}'.format(errmsg))
+            verifystatus = rsp['status']
+            if verifystatus == 2:
+                raise Exception('Failed to verify firmware image')
+            if verifystatus != 1:
+                await asyncio.sleep(1)
+            if verifystatus not in (0, 1, 255):
+                errmsg = repr(rsp) if rsp else wc.lastjsonerror
+                raise Exception(
+                    'Unexpected reply to verifystate: ' + errmsg)
+        progress({'phase': 'validating',
+                  'progress': 99.0})
+        await self._refresh_token()
+        rsp = await wc.grab_json_response('/api/dataset/imm_firmware_success')
+        if len(rsp['items']) != 1:
+            raise Exception('Unexpected result: ' + repr(rsp))
+        firmtype = rsp['items'][0]['firmware_type']
+        if not firmtype:
+            raise Exception('Unknown firmware description returned: ' + repr(
+                rsp['items'][0]) + ' last verify return was: ' + repr(
+                    verifyuploadfilersp) + ' with code {0}'.format(status))
+        if firmtype not in (
+                'TDM', 'WINDOWS DRIV', 'LINUX DRIVER', 'UEFI', 'IMM'):
+            # adapter firmware
+            webid = rsp['items'][0]['webfile_build_id']
+            locations = webid[webid.find('[') + 1:webid.find(']')]
+            locations = locations.split(':')
+            validselectors = set([])
+            for loc in locations:
+                validselectors.add(loc.replace('#', '-'))
+            await self._refresh_token()
+            rsp = await wc.grab_json_response(
+                '/api/function/adapter_update?params=pci_GetAdapterListAndFW')
+            foundselectors = []
+            for adpitem in rsp['items']:
+                selector = '{0}-{1}'.format(adpitem['location'],
+                                            adpitem['slotNo'])
+                if selector in validselectors:
+                    foundselectors.append(selector)
+                    if len(foundselectors) == len(validselectors):
+                        break
+            else:
+                raise Exception('Could not find matching adapter for update')
+            await self._refresh_token()
+            rsp = await wc.grab_json_response('/api/function', json.dumps(
+                {'pci_SetOOBFWSlots': '|'.join(foundselectors)}))
+            if rsp.get('return', -1) != 0:
+                errmsg = repr(rsp) if rsp else wc.lastjsonerror
+                raise Exception(
+                    'Unexpected result from PCI select: ' + errmsg)
+        else:
+            await self._refresh_token()
+            rsp = await wc.grab_json_response(
+                '/api/dataset/imm_firmware_update')
+            if rsp['items'][0]['upgrades'][0]['id'] != 1:
+                raise Exception('Unexpected answer: ' + repr(rsp))
+        await self._refresh_token()
+        progress({'phase': 'apply',
+                  'progress': 0.0})
+        if bank in ('primary', None):
+            rsp = await wc.grab_json_response(
+                '/api/providers/fwupdate', json.dumps(
+                    {'UPD_WebStartDefaultAction': 1}))
+        elif bank == 'backup':
+            rsp = await wc.grab_json_response(
+                '/api/providers/fwupdate', json.dumps(
+                    {'UPD_WebStartOptionalAction': 2}))
+
+        if rsp.get('return', -1) != 0:
+            errmsg = repr(rsp) if rsp else wc.lastjsonerror
+            raise Exception('Unexpected result starting update: %s' % errmsg)
+        complete = False
+        while not complete:
+            await self._refresh_token()
+            await asyncio.sleep(3)
+            rsp = await wc.grab_json_response(
+                '/api/dataset/imm_firmware_progress')
+            progress({'phase': 'apply',
+                      'progress': rsp['items'][0]['action_percent_complete']})
+            if rsp['items'][0]['action_state'] == 'Idle':
+                complete = True
+                break
+            if rsp['items'][0]['action_state'] == 'Complete OK':
+                complete = True
+                if rsp['items'][0]['action_status'] != 0:
+                    raise Exception('Unexpected failure: %s' % repr(rsp))
+                break
+            if (rsp['items'][0]['action_state'] == 'In Progress'
+                    and rsp['items'][0]['action_status'] == 2):
+                raise Exception('Unexpected failure: ' + repr(rsp))
+            if rsp['items'][0]['action_state'] != 'In Progress':
+                raise Exception(
+                    'Unknown condition waiting for '
+                    'firmware update: %s' % repr(rsp))
+        if bank == 'backup':
+            return 'complete'
+        return 'pending'
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        wc = await self.wc()
+        rsp = await wc.grab_json_response('/api/providers/ffdc',
+                                         {'Generate_FFDC': 1})
+        if rsp.get('return', 0) == 4:
+            rsp = await wc.grab_json_response('/api/providers/ffdc',
+                                             {'Generate_FFDC': 1,
+                                              'thermal_log': 0})
+        percent = 0
+        while percent != 100:
+            await asyncio.sleep(3)
+            result = await wc.grab_json_response('/api/providers/ffdc',
+                                                {'Generate_FFDC_status': 1})
+            await self._refresh_token()
+            if progress:
+                progress({'phase': 'initializing', 'progress': float(percent)})
+            percent = result['progress']
+        while 'FileName' not in result:
+            result = await wc.grab_json_response('/api/providers/ffdc',
+                                                {'Generate_FFDC_status': 1})
+        url = '/ffdc/{0}'.format(result['FileName'])
+        if autosuffix and not savefile.endswith('.tzz'):
+            savefile += '-{0}'.format(result['FileName'])
+        fd = webclient.make_downloader(wc, url, savefile)
+        while not fd.completed():
+            try:
+                await fd.join(1)
+            except asyncio.TimeoutError:
+                pass
+            if progress and await fd.get_progress() > 0:
+                progress({'phase': 'download',
+                            'progress': 100 * await fd.get_progress()})
+            await self._refresh_token()
+        if progress:
+            progress({'phase': 'complete'})
+        return savefile
+
+    async def get_licenses(self, fishclient):
+        wc = await self.wc()
+        licdata = await wc.grab_json_response('/api/providers/imm_fod')
+        for lic in licdata.get('items', [{}])[0].get('keys', []):
+            if lic['status'] == 0:
+                yield {'name': lic['feature'], 'state': 'Active'}
+            if lic['status'] == 10:
+                yield {
+                    'name': lic['feature'],
+                    'state': 'Missing required license'
+                }
+
+    async def delete_license(self, name, fishclient):
+        wc = await self.wc()
+        licdata = await wc.grab_json_response('/api/providers/imm_fod')
+        for lic in licdata.get('items', [{}])[0].get('keys', []):
+            if lic.get('feature', None) == name:
+                licid = ','.join((str(lic['type']), str(lic['id'])))
+                await wc.grab_json_response(
+                    '/api/providers/imm_fod',
+                    {
+                        'FOD_LicenseKeyDelete': licid
+                    }
+                )
+                break
+
+    async def save_licenses(self, directory, fishclient):
+        wc = await self.wc()
+        licdata = await wc.grab_json_response('/api/providers/imm_fod')
+        for lic in licdata.get('items', [{}])[0].get('keys', []):
+            licid = ','.join((str(lic['type']), str(lic['id'])))
+            rsp = await wc.grab_json_response(
+                '/api/providers/imm_fod', {'FOD_LicenseKeyExport': licid})
+            filename = rsp.get('FileName', None)
+            if filename:
+                url = '/download/' + filename
+                savefile = os.path.join(directory, filename)
+                fd = webclient.make_downloader(wc, url, savefile)
+                while not fd.completed():
+                    try:
+                        await fd.join(1)
+                    except asyncio.TimeoutError:
+                        pass
+                    await self._refresh_token()
+                yield savefile
+
+    async def apply_license(self, filename, fishclient, progress=None, data=None):
+        license_errors = {
+            310: "License is for a different model of system",
+            311: "License is for a different system serial number",
+            312: "License is invalid",
+            313: "License is expired",
+            314: "License usage limit reached",
+        }
+        wc = await self.wc()
+        uploadthread = await webclient.make_uploader(wc, '/upload', filename,
+                                              data=data)
+        await uploadthread.join()
+        rspstatus, rsp, headers = uploadthread.get_response()
+        licpath = rsp.get('items', [{}])[0].get('path', None)
+        if licpath:
+            rsp = await wc.grab_json_response(
+                '/api/providers/imm_fod',
+                {
+                    'FOD_LicenseKeyInstall': licpath
+                }
+            )
+            if rsp.get('return', 0) in license_errors:
+                raise pygexc.InvalidParameterValue(
+                    license_errors[rsp['return']])
+
+    async def user_delete(self, uid, fishclient=None):
+        wc = await self.wc()
+        userinfo = await wc.grab_json_response('/api/dataset/imm_users')
+        uidtonamemap = {}
+        for user in userinfo.get('items', [{'users': []}])[0].get('users', []):
+            uidtonamemap[user['users_user_id']] = user['users_user_name']
+        if uid in uidtonamemap:
+            deltarget = '{0},{1}'.format(uid, uidtonamemap[uid])
+            await wc.grab_json_response('/api/function', {"USER_UserDelete": deltarget})
+            return True
+        return await super(OEMHandler, self).user_delete(uid)
+
+    async def get_user_expiration(self, uid):
+        wc = await self.wc()
+        userinfo = await wc.grab_json_response('/api/dataset/imm_users')
+        for user in userinfo['items'][0]['users']:
+            if str(user['users_user_id']) == str(uid):
+                days = user['users_pass_left_days']
+                if days == 366:
+                    return 0
+                else:
+                    return days
+
+    def get_inventory_descriptions(self, withids=False):
+        hwmap = self.hardware_inventory_map()
+        yield "System"
+        for key in natural_sort(hwmap):
+            yield key
+        for cpuinv in self._get_cpu_inventory():
+            yield cpuinv[0]
+        for meminv in self._get_mem_inventory():
+            yield meminv[0]
+
+
+    def get_inventory_of_component(self, compname):
+        if compname.lower() == 'system':
+            sysinfo = {
+                'UUID': self._varsysinfo.get('UUID', ''),
+                'Serial Number': self._varsysinfo.get('SerialNumber', ''),
+                'Manufacturer': self._varsysinfo.get('Manufacturer', ''),
+                'Product name': self._varsysinfo.get('Model', ''),
+                'Model': self._varsysinfo.get(
+                    'SKU', self._varsysinfo.get('PartNumber', '')),
+            }
+            return sysinfo
+        hwmap = self.hardware_inventory_map()
+        try:
+            return hwmap[compname]
+        except KeyError:
+            for cpuinv in self._get_cpu_inventory():
+                if cpuinv[0] == compname:
+                    return cpuinv[1]
+            for meminv in self._get_mem_inventory():
+                if meminv[0] == compname:
+                    return meminv[1]
+
+
+            return None
+
+    async def get_inventory(self, withids=False):
+        sysinfo = {
+            'UUID': self._varsysinfo.get('UUID', ''),
+            'Serial Number': self._varsysinfo.get('SerialNumber', ''),
+            'Manufacturer': self._varsysinfo.get('Manufacturer', ''),
+            'Product name': self._varsysinfo.get('Model', ''),
+            'Model': self._varsysinfo.get(
+                'SKU', self._varsysinfo.get('PartNumber', '')),
+        }
+        yield ('System', sysinfo)
+        async for cpuinv in self._get_cpu_inventory():
+            yield cpuinv
+        async for meminv in self._get_mem_inventory():
+            yield meminv
+        hwmap = await self.hardware_inventory_map()
+        for key in natural_sort(hwmap):
+            yield (key, hwmap[key])
+
+    async def hardware_inventory_map(self):
+        hwmap = self.get_cached_data('lenovo_cached_hwmap')
+        if hwmap:
+            return hwmap
+        hwmap = {}
+        async for disk in self.disk_inventory(mode=1):  # hardware mode
+            hwmap[disk[0]] = disk[1]
+        adapterdata = self.get_cached_data('lenovo_cached_adapters')
+        if not adapterdata:
+            if self.updating:
+                raise pygexc.TemporaryError(
+                    'Cannot read extended inventory during firmware update')
+            wc = await self.wc()
+            if wc:
+                adapterdata = await wc.grab_json_response(self.ADP_URL)
+                if adapterdata:
+                    self.datacache['lenovo_cached_adapters'] = (
+                        adapterdata, util._monotonic_time())
+        if adapterdata and 'items' in adapterdata:
+            anames = {}
+            for adata in adapterdata['items']:
+                skipadapter = False
+                clabel = adata[self.ADP_LABEL]
+                if clabel == 'Unknown':
+                    continue
+                if clabel != 'Onboard':
+                    aslot = adata[self.ADP_SLOTNO]
+                    if clabel == 'ML2':
+                        clabel = 'ML2 (Slot {0})'.format(aslot)
+                    else:
+                        clabel = 'Slot {0}'.format(aslot)
+                aname = adata[self.ADP_NAME]
+                bdata = {'location': clabel, 'name': aname}
+                if aname in anames:
+                    anames[aname] += 1
+                    aname = '{0} {1}'.format(aname, anames[aname])
+                else:
+                    anames[aname] = 1
+                for fundata in adata[self.ADP_FUN]:
+                    bdata['pcislot'] = '{0:02x}:{1:02x}'.format(
+                        fundata[self.BUSNO], fundata[self.DEVNO])
+                    serialdata = fundata.get(self.ADP_SERIALNO, None)
+                    if (serialdata and serialdata != 'N/A'
+                            and '---' not in serialdata):
+                        bdata['serial'] = serialdata
+                    partnum = fundata.get(self.ADP_PARTNUM, None)
+                    if partnum and partnum != 'N/A':
+                        bdata['Part Number'] = partnum
+                    cardtype = funtypes.get(fundata.get('funType', None),
+                                            None)
+                    if cardtype is not None:
+                        bdata['Type'] = cardtype
+                    venid = fundata.get(self.ADP_VENID, None)
+                    if venid is not None:
+                        bdata['PCI Vendor ID'] = '{0:04x}'.format(venid)
+                    devid = fundata.get(self.ADP_DEVID, None)
+                    if devid is not None and 'PCIE Device ID' not in bdata:
+                        bdata['PCI Device ID'] = '{0:04x}'.format(devid)
+                    venid = fundata.get(self.ADP_SUBVENID, None)
+                    if venid is not None:
+                        bdata['PCI Subsystem Vendor ID'] = '{0:04x}'.format(
+                            venid)
+                    devid = fundata.get(self.ADP_SUBDEVID, None)
+                    if devid is not None:
+                        bdata['PCI Subsystem Device ID'] = '{0:04x}'.format(
+                            devid)
+                    fruno = fundata.get(self.ADP_FRU, None)
+                    if fruno is not None:
+                        bdata['FRU Number'] = fruno
+                    if self.PORTS in fundata:
+                        for portinfo in fundata[self.PORTS]:
+                            for lp in portinfo['logicalPorts']:
+                                ma = lp['networkAddr']
+                                ma = ':'.join(
+                                    [ma[i:i + 2] for i in range(
+                                        0, len(ma), 2)]).lower()
+                                bdata['MAC Address {0}'.format(
+                                    portinfo['portIndex'])] = ma
+                    elif clabel == 'Onboard':  # skip the various non-nic
+                        skipadapter = True
+                if not skipadapter:
+                    hwmap[aname] = bdata
+            self.datacache['lenovo_cached_hwmap'] = (hwmap,
+                                                     util._monotonic_time())
+        # self.weblogout()
+        return hwmap
+
+    async def disk_inventory(self, mode=0):
+        # mode 0 is firmware, 1 is hardware
+        storagedata = self.get_cached_data('lenovo_cached_storage')
+        if not storagedata:
+            wc = await self.wc()
+            if wc:
+                storagedata = await wc.grab_json_response(
+                    '/api/function/raid_alldevices?params=storage_GetAllDisks')
+                if storagedata:
+                    self.datacache['lenovo_cached_storage'] = (
+                        storagedata, util._monotonic_time())
+        if storagedata and 'items' in storagedata:
+            for adp in storagedata['items']:
+                for diskent in adp.get('disks', ()):
+                    if mode == 0:
+                        yield self.get_disk_firmware(diskent)
+                    elif mode == 1:
+                        yield self.get_disk_hardware(diskent)
+                for diskent in adp.get('aimDisks', ()):
+                    if mode == 0:
+                        yield self.get_disk_firmware(diskent)
+                    elif mode == 1:
+                        yield self.get_disk_hardware(diskent)
+                if mode == 1:
+                    bdata = {'Description': 'Unmanaged Disk'}
+                    if adp.get('m2Type', -1) == 2:
+                        yield 'M.2 Disk', bdata
+                    for umd in adp.get('unmanagedDisks', []):
+                        yield 'Disk {0}'.format(umd['slotNo']), bdata
+
+    async def _get_cpu_inventory(self):
+        procdata = self.get_cached_data('lenovo_cached_proc')
+        if not procdata:
+            wc = await self.wc()
+            if wc:
+                procdata = await wc.grab_json_response(
+                    '/api/dataset/imm_processors')
+                if procdata:
+                    self.datacache['lenovo_cached_proc'] = (
+                        procdata, util._monotonic_time())
+        if procdata:
+            for proc in procdata.get('items', [{}])[0].get('processors', []):
+                procinfo = {
+                    'Model': proc['processors_cpu_model']
+                }
+                yield ('Processor {0}'.format(proc['processors_name']),
+                       procinfo)
+
+    async def _get_mem_inventory(self):
+        memdata = self.get_cached_data('lenovo_cached_memory')
+        if not memdata:
+            wc = await self.wc()
+            if wc:
+                memdata = await wc.grab_json_response(
+                    '/api/dataset/imm_memory')
+                if memdata:
+                    self.datacache['lenovo_cached_memory'] = (
+                        memdata, util._monotonic_time())
+        if memdata:
+            for dimm in memdata.get('items', [{}])[0].get('memory', []):
+                memdata = {}
+                memdata['speed'] = dimm['memory_mem_speed'] * 8 // 100 * 100
+                memdata['module_type'] = 'RDIMM'
+                memdata['capacity_mb'] = dimm['memory_capacity'] * 1024
+                memdata['manufacturer'] = dimm['memory_manufacturer']
+                memdata['memory_type'] = dimm['memory_type']
+                memdata['model'] = dimm['memory_part_number'].rstrip()
+                memdata['serial'] = dimm['memory_serial_number']
+                yield (dimm['memory_name'], memdata)
+
+    def get_disk_hardware(self, diskent, prefix=''):
+        bdata = {}
+        if not prefix:
+            location = diskent.get('location', '')
+            if location.startswith('M.2'):
+                prefix = 'M.2-'
+            elif location.startswith('7MM'):
+                prefix = '7MM-'
+        diskname = 'Disk {1}{0}'.format(diskent['slotNo'], prefix)
+        bdata['Model'] = diskent['productName'].rstrip()
+        bdata['Serial Number'] = diskent['serialNo'].rstrip()
+        bdata['FRU Number'] = diskent['fruPartNo'].rstrip()
+        bdata['Description'] = diskent['type'].rstrip()
+        return (diskname, bdata)
diff --git a/confluent_server/aiohmi/redfish/oem/lenovo/xcc3.py b/confluent_server/aiohmi/redfish/oem/lenovo/xcc3.py
new file mode 100644
index 00000000..fe3dc109
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/lenovo/xcc3.py
@@ -0,0 +1,1213 @@
+# Copyright 2025 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import asyncio
+import copy
+import json
+import re
+import aiohmi.constants as pygconst
+import aiohmi.redfish.oem.generic as generic
+import aiohmi.exceptions as pygexc
+import aiohmi.util.webclient as webclient
+import aiohmi.storage as storage
+import aiohmi.ipmi.private.util as util
+import os.path
+import zipfile
+
+numregex = re.compile('([0-9]+)')
+
+def naturalize_string(key):
+    """Analyzes string in a human way to enable natural sort
+
+    :param key: string for the split
+    :returns: A structure that can be consumed by 'sorted'
+    """
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(numregex, key)]
+
+def natural_sort(iterable):
+    """Return a sort using natural sort if possible
+
+    :param iterable:
+    :return:
+    """
+    try:
+        return sorted(iterable, key=naturalize_string)
+    except TypeError:
+        # The natural sort attempt failed, fallback to ascii sort
+        return sorted(iterable)
+
+class SensorReading(object):
+    def __init__(self, healthinfo, sensor=None, value=None, units=None,
+                 unavailable=False):
+        if sensor:
+            self.name = sensor['name']
+        else:
+            self.name = healthinfo['name']
+            self.health = healthinfo['health']
+            self.states = healthinfo['states']
+            self.state_ids = healthinfo.get('state_ids', None)
+        self.value = value
+        self.imprecision = None
+        self.units = units
+        self.unavailable = unavailable
+
+class OEMHandler(generic.OEMHandler):
+
+    @classmethod
+    async def create(cls, sysinfo, sysurl, webclient, cache, gpool=None):
+        self = await super(OEMHandler, cls).create(sysinfo, sysurl, webclient, cache,
+                                         gpool)
+        self.datacache = {}
+        return self
+
+    async def weblogout(self):
+        if self.webclient:
+            try:
+                await self.webclient.grab_json_response('/logout')
+            except Exception:
+                pass
+    
+    def get_cached_data(self, attribute, age=30):
+        try:
+            kv = self.datacache[attribute]
+            if kv[1] > util._monotonic_time() - age:
+                return kv[0]
+        except KeyError:
+            return None
+    
+    async def get_inventory(self, withids=False):
+        sysinfo = {
+            'UUID': self._varsysinfo.get('UUID', '').lower(),
+            'Serial Number': self._varsysinfo.get('SerialNumber', ''),
+            'Manufacturer': self._varsysinfo.get('Manufacturer', ''),
+            'Product name': self._varsysinfo.get('Model', ''),
+            'Model': self._varsysinfo.get(
+                'SKU', self._varsysinfo.get('PartNumber', '')),
+        }
+        yield ('System', sysinfo)
+        async for cpuinv in self._get_cpu_inventory():
+            yield cpuinv
+        async for meminv in self._get_mem_inventory():
+            yield meminv
+        hwmap = await self.hardware_inventory_map()
+        for key in natural_sort(hwmap):
+            yield (key, hwmap[key])
+    
+    async def hardware_inventory_map(self):
+        hwmap = self.get_cached_data('lenovo_cached_hwmap')
+        if hwmap:
+            return hwmap
+        hwmap = {}
+        async for disk in self.disk_inventory(mode=1):  # hardware mode
+            hwmap[disk[0]] = disk[1]
+        adapterdata = self.get_cached_data('lenovo_cached_adapters')
+        if not adapterdata:
+            # if self.updating:
+            #     raise pygexc.TemporaryError(
+            #         'Cannot read extended inventory during firmware update')
+            if self.webclient:
+                adapterdata = []
+                async for adata in self._do_bulk_requests([i['@odata.id'] for i in (await self.webclient.grab_json_response(
+                        '/redfish/v1/Chassis/1'))['Links']['PCIeDevices']]):
+                    adapterdata.append(adata)           
+                if adapterdata:
+                    self.datacache['lenovo_cached_adapters'] = (
+                        adapterdata, util._monotonic_time())
+        if adapterdata:
+            anames = {}
+            for adata, _ in adapterdata:
+                skipadapter = False
+                clabel = adata['Slot']['Location']['PartLocation'].get('LocationType','')
+                if not clabel:
+                    clabel = adata['Slot']['Location']['PartLocation'].get('ServiceLabel', '').split("=")[0]                
+                if clabel != 'Embedded':
+                    aslot = adata['Slot']['Location']['PartLocation']['LocationOrdinalValue']
+                    clabel = 'Slot {0}'.format(aslot)
+                aname = adata['Name']
+                bdata = {'location': clabel, 'name': aname}
+                if aname in anames:
+                    anames[aname] += 1
+                    aname = '{0} {1}'.format(aname, anames[aname])
+                else:
+                    anames[aname] = 1
+                pcislot = adata['Id'].split('_')[1]
+                bdata['pcislot'] = '{0}:{1}.{2}'.format(
+                    pcislot[:4].replace('0x',''), pcislot[4:6], pcislot[6:8]
+                )
+                serialdata = adata.get('SerialNumber', '')
+                if (serialdata and serialdata != 'N/A'
+                        and '---' not in serialdata):
+                    bdata['serial'] = serialdata
+                partnum = adata.get('PartNumber', '')
+                if partnum and partnum != 'N/A':
+                    bdata['Part Number'] = partnum
+                fundata = await self._get_expanded_data(adata['PCIeFunctions']['@odata.id'])
+                venid = fundata['Members'][0].get('VendorId', None)
+                if venid is not None:
+                    bdata['PCI Vendor ID'] = venid.lower().split('0x')[-1]
+                devid = fundata['Members'][0].get('DeviceId', None)
+                if devid is not None and 'PCIE Device ID' not in bdata:
+                    bdata['PCI Device ID'] = devid.lower().split('0x')[-1]
+                subvenid = fundata['Members'][0].get('SubsystemVendorId', None)
+                if subvenid is not None:
+                    bdata['PCI Subsystem Vendor ID'] = subvenid.lower().split('0x')[-1]
+                subdevid = fundata['Members'][0].get('SubsystemId', None)
+                if subdevid is not None:
+                    bdata['PCI Subsystem Device ID'] = subdevid.lower().split('0x')[-1]
+                bdata['FRU Number'] = adata.get('SKU', '')
+
+                # Could be identified also through Oem->Lenovo->FunctionClass
+                if fundata['Members'][0]['DeviceClass'] == 'NetworkController':
+                    ports_data = await self._get_expanded_data('{0}/Ports'.format(adata['@odata.id'].replace('PCIeDevices','NetworkAdapters')))
+                    macidx = 1
+                    for port in ports_data['Members']:
+                        if port.get('Ethernet', None):
+                            macs = [x for x in port['Ethernet'].get('AssociatedMACAddresses', [])]
+                            for mac in macs:
+                                label = 'MAC Address {}'.format(macidx)
+                                bdata[label] = generic._normalize_mac(mac)
+                                macidx += 1
+                        ibinfo = port.get('InfiniBand', {})
+                        if ibinfo:
+                            macs = [x for x in ibinfo.get('AssociatedPortGUIDs', [])]
+                            for mac in macs:
+                                label = 'Port GUID {}'.format(macidx)
+                                bdata[label] = mac
+                                macidx += 1                        
+
+                hwmap[aname] = bdata
+            self.datacache['lenovo_cached_hwmap'] = (hwmap,
+                                                     util._monotonic_time())
+        # self.weblogout()
+        return hwmap
+
+    def get_disk_firmware(self, diskent, prefix=''):
+        bdata = {}
+        if not prefix:
+            location = diskent.get('Name', '')
+            if location.startswith('M.2'):
+                prefix = 'M.2-'
+            elif location.startswith('7MM'):
+                prefix = '7MM-'
+        diskname = 'Disk {0}{1}'.format(prefix, diskent['PhysicalLocation']['PartLocation']['LocationOrdinalValue'])
+        bdata['model'] = '{0}_{1}'.format(diskent['Manufacturer'].rstrip(), diskent['Model'].rstrip())
+        bdata['version'] = diskent.get('FirmwareVersion','')
+        return (diskname, bdata)
+
+    def get_disk_hardware(self, diskent, prefix=''):
+        bdata = {}
+        if not prefix:
+            location = diskent.get('Name', '')
+            if location.startswith('M.2'):
+                prefix = 'M.2-'
+            elif location.startswith('7MM'):
+                prefix = '7MM-'
+        diskname = 'Disk {0}{1}'.format(prefix, diskent['PhysicalLocation']['PartLocation']['LocationOrdinalValue'])
+        bdata['Model'] = '{0}_{1}'.format(diskent['Manufacturer'].rstrip(), diskent['Model'].rstrip())
+        bdata['Serial Number'] = diskent['SerialNumber'].rstrip()
+        bdata['FRU Number'] = diskent['SKU'].rstrip()
+        bdata['Description'] = diskent['Oem']['Lenovo']['TypeString'].rstrip()
+        return (diskname, bdata)
+
+    async def disk_inventory(self, mode=0):
+        # mode 0 is firmware, 1 is hardware
+        storagedata = self.get_cached_data('lenovo_cached_storage')
+        if not storagedata:
+                if self.webclient:
+                    chassisinfo = await self.webclient.grab_json_response('/redfish/v1/Chassis/1')
+                    storagedata = []
+                    async for data in self._do_bulk_requests([i['@odata.id'] for i in chassisinfo['Links']['Drives']]):
+                        storagedata.append(data)
+                    if storagedata:
+                        self.datacache['lenovo_cached_storage'] = (
+                            storagedata, util._monotonic_time())
+        # Unmanaged disks cannot be retrieved through Redfish API
+        if storagedata:
+            for diskent, _ in storagedata:
+                if mode == 0:
+                    yield self.get_disk_firmware(diskent)
+                elif mode == 1:
+                    yield self.get_disk_hardware(diskent)
+
+    async def get_storage_configuration(self, logout=True):
+        rsp = await self._get_expanded_data("/redfish/v1/Systems/1/Storage")
+        standalonedisks = []
+        pools = []
+        for item in rsp.get('Members',[]):
+            # Drives shown at 'Direct attached drives' in XCC
+            # cannot be used for RAID creation
+            if item['Id'].lower() == 'direct_attached_nvme':
+                continue            
+            cdisks = [item['Drives'][i]['@odata.id'] for i in range(len(item['Drives']))]
+            cid = '{0},{1}'.format(
+                        item['Id'],
+                        item['StorageControllers'][0]['Location']['PartLocation'].get('LocationOrdinalValue', -1))
+            if item['Id'].lower() == 'vroc':
+                cid = 'vroc,0'            
+            storage_pools = await self._get_expanded_data(item['StoragePools']['@odata.id'])
+            for p in storage_pools['Members']:
+                vols = await self._get_expanded_data(p['AllocatedVolumes']['@odata.id'])
+                for vol in vols['Members']:
+                    volumes=[]
+                    disks=[]
+                    spares=[]
+                    volumes.append(
+                        storage.Volume(name=vol['DisplayName'],
+                                    size=int(vol['CapacityBytes'])/1024//1024,
+                                    status=vol['Status']['Health'],
+                                    id=(cid,vol['Id'])))
+                    for item_key, disk_ids in vol['Links'].items():
+                        if isinstance(disk_ids, list) and 'drives' in item_key.lower():
+                            for disk in disk_ids:
+                                if disk['@odata.id'] in cdisks:
+                                    cdisks.remove(disk['@odata.id'])
+                                disk_data = await self.webclient.grab_json_response(disk['@odata.id'])
+                                (spares if disk_data['Oem']['Lenovo']['DriveStatus']=="DedicatedHotspare" else disks).append(
+                                    storage.Disk(
+                                        name=disk_data['Name'], description=disk_data['Oem']['Lenovo']['TypeString'],
+                                        id=(cid, disk_data['Id']), status=disk_data['Oem']['Lenovo']['DriveStatus'],
+                                        serial=disk_data['SerialNumber'], fru=disk_data['SKU']))
+                    raid=vol['RAIDType']
+                totalsize = int(p['Capacity']['Data']['AllocatedBytes'])/1024//1024
+                freesize = totalsize - int(p['Capacity']['Data']['ConsumedBytes'])/1024//1024
+                pools.append(storage.Array(
+                    disks=disks, raid=raid, volumes=volumes,
+                    id=(cid, p['Id']), hotspares=spares,
+                    capacity=totalsize, available_capacity=freesize))
+            for d in cdisks:
+                disk_data = await self.webclient.grab_json_response(d)
+                standalonedisks.append(
+                    storage.Disk(
+                        name=disk_data['Name'], description=disk_data['Oem']['Lenovo']['TypeString'],
+                        id=(cid, disk_data['Id']), status=disk_data['Oem']['Lenovo']['DriveStatus'],
+                        serial=disk_data['SerialNumber'], fru=disk_data['SKU']))
+        return storage.ConfigSpec(disks=standalonedisks, arrays=pools)
+
+    async def check_storage_configuration(self, cfgspec=None):
+        rsp = await self.webclient.grab_json_response(
+            '/api/providers/raidlink_GetStatus')
+        if rsp['return'] != 0 or rsp['status'] != 1:
+            raise pygexc.TemporaryError('Storage configuration unavailable in '
+                                        'current state (try boot to setup or '
+                                        'an OS)')
+        return True
+
+    async def apply_storage_configuration(self, cfgspec):
+        realcfg = await self.get_storage_configuration(False)
+        for disk in cfgspec.disks:
+            if disk.status.lower() == 'jbod':
+                await self._make_jbod(disk, realcfg)
+            elif disk.status.lower() == 'hotspare':
+                await self._make_global_hotspare(disk, realcfg)
+            elif disk.status.lower() in ('unconfigured', 'available', 'ugood',
+                                         'unconfigured good'):
+                await self._make_available(disk, realcfg)
+        for pool in cfgspec.arrays:
+            if pool.disks:
+                await self._create_array(pool)
+
+    async def _make_available(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        newstate = None
+        if currstatus.lower() == 'unconfiguredgood':
+            return
+        elif currstatus.lower() == 'globalhotspare':
+            newstate = "None"
+        elif currstatus.lower() == 'jbod':
+            newstate = "MakeUnconfiguredGood"
+        await self._set_drive_state(disk, newstate)
+
+    async def _make_jbod(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        if currstatus.lower() == 'jbod':
+            return
+        await self._make_available(disk, realcfg)
+        await self._set_drive_state(disk, "MakeJBOD")
+
+    async def _make_global_hotspare(self, disk, realcfg):
+        currstatus = self._get_status(disk, realcfg)
+        if currstatus.lower() == 'globalhotspare':
+            return
+        await self._make_available(disk, realcfg)
+        await self._set_drive_state(disk, "Global")
+    
+    async def _set_drive_state(self, disk, state):
+        raid_alldevices = await self.webclient.grab_json_response(
+            '/api/providers/raid_alldevices')
+        if raid_alldevices.get('return', -1) != 0:
+            raise Exception(
+                'Unexpected return to get all RAID devices information')
+        for c in raid_alldevices.get('StorageComplexes',[]):
+            cslot = str(c.get('SlotNumber'))
+            if cslot == disk.id[0].split(',')[1]:
+                c_pciaddr = c.get('PCIeAddress',-1)
+                cdrives = c.get('Drives',[])
+                for d in cdrives:
+                    if disk.id[1] == d.get('Id',''):
+                        currstatus = d['Oem']['Lenovo']['DriveStatus']
+                        d_resid = d['Internal']['ResourceId']
+                        if state in ("Global", "None"):
+                            data = {
+                                "controller_address": c_pciaddr,
+                                "drive_resource_id": d_resid,
+                                "hotspare_type": state,
+                                "pool_resource_ids": []}
+                            raidlink_url = '/api/providers/raidlink_AssignHotSpare'
+                        else:
+                            data = {
+                                "controller_address": c_pciaddr,
+                                "drive_operation": state,
+                                "drive_resource_ids": [d_resid]}
+                            raidlink_url = '/api/providers/raidlink_DiskStateAction'
+                        msg = await self._do_web_request(raidlink_url, method='POST', 
+                                                   payload=data, cache=False)
+                        if msg.get('return', -1) != 0:
+                            raise Exception(
+                                'Unexpected return to set disk state: {0}'.format(
+                                msg.get('return', -1)))
+                        set_state_token = msg.get('token', '')
+                        msg = await self._do_web_request(
+                            '/api/providers/raidlink_QueryAsyncStatus',
+                            method='POST',
+                            payload={"token": set_state_token},
+                            cache=False)
+                        while msg['status'] == 2:
+                            await asyncio.sleep(1)
+                            msg = await self._do_web_request(
+                            '/api/providers/raidlink_QueryAsyncStatus',
+                            method='POST',
+                            payload={"token": set_state_token},
+                            cache=False)
+                        if msg.get('return',-1) != 0 or msg.get('status',-1) != 0:
+                            raise Exception(
+                                'Unexpected return to set disk state: {0}'.format(
+                                msg.get('return', -1)))
+                        disk_url=f"/redfish/v1/Systems/1/Storage/{disk.id[0].split(',')[0]}/Drives/{disk.id[1]}"
+                        newstatus = await self.webclient.grab_json_response(disk_url)
+                        disk_converted = False
+                        for _ in range(60):
+                            if currstatus == newstatus['Oem']['Lenovo']['DriveStatus']:
+                                await asyncio.sleep(1)
+                                newstatus = await self.webclient.grab_json_response(disk_url)
+                            else:
+                                disk_converted = True
+                                break
+                        if not disk_converted:
+                            raise Exception(
+                                'Disk set command was successful, but the disk state is unchanged')
+
+    def _get_status(self, disk, realcfg):
+        for cfgdisk in realcfg.disks:
+            if disk.id == cfgdisk.id:
+                currstatus = cfgdisk.status
+                break
+        else:
+            raise pygexc.InvalidParameterValue('Requested disk not found')
+        return currstatus
+    
+    async def remove_storage_configuration(self, cfgspec):
+        realcfg = await self.get_storage_configuration(False)
+        for pool in cfgspec.arrays:
+            for volume in pool.volumes:
+                cid = volume.id[0].split(',')[0]
+                vid = volume.id[1]
+                msg, code = await self.webclient.grab_json_response_with_status(
+                    f'/redfish/v1/Systems/1/Storage/{cid}/Volumes/{vid}',
+                    method='DELETE')
+                if code == 500:
+                    raise Exception(
+                        'Unexpected return to volume deletion: ' + repr(msg))
+        for disk in cfgspec.disks:
+            await self._make_available(disk, realcfg)
+
+    def _parse_array_spec(self, arrayspec):
+        controller = None
+        if arrayspec.disks:
+            for disk in list(arrayspec.disks) + list(arrayspec.hotspares):
+                if controller is None:
+                    controller = disk.id[0]
+                if controller != disk.id[0]:
+                    raise pygexc.UnsupportedFunctionality(
+                        'Cannot span arrays across controllers')
+            raidmap = self._raid_number_map(controller)
+            if not raidmap:
+                raise pygexc.InvalidParameterValue(
+                    'No RAID Type supported on this controller')
+            requestedlevel = str(arrayspec.raid)
+            if requestedlevel not in raidmap:
+                raise pygexc.InvalidParameterValue(
+                    'Requested RAID Type "{0}" not available on this '
+                    'controller. Allowed values are: {1}'.format(
+                        requestedlevel, [k for k in raidmap]))
+            rdinfo = raidmap[str(arrayspec.raid).lower()]
+            rdlvl = str(rdinfo[0])
+            defspan = 1 if rdinfo[1] == 1 else 2
+            spancount = defspan if arrayspec.spans is None else arrayspec.spans
+            drivesperspan = str(len(arrayspec.disks) // int(spancount))
+            hotspares = arrayspec.hotspares
+            drives = arrayspec.disks
+            minimal_conditions = {
+                "RAID0": (1,128,1),
+                "RAID1": (2,2,1),
+                "RAID1Triple": (3,3,1),
+                "RAID10": (4,128,2),
+                "RAID10Triple": (6,128,3),
+                "RAID5": (3,128,1),
+                "RAID50": (6,128,2),
+                "RAID6": (4,128,1),
+                "RAID60": (8, 128, 2)
+            }
+            raid_level = rdinfo[0]
+            min_pd = minimal_conditions[raid_level][0]
+            max_pd = minimal_conditions[raid_level][1]
+            disk_multiplier = minimal_conditions[raid_level][2]
+            if len(drives) < min_pd or \
+            len(drives) > max_pd or \
+            len(drives) % disk_multiplier != 0:
+                raise pygexc.InvalidParameterValue(
+                    f'Number of disks for {rdinfo} must be between {min_pd} and {max_pd} and be a multiple of {disk_multiplier}')
+            if hotspares:
+                hstr = '|'.join([str(x.id[1]) for x in hotspares]) + '|'
+            else:
+                hstr = ''
+            drvstr = '|'.join([str(x.id[1]) for x in drives]) + '|'
+            return {
+                'controller': controller,
+                'drives': drvstr,
+                'hotspares': hstr,
+                'raidlevel': rdlvl,
+                'spans': spancount,
+                'perspan': drivesperspan,
+            }
+        else:
+            # TODO(Jarrod Johnson): adding new volume to
+            #  existing array would be here
+            pass
+    
+    async def _raid_number_map(self, controller):
+        themap = {}
+        cid = controller.split(',')
+        rsp = await self.webclient.grab_json_response(
+            '/redfish/v1/Systems/1/Storage/{0}'.format(cid[0]))
+        for rt in rsp['StorageControllers'][0]['SupportedRAIDTypes']:
+            rt_lower = rt.lower()
+            mapdata = (rt, 1)
+            themap[rt]=mapdata
+            themap[rt_lower] = mapdata
+            themap[rt_lower.replace('raid','r')] = mapdata
+            themap[rt_lower.replace('raid','')] = mapdata
+        return themap
+
+    async def _create_array(self, pool):
+        params = self._parse_array_spec(pool)
+        cid = params['controller'].split(',')[0]
+        c_capabilities, code = await self.webclient.grab_json_response_with_status(
+            f'/redfish/v1/Systems/1/Storage/{cid}/Volumes/Capabilities')
+        if code == 404:
+            c_capabilities, code = await self.webclient.grab_json_response_with_status(
+            f'/redfish/v1/Systems/1/Storage/{cid}/Volumes/Oem/Lenovo/Capabilities')
+            if code == 404:
+                # If none of the endpoints exist, maybe it should be printed that
+                # no capabilities found, therefore default values will be used
+                # whatever they are
+                pass
+        volumes = pool.volumes
+        drives = [d for d in params['drives'].split("|") if d != '']
+        hotspares = [h for h in params['hotspares'].split("|") if h != '']
+        raidlevel = params['raidlevel']
+        nameappend = 1
+        currvolnames = None
+        currcfg = await self.get_storage_configuration(False)
+        for vol in volumes:
+            if vol.name is None:
+                # need to iterate while there exists a volume of that name
+                if currvolnames is None:
+                    currvolnames = set([])
+                    for pool in currcfg.arrays:
+                        for volume in pool.volumes:
+                            currvolnames.add(volume.name)
+                name = 'Volume_{0}'.format(nameappend)
+                nameappend += 1
+                while name in currvolnames:
+                    name = 'Volume_{0}'.format(nameappend)
+                    nameappend += 1
+            else:
+                name = vol.name
+
+            # Won't check against Redfish allowable values as they not trustworthy yet
+            # Some values show in Redfish, but may not be accepted by UEFI/controller or vice versa 
+            stripsize_map = {
+                '4': 4096, '4096': 4096,
+                '16': 16384, '16384': 16384,
+                '32': 32768, '32768': 32768,
+                '64': 65536, '65536': 65536,
+                '128': 131072, '131072': 131072,
+                '256': 262144, '262144': 262144,
+                '512': 524288, '524288': 524288,
+                '1024': 1048576, '1048576': 1048576
+            }
+            stripsize = stripsize_map[str(vol.stripsize).lower().replace('k','')] if vol.stripsize is not None else None
+
+            readpolicy_map = {'0': 'Off', '1': 'ReadAhead'}
+            read_policy = None
+            read_cache_possible = c_capabilities.get("ReadCachePolicy@Redfish.AllowableValues",[])
+            if read_cache_possible:
+                if vol.read_policy is not None:
+                    if str(vol.read_policy) in readpolicy_map:
+                        vol.read_policy = readpolicy_map[str(vol.read_policy)]                    
+                    if vol.read_policy in read_cache_possible:
+                        read_policy = vol.read_policy
+                    else:
+                        raise pygexc.InvalidParameterValue(
+                        f'{vol.read_policy} Read Cache Policy is not supported. Allowed values are: {read_cache_possible}')
+            
+            writepolicy_map = {'0': 'WriteThrough', '1': 'UnprotectedWriteBack',
+                               '2': 'ProtectedWriteBack', '3': 'Off'}
+            write_policy = None
+            write_cache_possible = c_capabilities.get("WriteCachePolicy@Redfish.AllowableValues",[])
+            if write_cache_possible:
+                if vol.write_policy is not None:
+                    if str(vol.write_policy) in writepolicy_map:
+                        vol.write_policy = writepolicy_map[str(vol.write_policy)]                    
+                    if vol.write_policy in write_cache_possible:
+                        write_policy = vol.write_policy
+                    else:
+                        raise pygexc.InvalidParameterValue(
+                        f'{vol.write_policy} Write Cache Policy is not supported. Allowed values are: {write_cache_possible}')
+
+            defaultinit_map = {'0': 'No', '1': 'Fast', '2': 'Full'}
+            default_init = None
+            default_init_possible = c_capabilities.get("InitializationType@Redfish.AllowableValues",[])
+            if default_init_possible:
+                if vol.default_init is not None:
+                    if str(vol.default_init) in defaultinit_map:
+                        vol.default_init = defaultinit_map[str(vol.default_init)]
+                    if vol.default_init in default_init_possible:
+                        default_init = vol.default_init
+                    else:
+                        raise pygexc.InvalidParameterValue(
+                        f'{vol.default_init} Initialization Type is not supported. Allowed values are: {default_init_possible}')
+
+            volsize = None
+            spec_disks = sorted(drives)
+            spec_hotspares = hotspares
+            for array in currcfg.arrays:
+                in_use_disks = sorted([d.id[1] for d in array.disks])
+                in_use_hotspares = [h.id[1] for h in array.hotspares]
+                if spec_disks == in_use_disks:
+                    if vol.size is None:
+                        volsize = array.available_capacity
+                        array.available_capacity = 0
+                        break
+                    else:
+                        strsize = str(vol.size)
+                        if strsize in ('all','100%'):
+                            raise pygexc.InvalidParameterValue(
+                                f'Requested size for volume {name} exceeds available capacity. Available capacity is {array.available_capacity} MiB')
+                        elif strsize.endswith('%'):
+                            volsize = int(array.capacity
+                                        * float(strsize.replace('%', ''))
+                                        / 100.0)
+                            if volsize > array.available_capacity:
+                                raise pygexc.InvalidParameterValue(
+                                f'Requested size for volume {name} exceeds available capacity. Available capacity is {array.available_capacity} MiB')
+                            else:
+                                array.available_capacity-=volsize
+                        else:
+                            try:
+                                volsize = int(strsize)
+                                if volsize > array.available_capacity:
+                                    raise pygexc.InvalidParameterValue(
+                                        f'Requested size for volume {name} exceeds available capacity. Available capacity is {array.available_capacity} MiB')
+                                else:
+                                    array.available_capacity-=volsize
+                            except ValueError:
+                                raise pygexc.InvalidParameterValue(
+                                    'Unrecognized size ' + strsize)
+                elif any(d in in_use_disks for d in spec_disks):
+                    raise pygexc.InvalidParameterValue(
+                        f'At least one disk from provided config is in use by another volume. To create a volume using the remaining capacity, configure the new volume to use all the following disks: {in_use_disks}')
+                else:
+                    disks_capacities = {}
+                    for d in spec_disks:
+                        disks_capacities[d] = (await self.webclient.grab_json_response(
+                            f'/redfish/v1/Systems/1/Storage/{cid}/Drives/{d}'))["CapacityBytes"]
+                    max_capacity = sum(v for k,v in disks_capacities.items())
+                    min_disk = min([v for k,v in disks_capacities.items()])
+                    disk_count = len(disks_capacities)
+                    max_capacity_per_raid = {
+                        "RAID0": max_capacity,
+                        "RAID1": min_disk,
+                        "RAID1Triple": min_disk,
+                        "RAID10": (disk_count//2)*min_disk,
+                        "RAID10Triple": (disk_count//3)*min_disk,
+                        "RAID5": (disk_count-1)*min_disk,
+                        "RAID50": (disk_count-2)*min_disk,
+                        "RAID6": (disk_count-2)*min_disk,
+                        "RAID60": (disk_count-4)*min_disk
+                        }
+                    if vol.size is not None:
+                        strsize = str(vol.size)
+                        if strsize.endswith('%'):
+                            volsize = int(max_capacity_per_raid[raidlevel]
+                                        * float(strsize.replace('%', ''))
+                                        / 100.0)
+                        else:
+                            try:
+                                volsize = int(strsize)
+                                if volsize > max_capacity_per_raid[raidlevel]:
+                                    raise pygexc.InvalidParameterValue(
+                                        f'Requested size for volume {name} exceeds available capacity. Available capacity is {max_capacity_per_raid[raidlevel]} bytes')
+                            except ValueError:
+                                raise pygexc.InvalidParameterValue(
+                                    'Unrecognized size ' + strsize)
+                for h in spec_hotspares:
+                    if h in in_use_hotspares:
+                        raise pygexc.InvalidParameterValue(
+                            f'Hotspare {h} from provided config is in use by another volume.')
+            
+            request_data = {
+                "Name":name,
+                "RAIDType":raidlevel,
+                "Links":{
+                    "Drives":[
+                        {'@odata.id': f'/redfish/v1/Systems/1/Storage/{cid}/Drives/{did}'} for did in spec_disks]}}
+            if spec_hotspares:
+                request_data["Links"]["DedicatedSpareDrives"] = {[
+                    {'@odata.id': f'/redfish/v1/Systems/1/Storage/{cid}/Drives/{hid}' for hid in spec_hotspares}]}
+            if volsize:
+                request_data["CapacityBytes"] = volsize
+            if stripsize:
+                request_data["StripSizeBytes"] = stripsize
+            if read_policy:
+                request_data["ReadCachePolicy"] = read_policy
+            if write_policy:
+                request_data["WriteCachePolicy"] = write_policy
+            
+            msg, code=self.webclient.grab_json_response_with_status(
+                f'/redfish/v1/Systems/1/Storage/{cid}/Volumes',
+                method='POST',
+                data=request_data)
+            if code == 500:
+                raise Exception("Unexpected response to volume creation: " + repr(msg))
+            await asyncio.sleep(60)
+            #Even if in web the volume appears immediately, get_storage_configuration does not see it that fast
+            newcfg = await self.get_storage_configuration(False)
+            newvols = [v.id for p in newcfg.arrays for v in p.volumes]
+            currvols = [v.id for p in currcfg.arrays for v in p.volumes]
+            newvol = list(set(newvols) - set(currvols))[0]
+            if default_init:
+                msg, code = await self.webclient.grab_json_response_with_status(
+                    f'/redfish/v1/Systems/1/Storage/{cid}/Volumes/{newvol[1]}/Actions/Volume.Initialize',
+                    method='POST',
+                    data = {"InitializeType": default_init})
+                if code == 500:
+                    raise Exception("Unexpected response to volume initialization: " + repr(msg))
+
+    async def attach_remote_media(self, url, user, password, vmurls):
+        for vmurl in vmurls:
+            if 'EXT' not in vmurl:
+                continue
+            vminfo = await self._do_web_request(vmurl, cache=False)
+            if vminfo['ConnectedVia'] != 'NotConnected':
+                continue
+            msg,code = await self.webclient.grab_json_response_with_status(
+                vmurl,
+                data={'Image': url, 'Inserted': True},
+                method='PATCH')
+            if code == 500:
+                errmsg = "Unexpected response when attaching remote media: " + repr(msg)
+                try:
+                    if url.startswith('https://'):
+                        dmsg = json.loads(msg.decode('utf-8'))
+                        if dmsg.get('error', {}).get('code', '') == 'Base.1.16.0.InternalError':
+                            errmsg = 'XCC3 reported an internal error while attaching https media, check the certificate authorities on the XCC3'
+                except Exception:
+                    pass
+                raise Exception(errmsg)
+            self._invalidate_url_cache(vmurl)                
+            raise pygexc.BypassGenericBehavior()
+            break
+        else:
+            raise pygexc.InvalidParameterValue(
+                'XCC does not have required license for operation')
+
+    async def supports_expand(self, url):
+        return True
+
+    async def get_screenshot(self, outfile):
+        wc = self.webclient.dupe()
+        await self._get_session_token(wc)
+        url = '/web_download/Mini_ScreenShot.jpg'
+        fd = webclient.make_downloader(wc, url, outfile)
+        await fd.join()
+
+    async def get_diagnostic_data(self, savefile, progress=None, autosuffix=False):
+        try:
+            tsk = await self._do_web_request(
+                '/redfish/v1/Systems/1/LogServices/DiagnosticLog/Actions/LogService.CollectDiagnosticData',
+                {"DiagnosticDataType": "Manager", "SelectDataTypes": ["adapter","worknote","thermal"]})
+        except pygexc.RedfishError:
+            tsk = await self._do_web_request(
+                '/redfish/v1/Systems/1/LogServices/DiagnosticLog/Actions/LogService.CollectDiagnosticData',
+                {"DiagnosticDataType": "Manager", "SelectDataTypes": ["adapter"]})
+
+        taskrunning = True
+        taskurl = tsk.get('TaskMonitor', None)
+        pct = 0 if taskurl else 100
+        durl = None
+        while pct < 100 and taskrunning:
+            status = await self._do_web_request(taskurl)
+            durl = status.get('AdditionalDataURI', '')
+            pct = status.get('PercentComplete', 0)
+            taskrunning = status.get('TaskState', 'Complete') == 'Running'
+            if progress:
+                progress({'phase': 'initializing', 'progress': float(pct)})
+            if taskrunning:
+                await asyncio.sleep(3)
+        if not durl:
+            raise Exception("Failed getting service data url")
+        fname = os.path.basename(durl)
+        if autosuffix and not savefile.endswith('.tar.zst'):
+            savefile += '-{0}'.format(fname)
+        fd = webclient.make_downloader(self.webclient, durl, savefile)
+        while not fd.completed():
+            try:
+                await fd.join(1)
+            except asyncio.TimeoutError:
+                pass
+            if progress and await fd.get_progress():
+                progress({'phase': 'download',
+                          'progress': 100 * await fd.get_progress()})
+        if fd.exc:
+            raise fd.exc
+        if progress:
+            progress({'phase': 'complete'})
+        return savefile
+
+    async def get_ikvm_methods(self):
+        return ['openbmc', 'url']
+
+    async def get_ikvm_launchdata(self):
+        access = await self._do_web_request('/redfish/v1/Managers/1/Oem/Lenovo/RemoteControl/Actions/LenovoRemoteControlService.GetRemoteConsoleToken', {})
+        if access.get('Token', None):
+            accessinfo = {
+                'url': '/#/login?{}&context=remote&mode=multi'.format(access['Token'])
+                }
+            return accessinfo
+
+    async def get_system_power_watts(self, fishclient):
+        powerinfo = await fishclient._do_web_request('/redfish/v1/Chassis/1/Sensors/power_Sys_Power')
+        return powerinfo['Reading']
+    
+    async def get_health(self, fishclient, verbose=True):
+        rsp = await self._do_web_request('/api/providers/imm_active_events')
+        summary = {'badreadings': [], 'health': pygconst.Health.Ok}
+        fallbackdata = []
+        hmap = {
+            0 : pygconst.Health.Ok,
+            3: pygconst.Health.Critical,
+            2: pygconst.Health.Warning,
+        }
+        infoevents = False
+        existingevts = set([])
+        for item in rsp.get('items', ()):
+            # while usually the ipmi interrogation shall explain things,
+            # just in case there is a gap, make sure at least the
+            # health field is accurately updated
+            itemseverity = hmap.get(item.get('Severity', 2),
+                                    pygconst.Health.Critical)
+            if itemseverity == pygconst.Health.Ok:
+                infoevents = True
+                continue
+            if (summary['health'] < itemseverity):
+                summary['health'] = itemseverity
+            evtsrc = item.get('Oem', {}).get('Lenovo', {}).get('Source', '')
+            currevt = '{}:{}'.format(evtsrc, item['Message'])
+            if currevt in existingevts:
+                continue
+            existingevts.add(currevt)
+            fallbackdata.append(SensorReading({
+                'name': evtsrc,
+                'states': [item['Message']],
+                'health': itemseverity,
+                'type': evtsrc,
+            }, ''))
+        summary['badreadings'] = fallbackdata
+        return summary   
+
+    async def _get_cpu_temps(self, fishclient):
+        cputemps = []
+        for reading in await super()._get_cpu_temps(fishclient):
+            if 'Margin' in reading['Name']:
+                continue
+            cputemps.append(reading)
+        return cputemps
+
+    async def get_system_configuration(self, hideadvanced=True, fishclient=None):
+        stgs = (await self._getsyscfg(fishclient))[0]
+        outstgs = {}
+        for stg in stgs:
+            outstgs[f'UEFI.{stg}'] = stgs[stg]
+        return outstgs
+
+    async def set_system_configuration(self, changeset, fishclient):
+        bmchangeset = {}
+        vpdchangeset = {}
+        for stg in list(changeset):
+            if stg.startswith('BMC.'):
+                bmchangeset[stg.replace('BMC.', '')] = changeset[stg]
+                del changeset[stg]
+            if stg.startswith('UEFI.'):
+                changeset[stg.replace('UEFI.', '')] = changeset[stg]
+                del changeset[stg]
+            if stg.startswith('VPD.'):
+                vpdchangeset[stg.replace('VPD.', '')] = changeset[stg]
+                del changeset[stg]
+        if changeset:
+            await super().set_system_configuration(changeset, fishclient)
+        if bmchangeset:
+            await self._set_xcc3_settings(bmchangeset, fishclient)
+        if vpdchangeset:
+            await self._set_xcc3_vpd(vpdchangeset, fishclient)
+
+    async def _set_xcc3_vpd(self, changeset, fishclient):
+        newvpd = {'Attributes': changeset}
+        await fishclient._do_web_request(
+            '/redfish/v1/Chassis/1/Oem/Lenovo/SysvpdSettings/Actions/LenovoSysVpdSettings.SetVpdSettings',
+            newvpd)
+
+
+    async def _set_xcc3_settings(self, changeset, fishclient):
+        currsettings, reginfo = await self._get_lnv_bmcstgs(fishclient)
+        rawsettings = await fishclient._do_web_request('/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings',
+                                                 cache=False)
+        rawsettings = rawsettings.get('Attributes', {})
+        pendingsettings = {}
+        ret = self._set_redfish_settings(
+            changeset, fishclient, currsettings, rawsettings,
+            pendingsettings, self.lenovobmcattrdeps, reginfo,
+            '/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings')
+        await fishclient._do_web_request('/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings', cache=False)
+        return ret
+
+    oemacctmap = {
+        'password_reuse_count': 'MinimumPasswordReuseCycle',
+        'password_change_interval':  'MinimumPasswordChangeIntervalHours',
+        'password_expiration': 'PasswordExpirationPeriodDays',
+        'password_complexity': 'ComplexPassword',
+        }
+
+    acctmap = {
+        'password_login_failures': 'AccountLockoutThreshold',
+        'password_min_length': 'MinPasswordLength',
+        'password_lockout_period': 'AccountLockoutDuration',
+        }
+
+    async def update_firmware(self, filename, data=None, progress=None, bank=None, otherfields=()):
+        if not otherfields and bank == 'backup':
+            uxzcount = 0
+            otherfields = {'UpdateParameters': {"Targets": ["/redfish/v1/UpdateService/FirmwareInventory/BMC-Backup"]}}
+            needseek = False
+            if data and hasattr(data, 'read'):
+                if zipfile.is_zipfile(data):
+                    needseek = True
+                    z = zipfile.ZipFile(data)
+                else:
+                    data.seek(0)
+            elif data is None and zipfile.is_zipfile(filename):
+                z = zipfile.ZipFile(filename)
+            if z:
+                for tmpname in z.namelist():
+                    if tmpname.startswith('payloads/'):
+                        uxzcount += 1
+                        if tmpname.endswith('.uxz'):
+                            wrappedfilename = tmpname
+            if uxzcount == 1 and wrappedfilename:
+                filename = os.path.basename(wrappedfilename)
+                data = z.open(wrappedfilename)
+            elif needseek:
+                data.seek(0)
+        await super().update_firmware(filename, data=data, progress=progress, bank=bank, otherfields=otherfields)
+
+
+    async def get_bmc_configuration(self):
+        settings = {}
+        acctsrv = await self._do_web_request('/redfish/v1/AccountService')
+        for oemstg in self.oemacctmap:
+            settings[oemstg] = {
+                'value': acctsrv['Oem']['Lenovo'][self.oemacctmap[oemstg]]}
+        for stg in self.acctmap:
+            settings[stg] = {
+                'value': acctsrv[self.acctmap[stg]]}
+        bmcstgs = await self._do_web_request('/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings')
+        bmcattrs = bmcstgs['Attributes']
+        self.ethoverusb = True if 'EthOverUSBEnabled' in bmcattrs else False
+        usbcfg = bmcattrs.get('NetMgrUsb0Enabled', bmcattrs.get('EthOverUSBEnabled', 'False'))
+        usbeth = 'Enable' if usbcfg == 'True' else 'Disable'
+        settings['usb_ethernet'] = {
+            'value': usbeth
+        }
+        usbcfg = bmcattrs.get('NetMgrUsb0PortForwardingEnabled', bmcattrs.get('EthOverUSBPortForwardingEnabled', 'False'))
+        fwd = 'Enable' if usbcfg == 'True' else 'Disable'
+        settings['usb_ethernet_port_forwarding'] = fwd
+        mappings = []
+        for idx in range(1, 11):
+            keyname = 'NetMgrUsb0PortForwardingPortMapping.{}'.format(idx)
+            keyaltname = 'EthOverUSBPortForwardingPortMapping_{}'.format(idx)
+            currval = bmcattrs.get(keyname, bmcattrs.get(keyaltname, '0,0'))
+            if currval == '0,0':
+                continue
+            src, dst = currval.split(',')
+            mappings.append('{}:{}'.format(src,dst))
+        settings['usb_forwarded_ports'] = {'value': ','.join(mappings)}
+        cfgin = (await self._get_lnv_bmcstgs(self))[0]
+        for stgname in cfgin:
+            settings[f'{stgname}'] = cfgin[stgname]        
+        return settings
+
+    async def set_bmc_configuration(self, changeset):
+        acctattribs = {}
+        usbsettings = {}
+        bmchangeset = {}
+        rawchangeset = {}
+        for key in changeset:
+            rawchangeset[key] = changeset[key]
+            if isinstance(changeset[key], str):
+                changeset[key] = {'value': changeset[key]}
+            currval = changeset[key].get('value', None)
+            if key == 'password_complexity':
+                if currval.lower() in ("false", 0):
+                    currval = False
+                elif currval.lower() in ('true', 1):
+                    currval = True
+            elif key.lower().startswith('usb_'):
+                if 'forwarded_ports' not in key.lower():
+                    currval = currval.lower()
+                    if currval and 'disabled'.startswith(currval):
+                        currval = 'False'
+                    elif currval and 'enabled'.startswith(currval):
+                        currval = 'True'
+            else:
+                try:
+                    currval = int(currval)
+                except ValueError:
+                    pass
+            if key.lower() in self.oemacctmap:
+                if 'Oem' not in acctattribs:
+                    acctattribs['Oem'] = {'Lenovo': {}}
+                acctattribs['Oem']['Lenovo'][
+                    self.oemacctmap[key.lower()]] = currval
+                if key.lower() == 'password_expiration':
+                    warntime = int(int(currval) * 0.08)
+                    acctattribs['Oem']['Lenovo'][
+                        'PasswordExpirationWarningPeriod'] = warntime
+            elif key.lower() in self.acctmap:
+                acctattribs[self.acctmap[key.lower()]] = currval
+            elif key.lower() in (
+                    'usb_ethernet', 'usb_ethernet_port_forwarding',
+                    'usb_forwarded_ports'):
+                usbsettings[key] = currval
+            else:
+                bmchangeset[key.replace('bmc.', '')] = rawchangeset[key]
+        if acctattribs:
+            await self._do_web_request(
+                '/redfish/v1/AccountService', acctattribs, method='PATCH')
+            await self._do_web_request('/redfish/v1/AccountService', cache=False)
+        if usbsettings:
+            await self.apply_usb_configuration(usbsettings)
+        if bmchangeset:
+            self._set_xcc3_settings(bmchangeset, self)        
+
+    async def apply_usb_configuration(self, usbsettings):
+        bmcattribs = {}
+        if not hasattr(self, 'ethoverusb'):
+            await self.get_bmc_configuration()
+        if 'usb_forwarded_ports' in usbsettings:
+            pairs = usbsettings['usb_forwarded_ports'].split(',')
+            idx = 1
+            for pair in pairs:
+                if self.ethoverusb:
+                    keyname = 'EthOverUSBPortForwardingPortMapping_{}'.format(idx)
+                else:
+                    keyname = 'NetMgrUsb0PortForwardingPortMapping.{}'.format(idx)
+                pair = pair.replace(':', ',')
+                if self.ethoverusb:
+                    keyname = 'EthOverUSBPortForwardingPortMapping_{}'.format(idx)
+                else:
+                    keyname = 'NetMgrUsb0PortForwardingPortMapping.{}'.format(idx)
+                bmcattribs[keyname] = '0,0'
+                idx += 1
+            while idx < 11:
+                bmcattribs[
+                    'NetMgrUsb0PortForwardingPortMapping.{}'.format(
+                        idx)] = '0,0'
+                idx += 1
+        if 'usb_ethernet' in usbsettings:
+            keyname = 'EthOverUSBEnabled' if self.ethoverusb else 'NetMgrUsb0Enabled'
+            bmcattribs[keyname] = usbsettings['usb_ethernet']
+        if 'usb_ethernet_port_forwarding' in usbsettings:
+            keyname = 'EthOverUSBPortForwardingEnabled' if self.ethoverusb else 'NetMgrUsb0PortForwardingEnabled'
+            bmcattribs[keyname] = usbsettings[
+                    'usb_ethernet_port_forwarding']
+        await self._do_web_request(
+            '/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings',
+            {'Attributes': bmcattribs}, method='PATCH')
+        await self._do_web_request(
+            '/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings', cache=False)
+
+    async def get_extended_bmc_configuration(self, fishclient, hideadvanced=True):
+        cfgin = (await self._get_lnv_bmcstgs(fishclient))[0]
+        cfgout = {}
+        for stgname in cfgin:
+            cfgout[f'BMC.{stgname}'] = cfgin[stgname]
+        vpdin = (await self._get_lnv_vpd(fishclient))[0]
+        for stgname in vpdin:
+            cfgout[f'VPD.{stgname}'] = vpdin[stgname]
+        return cfgout
+
+    async def _get_lnv_vpd(self, fishclient):
+        currsettings, reginfo = await self._get_lnv_stgs(
+            fishclient, '/redfish/v1/Chassis/1/Oem/Lenovo/SysvpdSettings')
+        self.lenovobmcattrdeps = reginfo[3]
+        return currsettings, reginfo
+
+    async def _get_lnv_bmcstgs(self, fishclient):
+        currsettings, reginfo = await self._get_lnv_stgs(
+            fishclient, '/redfish/v1/Managers/1/Oem/Lenovo/BMCSettings')
+        self.lenovobmcattrdeps = reginfo[3]
+        return currsettings, reginfo
+
+    async def _get_lnv_stgs(self, fishclient, url):
+        bmcstgs = await fishclient._do_web_request(url)
+        bmcreg = bmcstgs.get('AttributeRegistry', None)
+        extrainfo = {}
+        valtodisplay = {}
+        currsettings = {}
+        reginfo = {}, {}, {}, {}
+        if bmcreg:
+            reginfo = await self._get_attrib_registry(fishclient, bmcreg)
+            if reginfo:
+                extrainfo, valtodisplay, _, _ = reginfo
+        for setting in bmcstgs.get('Attributes', {}):
+            val = bmcstgs['Attributes'][setting]
+            currval = val
+            val = valtodisplay.get(setting, {}).get(val, val)
+            val = {'value': val}
+            val.update(**extrainfo.get(setting, {}))
+            currsettings[setting] = val
+        return currsettings, reginfo
+
+    async def get_description(self, fishclient):
+        rsp = await self._get_expanded_data('/redfish/v1/Chassis')
+        for chassis in rsp['Members']:
+            if (chassis['@odata.id'] == '/redfish/v1/Chassis/1'
+                    and chassis['ChassisType'] != 'Blade'):
+                hmm = chassis.get('HeightMm', None)
+                if hmm:
+                    return {'height': hmm/44.45}
+            if (chassis['@odata.id'] == '/redfish/v1/Chassis/Enclosure'
+                    and chassis.get('ChassisType', None) == 'Enclosure'):
+                try:
+                    slot = chassis['Location']['PartLocation']['LocationOrdinalValue']
+                    slotnum = (2 * (slot >> 4) - 1) + ((slot & 15) % 10)
+                    slotcoord = [slot >> 4, (slot & 15) - 9]
+                    return {'slot': slotnum, 'slotlabel': '{:02x}'.format(slot), 'slotcoord': slotcoord}
+                except KeyError:
+                    continue
+        return {}
+
+    async def upload_media(self, filename, progress=None, data=None):
+        wc = self.webclient
+        uploadthread = await webclient.make_uploader(
+            wc, '/rdoc_upload', filename, data,
+            formname='file',
+            formwrap=True)
+        while not uploadthread.completed():
+            try:
+                await uploadthread.join(3)
+            except asyncio.TimeoutError:
+                pass
+            if progress:
+                progress({'phase': 'upload',
+                          'progress': 100 * await uploadthread.get_progress()})
+        rspstatus, rsp, headers = uploadthread.get_response()
+        if rsp['return'] != 0:
+            raise Exception('Issue uploading file')
+        remfilename = rsp['upload_filename']
+        if progress:
+            progress({'phase': 'upload',
+                      'progress': 100.0})
+        await self._do_web_request(
+            '/redfish/v1/Systems/1/VirtualMedia/RDOC1',
+            {'Image':'file:///gpx/rdocupload/' + remfilename,
+             'WriteProtected': False}, method='PATCH')
+        if progress:
+            progress({'phase': 'complete'})
+
+    async def get_firmware_inventory(self, components, fishclient, category):
+        sfs = await fishclient._do_web_request('/api/providers/system_firmware_status')
+        pendingscm = sfs.get('fpga_scm_pending_build', None)
+        pendinghpm = sfs.get('fpga_hpm_pending_build', None)
+        if pendingscm == '*':
+            pendingscm = None
+        if pendinghpm == '*':
+            pendinghpm = None    
+        oldtimeout = fishclient.wc.get_timeout()
+        fishclient.wc.set_timeout(120)
+        fwinv = await fishclient.get_fwinventory()
+        fwlist = await fishclient._do_web_request(fwinv + '?$expand=.')
+        fishclient.wc.set_timeout(oldtimeout)
+        fwlist = copy.deepcopy(fwlist.get('Members', []))
+        self._fwnamemap = {}
+        for redres in fwlist:
+            fwurl = redres['@odata.id']
+            res = (redres, fwurl)
+            if fwurl.startswith('/redfish/v1/UpdateService/FirmwareInventory/Bundle.'):
+                continue  # skip Bundle information for now
+            if redres.get('Name', '').startswith('Firmware:'):
+                redres['Name'] = redres['Name'].replace('Firmware:', '')
+            if redres['Name'].startswith('Firmware-PSoC') and 'Drive_Backplane' in redres["@odata.id"]:
+                redres['Name'] = 'Drive Backplane'
+            if redres['Name'].startswith('DEVICE-'):
+                redres['Name'] = redres['Name'].replace('DEVICE-', '')
+            if redres['Name'].startswith('POWER-PSU'):
+                redres['Name'] = redres['Name'].replace('POWER-', '')
+            swid = redres.get('SoftwareId', '')
+            buildid = ''
+            version = redres.get('Version', None)
+            for prefix in ['FPGA-', 'UEFI-', 'BMC-', 'LXPM-', 'DRVWN-', 'DRVLN-', 'LXUM']:
+                if swid.startswith(prefix):
+                    buildid = swid.split('-')[1] + version.split('-')[0]
+                    version = '-'.join(version.split('-')[1:])
+                    break
+            if version:
+                redres['Version'] = version
+            cres = fishclient._extract_fwinfo(res)
+            if cres[0] is None:
+                continue
+            if buildid:
+                cres[1]['build'] = buildid
+            yield cres
+            if cres[0] == 'SCM-FPGA' and pendingscm:
+                yield 'SCM-FPGA Pending', {
+                    'Name': 'SCM-FPGA Pending',
+                    'build': pendingscm}
+            elif cres[0] == 'HPM-FPGA' and pendinghpm:
+                yield 'HPM-FPGA Pending', {
+                    'Name': 'HPM-FPGA Pending',
+                    'build': pendinghpm}
+        raise pygexc.BypassGenericBehavior()
+
+
diff --git a/confluent_server/aiohmi/redfish/oem/lookup.py b/confluent_server/aiohmi/redfish/oem/lookup.py
new file mode 100644
index 00000000..07bd4767
--- /dev/null
+++ b/confluent_server/aiohmi/redfish/oem/lookup.py
@@ -0,0 +1,47 @@
+# Copyright 2019 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import aiohmi.redfish.oem.dell.main as dell
+import aiohmi.redfish.oem.generic as generic
+import aiohmi.redfish.oem.lenovo.main as lenovo
+import aiohmi.redfish.oem.ami.main as ami
+
+OEMMAP = {
+    'Lenovo': lenovo,
+    'Dell': dell,
+    'AMI': ami,
+    'Ami': ami,
+}
+
+
+def get_oem_handler(sysinfo, sysurl, webclient, cache, cmd, rootinfo={}):
+    if rootinfo.get('Vendor', None) in OEMMAP:
+        return OEMMAP[rootinfo['Vendor']].get_handler(sysinfo, sysurl,
+                                                     webclient, cache, cmd, rootinfo)
+    for oem in sysinfo.get('Oem', {}):
+        if oem in OEMMAP:
+            return OEMMAP[oem].get_handler(sysinfo, sysurl, webclient, cache,
+                                           cmd, rootinfo)
+    for oem in sysinfo.get('Links', {}).get('OEM', []):
+        if oem in OEMMAP:
+            return OEMMAP[oem].get_handler(sysinfo, sysurl, webclient, cache,
+                                           cmd, rootinfo)
+    if rootinfo:  # rootinfo indicates early invocation, bmcinfo not ready yet
+        return generic.OEMHandler(sysinfo, sysurl, webclient, cache, cmd._gpool, rootinfo)    
+    bmcinfo = cmd.bmcinfo
+    for oem in bmcinfo.get('Oem', {}):
+        if oem in OEMMAP:
+            return OEMMAP[oem].get_handler(sysinfo, sysurl, webclient, cache,
+                                           cmd, rootinfo)
+    return generic.OEMHandler(sysinfo, sysurl, webclient, cache, cmd._gpool, rootinfo)
diff --git a/confluent_server/aiohmi/storage.py b/confluent_server/aiohmi/storage.py
new file mode 100644
index 00000000..54aa893e
--- /dev/null
+++ b/confluent_server/aiohmi/storage.py
@@ -0,0 +1,113 @@
+# Copyright 2017 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Disk(object):
+    def __init__(self, name, description=None, id=None, status=None,
+                 serial=None, fru=None, stripsize=None):
+        """Define a disk object
+
+        :param name: A name describing the disk in human readable terms
+        :param description: A description of the device
+        :param id: Identifier used by the controller
+        :param status: Controller indicated status of disk
+        :param serial: Serial number of the drive
+        :param fru: FRU number of the driver
+        :param stripsize: The stripsize of the disk in kibibytes
+        """
+        self.name = str(name)
+        self.description = description
+        self.id = id
+        self.status = status
+        self.serial = serial
+        self.fru = fru
+        self.stripsize = stripsize
+
+
+class Array(object):
+    def __init__(self, disks=None, raid=None, status=None, volumes=(), id=None,
+                 spans=None, hotspares=(), capacity=None,
+                 available_capacity=None):
+        """Define an array of disks object
+
+        :param disks: An array of Disk objects
+        :param raid: the RAID level
+        :param status: Status of the array according to the controller
+        :param id: Unique identifier used by controller to identify
+        :param spans: Number of spans for a multi-dimensional array
+        :param hotspares: List of Disk objects that are dedicated hot spares
+            for this array.
+        :param capacity: the total capacity of the array
+        :param available_capacity: the remaining capacity of the array
+        """
+        self.disks = disks
+        self.raid = raid
+        self.status = status
+        self.id = id
+        self.volumes = volumes
+        self.spans = spans
+        self.hotspares = hotspares
+        self.capacity = capacity
+        self.available_capacity = available_capacity
+
+
+class Volume(object):
+    def __init__(self, name=None, size=None, status=None, id=None,
+                 stripsize=None, read_policy=None, write_policy=None,
+                 default_init=None):
+        """Define a Volume as an object
+
+        :param name: Name of the volume
+        :param size: Size of the volume in MB
+        :param status: Controller indicated status of the volume
+        :param id: Controller identifier of a given volume
+        :param stripsize: The stripsize of the volume in kibibytes
+        :param read_policy: The read policy of the volume
+        :param write_policy: The write policy of the volume
+        :param default_init: The default initialization of the volume
+        """
+        self.name = name
+        if isinstance(size, int):
+            self.size = size
+        else:
+            strsize = str(size).lower()
+            if strsize.endswith('mb'):
+                self.size = int(strsize.replace('mb', ''))
+            elif strsize.endswith('gb'):
+                self.size = int(strsize.replace('gb', '')) * 1000
+            elif strsize.endswith('tb'):
+                self.size = int(strsize.replace('tb', '')) * 1000 * 1000
+            else:
+                self.size = size
+        self.status = status
+        self.id = id
+        self.stripsize = stripsize
+        self.read_policy = read_policy
+        self.write_policy = write_policy
+        self.default_init = default_init
+
+
+class ConfigSpec(object):
+    def __init__(self, disks=(), arrays=()):
+        """A configuration specification of storage
+
+        When returned from a remote system, it describes the current config.
+        When given to a remote system, it should only describe the delta
+        between current config.
+
+        :param disks:  A list of Disk in the configuration not in an array
+        :param arrays: A list of Array objects
+        """
+        self.disks = disks
+        self.arrays = arrays
diff --git a/confluent_server/aiohmi/tests/__init__.py b/confluent_server/aiohmi/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/tests/unit/__init__.py b/confluent_server/aiohmi/tests/unit/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/tests/unit/base.py b/confluent_server/aiohmi/tests/unit/base.py
new file mode 100644
index 00000000..5e577e41
--- /dev/null
+++ b/confluent_server/aiohmi/tests/unit/base.py
@@ -0,0 +1,21 @@
+# Copyright 2017 Red Hat, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from oslotest import base
+
+
+class TestCase(base.BaseTestCase):
+
+    """Test case base class for all unit tests."""
diff --git a/confluent_server/aiohmi/tests/unit/ipmi/__init__.py b/confluent_server/aiohmi/tests/unit/ipmi/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/confluent_server/aiohmi/tests/unit/ipmi/test_sdr.py b/confluent_server/aiohmi/tests/unit/ipmi/test_sdr.py
new file mode 100644
index 00000000..2998253b
--- /dev/null
+++ b/confluent_server/aiohmi/tests/unit/ipmi/test_sdr.py
@@ -0,0 +1,23 @@
+# Copyright 2017 Red Hat, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from aiohmi.ipmi import sdr
+from aiohmi.tests.unit import base
+
+
+class SDRTestCase(base.TestCase):
+
+    def test_ones_complement(self):
+        self.assertEqual(sdr.ones_complement(127, 8), 127)
diff --git a/confluent_server/aiohmi/util/__init__.py b/confluent_server/aiohmi/util/__init__.py
new file mode 100644
index 00000000..0dead496
--- /dev/null
+++ b/confluent_server/aiohmi/util/__init__.py
@@ -0,0 +1 @@
+__author__ = 'jjohnson2'
diff --git a/confluent_server/aiohmi/util/parse.py b/confluent_server/aiohmi/util/parse.py
new file mode 100644
index 00000000..b7fd0783
--- /dev/null
+++ b/confluent_server/aiohmi/util/parse.py
@@ -0,0 +1,66 @@
+# Copyright 2019 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime
+from datetime import timedelta
+
+from dateutil import tz
+
+
+def parse_time(timeval):
+    if timeval is None:
+        return None
+    try:
+        if '+' not in timeval and len(timeval.split('-')) <= 3:
+            retval = datetime.strptime(timeval, '%Y-%m-%dT%H:%M:%SZ')
+            return retval.replace(tzinfo=tz.tzutc())
+    except ValueError:
+        pass
+    try:
+        positive = None
+        offset = None
+        if '+' in timeval:
+            timeval, offset = timeval.split('+', 1)
+            positive = 1
+        elif len(timeval.split('-')) > 3:
+            timeval, offset = timeval.rsplit('-', 1)
+            positive = -1
+        if positive:
+            hrs, mins = offset.split(':', 1)
+            secs = int(hrs) * 60 + int(mins)
+            secs = secs * 60 * positive
+            ms = None
+            if '.' in timeval:
+                timeval, ms = timeval.split('.', 1)
+                ms = int(ms)
+                ms = timedelta(0, 0, 0, ms)
+            retval = datetime.strptime(timeval, '%Y-%m-%dT%H:%M:%S')
+            if ms:
+                retval += ms
+            return retval.replace(tzinfo=tz.tzoffset('', secs))
+    except ValueError:
+        pass
+    try:
+        return datetime.strptime(timeval, '%Y-%m-%dT%H:%M:%S')
+    except ValueError:
+        pass
+    try:
+        return datetime.strptime(timeval, '%Y-%m-%d')
+    except ValueError:
+        pass
+    try:
+        return datetime.strptime(timeval, '%m/%d/%Y')
+    except ValueError:
+        pass
+    return None
diff --git a/confluent_server/aiohmi/util/webclient.py b/confluent_server/aiohmi/util/webclient.py
new file mode 100644
index 00000000..9e89e169
--- /dev/null
+++ b/confluent_server/aiohmi/util/webclient.py
@@ -0,0 +1,441 @@
+# Copyright 2015-2019 Lenovo
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This provides ability to do HTTPS in a manner like ssh host keys for the
+# sake of typical internal management devices.  Compatibility back to python
+# 2.6 as is found in commonly used enterprise linux distributions.
+
+import asyncio
+import base64
+import copy
+import gzip
+import io
+import json
+import os
+import socket
+import ssl
+import threading
+import traceback
+
+from yarl import URL
+import aiohmi.exceptions as pygexc
+
+
+import aiohttp
+from aiohttp.cookiejar import CookieJar
+
+import http.client as httplib
+import http.cookies as Cookie
+
+# Used as the separator for form data
+
+# We will frequently be dealing with the same data across many instances,
+# consolidate forms to single memory location to get benefits..
+uploadforms = {}
+
+class CustomVerifier(aiohttp.Fingerprint):
+    def __init__(self, verifycallback):
+        self._certverify = verifycallback
+
+    def check(self, transport):
+        sslobj = transport.get_extra_info("ssl_object")
+        cert = sslobj.getpeercert(binary_form=True)
+        try:
+            if not self._certverify(cert):
+                raise pygexc.UnrecognizedCertificate('Unknown certificate',
+                                                     cert)
+        except Exception:
+            transport.close()
+            raise
+
+class Downloader:
+    @classmethod
+    def create(cls, filehandle):
+        self = cls()
+        self.contentlen = None
+        self._completed = False
+        self._filehandle = filehandle
+        self._xfertask = None
+        self.exc = None
+        return self
+
+    async def get_progress(self):
+        if self.contentlen is None:
+            return -0.5
+        offset = None
+        retries = 100
+        while offset is None:
+            if self._completed:
+                return 1.0
+            try:
+                offset = self._filehandle.tell()
+            except ValueError:
+                retries -= 1
+                if retries <= 0:
+                    return -0.5
+                await asyncio.sleep(0.01)
+        return float(offset) / float(self.contentlen)
+    
+    def mark_completed(self, fut):
+        self._completed = True
+
+    def set_task(self, task):
+        self._xfertask = task
+
+    def completed(self):
+        return self._completed
+
+    async def join(self, timeout=None):
+        if self._xfertask is None:
+            return
+        if timeout is None:
+            await self._xfertask
+        else:
+            await asyncio.wait_for(asyncio.shield(self._xfertask), timeout=timeout)
+
+class Uploader(Downloader):
+    @classmethod
+    async def create(cls, filename, data=None, formname=None,
+                 otherfields=(), formwrap=True):
+        self = cls()
+        self._response = None
+        self._statuscode = None
+        self._xfertask = None
+        self._completed = False
+        self._rspheaders = None
+        self.rsp = ''
+        self.rspstatus = 500
+        self.filename = filename
+        if data:
+            self.data = data
+        else:
+            self.data = open(filename, 'rb')
+        self.formname = formname
+        self.otherfields = otherfields
+        self.ulheaders = {}
+        if formwrap:
+            guf = await get_upload_form(
+                filename, self.data, formname, otherfields)
+            self._upbuffer = io.BytesIO(guf[0])
+            self._boundary = guf[1]
+            self.ulsize = len(uploadforms[filename][0])
+            self.ulheaders['Content-Type'] = 'multipart/form-data; boundary={0}'.format(
+                self._boundary.decode('utf-8'))
+            self.ulheaders['Content-Size'] = str(self.ulsize)
+        else:
+            canseek = True
+            try:
+                curroff = self.data.tell()
+            except Exception:
+                canseek = False
+                databytes = await asyncio.to_thread(self.data.read)
+                self.ulsize = len(databytes)
+                self._upbuffer = io.BytesIO(databytes)
+            if canseek:
+                self.data.seek(0, 2)
+                self.ulsize = self.data.tell() - curroff
+                self.data.seek(curroff, 0)
+                self._upbuffer = self.data
+            self.ulheaders['Content-Length'] = str(self.ulsize)
+            self.ulheaders['Content-Type'] = 'application/octet-stream'
+        return self
+    
+    def set_response(self, statuscode, response, headers):
+        self._statuscode = statuscode
+        self._response = response
+        self._rspheaders = headers
+
+    def get_response(self):
+        return self._statuscode, self._response, self._rspheaders
+    
+    def get_buffer(self):
+        return self._upbuffer
+    
+    def get_headers(self):
+        return self.ulheaders
+    
+    def get_size(self):
+        return self.ulsize
+    
+    def close(self):
+        if self.filename in uploadforms:
+            try:
+                del uploadforms[self.filename]
+            except KeyError:
+                pass
+        try:
+            self.data.close()
+        except Exception:
+            pass
+
+    async def get_progress(self):
+        if self._completed:
+            return 1.0
+        if self._xfertask is None:
+            return 0.0
+
+        totalen = self.get_size()
+        if totalen is None:
+            return -0.5
+        offset = None
+        tries = 100
+        while offset is None:
+            if self._completed:
+                return 1.0
+            if self._xfertask is None:
+                return 0.0
+            try:
+                offset = self._upbuffer.tell()
+            except ValueError:
+                await asyncio.sleep(0.01)
+                tries -= 1
+                if tries <= 0:
+                    return -0.5
+        return float(offset) / float(totalen)
+
+def make_downloader(webconn, url, dlfile):
+    if isinstance(dlfile, str):
+        dlfile = open(dlfile, 'wb')
+    dler = Downloader.create(dlfile)
+    tsk = asyncio.create_task(webconn.download(url, dlfile, dler))
+    dler.set_task(tsk)
+    tsk.add_done_callback(dler.mark_completed)
+    return dler
+
+async def make_uploader(webconn, url, filename, data=None, formname=None,
+                 otherfields=(), formwrap=True):
+    uler = await Uploader.create(filename, data, formname, otherfields, formwrap)
+    tsk = asyncio.create_task(webconn.upload(
+        url, filename, uler.get_buffer(), uploader=uler))
+    uler.set_task(tsk)
+    tsk.add_done_callback(uler.mark_completed)
+    return uler
+    
+
+    
+
+async def get_upload_form(filename, data, formname, otherfields, boundary=None):
+    if not boundary:
+        boundary = base64.urlsafe_b64encode(os.urandom(54))[:66] 
+    ffilename = filename.split('/')[-1]
+    if not formname:
+        formname = ffilename
+    while uploadforms.get(filename, None) == 'pending':
+        await asyncio.sleep(0.1)
+    try:
+        return uploadforms[filename]
+    except KeyError:
+        uploadforms[filename] = 'pending'
+        try:
+            data = await asyncio.to_thread(data.read)
+        except AttributeError:
+            pass
+        return await asyncio.to_thread(assign_upload_form, filename, ffilename, data, formname, otherfields, boundary)
+
+def assign_upload_form(filename, ffilename, data, formname, otherfields, boundary=None):
+        form = b''
+        for ofield in otherfields:
+            tfield = otherfields[ofield]
+            xtra=''
+            if isinstance(tfield, dict):
+                tfield = json.dumps(tfield)
+                xtra = '\r\nContent-Type: application/json'
+            form += (b'--' + boundary
+                     + '\r\nContent-Disposition: form-data; '
+                       'name="{0}"{1}\r\n\r\n{2}\r\n'.format(
+                           ofield, xtra, tfield).encode('utf-8'))
+        form += (b'--' + boundary
+                + '\r\nContent-Disposition: form-data; '
+                  'name="{0}"; filename="{1}"\r\n'.format(
+                      formname, ffilename).encode('utf-8'))
+        form += b'Content-Type: application/octet-stream\r\n\r\n' + data
+        form += b'\r\n--' + boundary + b'--\r\n'
+        uploadforms[filename] = form, boundary
+        return uploadforms[filename]
+
+
+class WebConnection:
+    def __init__(self, host, port, verifycallback=None, timeout=None):
+        self.port = port
+        self.thehost = host
+        if ':' in host and '[' not in host:
+            self.host = f'[{host}]'
+        else:
+            self.host = host
+        if verifycallback:
+            self.ssl = CustomVerifier(verifycallback)
+        else:
+            self.ssl = None
+        self.verifycallback = verifycallback
+        if isinstance(timeout, (int, float)):
+            self.timeout = aiohttp.ClientTimeout(total=timeout)
+        else:
+            self.timeout = timeout 
+        self.stdheaders = {}
+        if '[' not in host and '%' in host:
+            self.stdheaders['Host'] = '[' + host.split('%', 1)[0] + ']'
+        self.cookies = CookieJar(quote_cookie=False, unsafe=True)
+
+    def set_timeout(self, timeout):
+        if isinstance(timeout, (int, float)):
+            self.timeout = aiohttp.ClientTimeout(total=timeout)
+        else:
+            self.timeout = timeout
+    
+    def get_timeout(self):
+        return self.timeout
+    
+    def set_header(self, key, value):
+        self.stdheaders[key] = value
+
+    def dupe(self, timeout=None):
+        newwc = WebConnection(self.host, self.port,
+                              verifycallback=self.verifycallback, timeout=timeout or self.timeout)
+        newwc.stdheaders = self.stdheaders.copy()
+        newwc.cookies = CookieJar(quote_cookie=False, unsafe=True)
+        for cookie in self.cookies:
+            newwc.cookies.update_cookies(
+                {cookie.key: cookie.value}, response_url=URL(f'https://{self.host}:{self.port}/'))
+        return newwc
+
+    async def request(
+            self, method, url, body=None, headers=None, referer=None):
+        if headers is None:
+            headers = self.stdheaders.copy()
+        else:
+            headers = headers.copy()
+        if method == 'GET' and 'Content-Type' in headers:
+            del headers['Content-Type']
+        if method == 'POST' and body and 'Content-Type' not in headers:
+            headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        if body and 'Content-Length' not in headers:
+            headers['Content-Length'] = len(body)
+        if referer:
+            headers['referer'] = referer
+        method = method.lower()
+        async with aiohttp.ClientSession(
+                f'https://{self.host}:{self.port}', cookie_jar=self.cookies, timeout=self.timeout) as session:
+            thefunc = getattr(session, method)
+            kwargs = {}
+            if isinstance(body, dict):
+                kwargs['json'] = body
+            elif body:
+                kwargs['data'] = body
+            async with thefunc(url, headers=headers, ssl=self.ssl, **kwargs) as rsp:
+                pass
+
+    def set_basic_credentials(self, username, password):
+        if isinstance(username, bytes) and not isinstance(username, str):
+            username = username.decode('utf-8')
+        if isinstance(password, bytes) and not isinstance(password, str):
+            password = password.decode('utf-8')
+        authinfo = ':'.join((username, password))
+        if not isinstance(authinfo, bytes):
+            authinfo = authinfo.encode('utf-8')
+        authinfo = base64.b64encode(authinfo)
+        if not isinstance(authinfo, str):
+            authinfo = authinfo.decode('utf-8')
+        self.stdheaders['Authorization'] = 'Basic {0}'.format(authinfo)
+
+    async def grab_json_response(self, url, data=None, referer=None, headers=None):
+        self.lastjsonerror = None
+        body, status = await self.grab_json_response_with_status(
+            url, data, referer, headers)
+        if status == 200:
+            return body
+        self.lastjsonerror = body
+        return {}
+
+    async def grab_json_response_with_status(self, url, data=None, referer=None,
+                                        headers=None, method=None):
+        rsp, status, hdrs = await self.grab_response_with_status(url, data, referer, headers, method, expect_type='json')
+        return rsp, status
+
+    async def grab_response_with_status(self, url, data=None, referer=None,
+                                        headers=None, method=None, expect_type=None):
+        if not headers:
+            headers = self.stdheaders.copy()
+        else:
+            headers = headers.copy()
+        if referer:
+            headers['referer'] = referer
+        if not method:
+            method = 'POST' if data is not None else 'GET'
+        method = method.lower()
+        if 'Content-Type' in headers and method.lower() in ('get', 'delete'):
+            del headers['Content-Type']
+        async with aiohttp.ClientSession(f'https://{self.host}:{self.port}', cookie_jar=self.cookies, timeout=self.timeout) as session:
+            thefunc = getattr(session, method)
+            kwargs = {}
+            if isinstance(data, dict):
+                kwargs['json'] = data
+                if 'Content-Type' not in headers:
+                    headers['Content-Type'] = 'application/json'
+            elif data is not None:
+                kwargs['data'] = data
+            async with thefunc(url, headers=headers, ssl=self.ssl, **kwargs) as rsp:
+                if rsp.status >= 200 and rsp.status < 300:
+                    if expect_type == 'json':
+                        return await rsp.json(content_type=''), rsp.status, rsp.headers
+                    elif expect_type == 'text':
+                        return await rsp.text(), rsp.status, rsp.headers
+                    else:
+                        return await rsp.read(), rsp.status, rsp.headers
+                else:
+                    return await rsp.read(), rsp.status, rsp.headers
+
+    async def download(self, url, dlfile, downloader=None):
+        """Download a file to filename or file object
+
+        """
+        if isinstance(dlfile, str):
+            dlfile = open(dlfile, 'wb')
+        dlheaders = self.stdheaders.copy()
+        if 'Accept-Encoding' in dlheaders:
+            del dlheaders['Accept-Encoding']
+        async with aiohttp.ClientSession(f'https://{self.host}:{self.port}', cookie_jar=self.cookies, timeout=self.timeout) as session:
+            async with session.get(url, headers=dlheaders, ssl=self.ssl) as rsp:
+                if downloader:
+                    downloader.contentlen = rsp.headers.get('content-length', None)
+                    try:
+                        downloader.contentlen = int(downloader.contentlen)
+                    except Exception:
+                        downloader.contentlen = None
+                async for chunk in rsp.content.iter_chunked(16384):
+                    dlfile.write(chunk)
+        dlfile.close()
+
+    async def upload(self, url, ulfile, data=None, uploader=None):
+        upheaders = self.stdheaders.copy()
+        if uploader:
+            upheaders.update(uploader.get_headers())
+            data = uploader.get_buffer()
+        else:
+            raise Exception("Not implemented without uploader handler")
+        async with aiohttp.ClientSession(f'https://{self.host}:{self.port}', cookie_jar=self.cookies, timeout=self.timeout) as session:
+            async with session.post(url, headers=upheaders, ssl=self.ssl, data=data) as rsp:
+                if rsp.status >= 200 and rsp.status < 300:
+                    expect_type = rsp.headers.get('Content-Type', '')
+                    if 'json' in expect_type:
+                        uploader.set_response(rsp.status, await rsp.json(content_type=''), rsp.headers)
+                    elif 'text' in expect_type:
+                        uploader.set_response(rsp.status, await rsp.text(), rsp.headers)
+                    else:
+                        uploader.set_response(rsp.status, await rsp.read(), rsp.headers)
+                else:
+                    uploader.set_response(rsp.status, await rsp.read(), rsp.headers)
+        if uploader:
+            uploader.close()
+            return uploader._statuscode
+
diff --git a/confluent_server/aiohmi/version.py b/confluent_server/aiohmi/version.py
new file mode 100644
index 00000000..f44b1551
--- /dev/null
+++ b/confluent_server/aiohmi/version.py
@@ -0,0 +1,18 @@
+# Copyright 2017 Red Hat, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import pbr.version
+
+version_info = pbr.version.VersionInfo('aiohmi')
diff --git a/confluent_server/confluent_server.spec.tmpl b/confluent_server/confluent_server.spec.tmpl
index fd425303..b0714321 100644
--- a/confluent_server/confluent_server.spec.tmpl
+++ b/confluent_server/confluent_server.spec.tmpl
@@ -21,7 +21,7 @@ Requires: confluent_vtbufferd
 Requires: python3-asyncssh, python3-pycryptodomex >= 3.4.7, confluent_client == %{version}, python3-pyparsing, python3-dns, python3-webauthn, python3-netifaces, python3-pyasn1 >= 0.2.3, python3-pysnmp >= 4.3.4, python3-lxml, python3-eficompressor, python3-setuptools, python3-dateutil, python3-cffi, python3-pyOpenSSL, python3-websocket-client python3-msgpack python3-libarchive-c python3-yaml openssl iproute
 %else
 %if "%{dist}" == ".el10"
-Requires: python3-asyncssh, confluent_client == %{version}, python3-pyparsing, python3-dns, python3-psutil, python3-pyasn1 >= 0.2.3, python3-pysnmp >= 4.3.4, python3-lxml,python3-setuptools, python3-dateutil, python3-cffi, python3-pyOpenSSL, python3-websocket-client python3-msgpack python3-libarchive-c python3-yaml openssl iproute python3-yarl python3-aiohmi python3-aiohttp
+Requires: python3-asyncssh, confluent_client == %{version}, python3-pyparsing, python3-dns, python3-psutil, python3-pyasn1 >= 0.2.3, python3-pysnmp >= 4.3.4, python3-lxml,python3-setuptools, python3-dateutil, python3-cffi, python3-pyOpenSSL, python3-websocket-client python3-msgpack python3-libarchive-c python3-yaml openssl iproute python3-yarl python3-aiohttp
 %endif
 %endif
 
@@ -58,10 +58,6 @@ rmdir $RPM_BUILD_ROOT/etc
 systemd-analyze verify $RPM_BUILD_ROOT/usr/lib/systemd/system/confluent.service 2>&1 | grep "'AmbientCapabilities'" > /dev/null && sed -e 's/User=.*//' -e 's/Group=.*//' -e 's/AmbientCapabilities=.*//' -i $RPM_BUILD_ROOT/usr/lib/systemd/system/confluent.service
 cat INSTALLED_FILES
 
-%triggerin -- python-aiohmi, python3-aiohmi
-if [ -x /usr/bin/systemctl ]; then /usr/bin/systemctl try-restart confluent >& /dev/null; fi
-true
-
 %pre
 getent group confluent > /dev/null || /usr/sbin/groupadd -r confluent
 getent passwd confluent > /dev/null || /usr/sbin/useradd -r -g confluent -d /var/lib/confluent -s /sbin/nologin confluent
diff --git a/confluent_server/setup.py.tmpl b/confluent_server/setup.py.tmpl
index 8987e19d..1cfe357f 100644
--- a/confluent_server/setup.py.tmpl
+++ b/confluent_server/setup.py.tmpl
@@ -22,7 +22,19 @@ setup(
               'confluent/plugins/info/',
               'confluent/plugins/shell/',
               'confluent/collective/',
-              'confluent/plugins/configuration/'],
+              'confluent/plugins/configuration/',
+              'aiohmi',
+              'aiohmi/cmd',
+              'aiohmi/ipmi',
+              'aiohmi/ipmi/oem',
+              'aiohmi/ipmi/oem/lenovo',
+              'aiohmi/ipmi/private',
+              'aiohmi/redfish',
+              'aiohmi/redfish/oem',
+              'aiohmi/redfish/oem/dell',
+              'aiohmi/redfish/oem/lenovo',
+              'aiohmi/redfish/oem/ami',
+              'aiohmi/util'],
     scripts=['bin/confluent', 'bin/confluent_selfcheck', 'bin/confluentdbutil', 'bin/collective', 'bin/osdeploy'],
     data_files=[('/etc/init.d', ['sysvinit/confluent']),
                 ('/usr/lib/sysctl.d', ['sysctl/confluent.conf']),