docs: def create_configuration(raid_config):
      """Create a RAID configuration on this server.
  
      This method creates the given RAID configuration on the
      server based on the input passed.
      :param raid_config: The dictionary containing the requested
          RAID configuration. This data structure should be as follows:
          raid_config = {'logical_disks': [{'raid_level': 1, 'size_gb': 100},
                                           <info-for-logical-disk-2>
                                          ]}
      :returns: the current raid configuration. This is same as raid_config
          with some extra properties like root_device_hint, volume_name,
          controller, physical_disks, etc filled for each logical disk
          after its creation.
      :raises exception.InvalidInputError, if input is invalid.
      :raises exception.HPSSAOperationError, if all the controllers are in HBA
          mode.
      """
      server = objects.Server()
  
      select_controllers = lambda x: not x.properties.get('HBA Mode Enabled',
                                                          False)
      _select_controllers_by(server, select_controllers, 'RAID enabled')
  
      validate(raid_config)
  
      # Make sure we create the large disks first.  This is avoid the
      # situation that we avoid giving large disks to smaller requests.
      # For example, consider this:
      #   - two logical disks - LD1(50), LD(100)
      #   - have 4 physical disks - PD1(50), PD2(50), PD3(100), PD4(100)
      #
      # In this case, for RAID1 configuration, if we were to consider
      # LD1 first and allocate PD3 and PD4 for it, then allocation would
      # fail. So follow a particular order for allocation.
      #
      # Also make sure we create the MAX logical_disks the last to make sure
      # we allot only the remaining space available.
      logical_disks_sorted = (
          sorted((x for x in raid_config['logical_disks']
                  if x['size_gb'] != "MAX"),
                 reverse=True,
                 key=lambda x: x['size_gb']) +
          [x for x in raid_config['logical_disks'] if x['size_gb'] == "MAX"])
  
      if any(logical_disk['share_physical_disks']
              for logical_disk in logical_disks_sorted
              if 'share_physical_disks' in logical_disk):
          logical_disks_sorted = _sort_shared_logical_disks(logical_disks_sorted)
  
      # We figure out the new disk created by recording the wwns
      # before and after the create, and then figuring out the
      # newly found wwn from it.
      wwns_before_create = set([x.wwn for x in
                                server.get_logical_drives()])
  
      for logical_disk in logical_disks_sorted:
  
          if 'physical_disks' not in logical_disk:
              disk_allocator.allocate_disks(logical_disk, server,
                                            raid_config)
  
          controller_id = logical_disk['controller']
  
          controller = server.get_controller_by_id(controller_id)
          if not controller:
              msg = ("Unable to find controller named '%(controller)s'."
                     " The available controllers are '%(ctrl_list)s'." %
                     {'controller': controller_id,
                      'ctrl_list': ', '.join(
                          [c.id for c in server.controllers])})
              raise exception.InvalidInputError(reason=msg)
  
          if 'physical_disks' in logical_disk:
              for physical_disk in logical_disk['physical_disks']:
                  disk_obj = controller.get_physical_drive_by_id(physical_disk)
                  if not disk_obj:
                      msg = ("Unable to find physical disk '%(physical_disk)s' "
                             "on '%(controller)s'" %
                             {'physical_disk': physical_disk,
                              'controller': controller_id})
                      raise exception.InvalidInputError(msg)
  
          controller.create_logical_drive(logical_disk)
  
          # Now find the new logical drive created.
          server.refresh()
          wwns_after_create = set([x.wwn for x in
                                   server.get_logical_drives()])
  
          new_wwn = wwns_after_create - wwns_before_create
  
          if not new_wwn:
              reason = ("Newly created logical disk with raid_level "
                        "'%(raid_level)s' and size %(size_gb)s GB not "
                        "found." % {'raid_level': logical_disk['raid_level'],
                                    'size_gb': logical_disk['size_gb']})
              raise exception.HPSSAOperationError(reason=reason)
  
          new_logical_disk = server.get_logical_drive_by_wwn(new_wwn.pop())
          new_log_drive_properties = new_logical_disk.get_logical_drive_dict()
          logical_disk.update(new_log_drive_properties)
  
          wwns_before_create = wwns_after_create.copy()
  
      _update_physical_disk_details(raid_config, server)
      return raid_config