docs: def create_cinder_volume(self, cinder, vol_name="demo-vol", vol_size=1,
                               img_id=None, src_vol_id=None, snap_id=None):
          """Create cinder volume, optionally from a glance image, OR
          optionally as a clone of an existing volume, OR optionally
          from a snapshot.  Wait for the new volume status to reach
          the expected status, validate and return a resource pointer.
  
          :param vol_name: cinder volume display name
          :param vol_size: size in gigabytes
          :param img_id: optional glance image id
          :param src_vol_id: optional source volume id to clone
          :param snap_id: optional snapshot id to use
          :returns: cinder volume pointer
          """
          # Handle parameter input and avoid impossible combinations
          if img_id and not src_vol_id and not snap_id:
              # Create volume from image
              self.log.debug('Creating cinder volume from glance image...')
              bootable = 'true'
          elif src_vol_id and not img_id and not snap_id:
              # Clone an existing volume
              self.log.debug('Cloning cinder volume...')
              bootable = cinder.volumes.get(src_vol_id).bootable
          elif snap_id and not src_vol_id and not img_id:
              # Create volume from snapshot
              self.log.debug('Creating cinder volume from snapshot...')
              snap = cinder.volume_snapshots.find(id=snap_id)
              vol_size = snap.size
              snap_vol_id = cinder.volume_snapshots.get(snap_id).volume_id
              bootable = cinder.volumes.get(snap_vol_id).bootable
          elif not img_id and not src_vol_id and not snap_id:
              # Create volume
              self.log.debug('Creating cinder volume...')
              bootable = 'false'
          else:
              # Impossible combination of parameters
              msg = ('Invalid method use - name:{} size:{} img_id:{} '
                     'src_vol_id:{} snap_id:{}'.format(vol_name, vol_size,
                                                       img_id, src_vol_id,
                                                       snap_id))
              amulet.raise_status(amulet.FAIL, msg=msg)
  
          # Create new volume
          try:
              vol_new = cinder.volumes.create(display_name=vol_name,
                                              imageRef=img_id,
                                              size=vol_size,
                                              source_volid=src_vol_id,
                                              snapshot_id=snap_id)
              vol_id = vol_new.id
          except TypeError:
              vol_new = cinder.volumes.create(name=vol_name,
                                              imageRef=img_id,
                                              size=vol_size,
                                              source_volid=src_vol_id,
                                              snapshot_id=snap_id)
              vol_id = vol_new.id
          except Exception as e:
              msg = 'Failed to create volume: {}'.format(e)
              amulet.raise_status(amulet.FAIL, msg=msg)
  
          # Wait for volume to reach available status
          ret = self.resource_reaches_status(cinder.volumes, vol_id,
                                             expected_stat="available",
                                             msg="Volume status wait")
          if not ret:
              msg = 'Cinder volume failed to reach expected state.'
              amulet.raise_status(amulet.FAIL, msg=msg)
  
          # Re-validate new volume
          self.log.debug('Validating volume attributes...')
          val_vol_name = self._get_cinder_obj_name(cinder.volumes.get(vol_id))
          val_vol_boot = cinder.volumes.get(vol_id).bootable
          val_vol_stat = cinder.volumes.get(vol_id).status
          val_vol_size = cinder.volumes.get(vol_id).size
          msg_attr = ('Volume attributes - name:{} id:{} stat:{} boot:'
                      '{} size:{}'.format(val_vol_name, vol_id,
                                          val_vol_stat, val_vol_boot,
                                          val_vol_size))
  
          if val_vol_boot == bootable and val_vol_stat == 'available' \
                  and val_vol_name == vol_name and val_vol_size == vol_size:
              self.log.debug(msg_attr)
          else:
              msg = ('Volume validation failed, {}'.format(msg_attr))
              amulet.raise_status(amulet.FAIL, msg=msg)
  
          return vol_new