docs: def create(vm_):
      '''
      Create a single VM from a data dict
      '''
      try:
          # Check for required profile parameters before sending any API calls.
          if vm_['profile'] and config.is_profile_configured(__opts__,
                                                             __active_provider_name__ or 'cloudstack',
                                                             vm_['profile'],
                                                             vm_=vm_) is False:
              return False
      except AttributeError:
          pass
  
      __utils__['cloud.fire_event'](
          'event',
          'starting create',
          'salt/cloud/{0}/creating'.format(vm_['name']),
          sock_dir=__opts__['sock_dir'],
          args=__utils__['cloud.filter_event']('creating', vm_, ['name', 'profile', 'provider', 'driver']),
          transport=__opts__['transport']
      )
  
      log.info('Creating Cloud VM %s', vm_['name'])
      conn = get_conn()
      # pylint: disable=not-callable
      kwargs = {
          'name': vm_['name'],
          'image': get_image(conn, vm_),
          'size': get_size(conn, vm_),
          'location': get_location(conn, vm_),
      }
      # pylint: enable=not-callable
  
      sg = get_security_groups(conn, vm_)
      if sg is not False:
          kwargs['ex_security_groups'] = sg
  
      if get_keypair(vm_) is not False:
          kwargs['ex_keyname'] = get_keypair(vm_)
  
      if get_networkid(vm_) is not False:
          kwargs['networkids'] = get_networkid(vm_)
          kwargs['networks'] = (   # The only attr that is used is 'id'.
                                   CloudStackNetwork(None, None, None,
                                                     kwargs['networkids'],
                                                     None, None),
                               )
  
      if get_project(conn, vm_) is not False:
          kwargs['project'] = get_project(conn, vm_)
  
      event_data = kwargs.copy()
      event_data['image'] = kwargs['image'].name
      event_data['size'] = kwargs['size'].name
  
      __utils__['cloud.fire_event'](
          'event',
          'requesting instance',
          'salt/cloud/{0}/requesting'.format(vm_['name']),
          sock_dir=__opts__['sock_dir'],
          args={
              'kwargs': __utils__['cloud.filter_event'](
                  'requesting',
                  event_data,
                  ['name', 'profile', 'provider', 'driver', 'image', 'size'],
              ),
          },
          transport=__opts__['transport']
      )
  
      displayname = cloudstack_displayname(vm_)
      if displayname:
          kwargs['ex_displayname'] = displayname
      else:
          kwargs['ex_displayname'] = kwargs['name']
  
      volumes = {}
      ex_blockdevicemappings = block_device_mappings(vm_)
      if ex_blockdevicemappings:
          for ex_blockdevicemapping in ex_blockdevicemappings:
              if 'VirtualName' not in ex_blockdevicemapping:
                  ex_blockdevicemapping['VirtualName'] = '{0}-{1}'.format(vm_['name'], len(volumes))
              __utils__['cloud.fire_event'](
                  'event',
                  'requesting volume',
                  'salt/cloud/{0}/requesting'.format(ex_blockdevicemapping['VirtualName']),
                  sock_dir=__opts__['sock_dir'],
                  args={'kwargs': {'name': ex_blockdevicemapping['VirtualName'],
                                   'device': ex_blockdevicemapping['DeviceName'],
                                   'size': ex_blockdevicemapping['VolumeSize']}},
              )
              try:
                  volumes[ex_blockdevicemapping['DeviceName']] = conn.create_volume(
                          ex_blockdevicemapping['VolumeSize'],
                          ex_blockdevicemapping['VirtualName']
                      )
              except Exception as exc:
                  log.error(
                      'Error creating volume %s on CLOUDSTACK\n\n'
                      'The following exception was thrown by libcloud when trying to '
                      'requesting a volume: \n%s',
                      ex_blockdevicemapping['VirtualName'], exc,
                      # Show the traceback if the debug logging level is enabled
                      exc_info_on_loglevel=logging.DEBUG
                  )
                  return False
      else:
          ex_blockdevicemapping = {}
      try:
          data = conn.create_node(**kwargs)
      except Exception as exc:
          log.error(
              'Error creating %s on CLOUDSTACK\n\n'
              'The following exception was thrown by libcloud when trying to '
              'run the initial deployment: \n%s',
              vm_['name'], exc,
              # Show the traceback if the debug logging level is enabled
              exc_info_on_loglevel=logging.DEBUG
          )
          return False
  
      for device_name in six.iterkeys(volumes):
          try:
              conn.attach_volume(data, volumes[device_name], device_name)
          except Exception as exc:
              log.error(
                  'Error attaching volume %s on CLOUDSTACK\n\n'
                  'The following exception was thrown by libcloud when trying to '
                  'attach a volume: \n%s',
                  ex_blockdevicemapping.get('VirtualName', 'UNKNOWN'), exc,
                  # Show the traceback if the debug logging level is enabled
                  exc_info=log.isEnabledFor(logging.DEBUG)
              )
              return False
  
      ssh_username = config.get_cloud_config_value(
          'ssh_username', vm_, __opts__, default='root'
      )
  
      vm_['ssh_host'] = get_ip(data)
      vm_['password'] = data.extra['password']
      vm_['key_filename'] = get_key()
      ret = __utils__['cloud.bootstrap'](vm_, __opts__)
  
      ret.update(data.__dict__)
  
      if 'password' in data.extra:
          del data.extra['password']
  
      log.info('Created Cloud VM \'%s\'', vm_['name'])
      log.debug(
          '\'%s\' VM creation details:\n%s',
          vm_['name'], pprint.pformat(data.__dict__)
      )
  
      __utils__['cloud.fire_event'](
          'event',
          'created instance',
          'salt/cloud/{0}/created'.format(vm_['name']),
          sock_dir=__opts__['sock_dir'],
          args=__utils__['cloud.filter_event']('created', vm_, ['name', 'profile', 'provider', 'driver']),
          transport=__opts__['transport']
      )
  
      return ret