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 'softlayer_hw',
                                                             vm_['profile'],
                                                             vm_=vm_) is False:
              return False
      except AttributeError:
          pass
  
      name = vm_['name']
      hostname = name
      domain = config.get_cloud_config_value(
          'domain', vm_, __opts__, default=None
      )
      if domain is None:
          SaltCloudSystemExit(
              'A domain name is required for the SoftLayer driver.'
          )
  
      if vm_.get('use_fqdn'):
          name = '.'.join([name, domain])
          vm_['name'] = name
  
      __utils__['cloud.fire_event'](
          'event',
          'starting create',
          'salt/cloud/{0}/creating'.format(name),
          args=__utils__['cloud.filter_event']('creating', vm_, ['name', 'profile', 'provider', 'driver']),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      log.info('Creating Cloud VM %s', name)
      conn = get_conn(service='SoftLayer_Product_Order')
      kwargs = {
          'complexType': 'SoftLayer_Container_Product_Order_Hardware_Server',
          'quantity': 1,
          'hardware': [{
              'hostname': hostname,
              'domain': domain,
          }],
          # Baremetal Package
          'packageId': 50,
          'prices': [
              # Size Ex: 1921: 2 x 2.0 GHz Core Bare Metal Instance - 2 GB Ram
              {'id': vm_['size']},
              # HDD Ex: 19: 250GB SATA II
              {'id': vm_['hdd']},
              # Image Ex: 13963: CentOS 6.0 - Minimal Install (64 bit)
              {'id': vm_['image']},
  
              # The following items are currently required
              # Reboot / Remote Console
              {'id': '905'},
              # 1 IP Address
              {'id': '21'},
              # Host Ping Monitoring
              {'id': '55'},
              # Email and Ticket Notifications
              {'id': '57'},
              # Automated Notification Response
              {'id': '58'},
              # Unlimited SSL VPN Users & 1 PPTP VPN User per account
              {'id': '420'},
              # Nessus Vulnerability Assessment & Reporting
              {'id': '418'},
          ],
      }
  
      optional_products = config.get_cloud_config_value(
          'optional_products', vm_, __opts__, default=[]
      )
      for product in optional_products:
          kwargs['prices'].append({'id': product})
  
      # Default is 273 (100 Mbps Public & Private Networks)
      port_speed = config.get_cloud_config_value(
          'port_speed', vm_, __opts__, default=273
      )
      kwargs['prices'].append({'id': port_speed})
  
      # Default is 1800 (0 GB Bandwidth)
      bandwidth = config.get_cloud_config_value(
          'bandwidth', vm_, __opts__, default=1800
      )
      kwargs['prices'].append({'id': bandwidth})
  
      post_uri = config.get_cloud_config_value(
          'post_uri', vm_, __opts__, default=None
      )
      if post_uri:
          kwargs['prices'].append({'id': post_uri})
  
      vlan_id = config.get_cloud_config_value(
          'vlan', vm_, __opts__, default=False
      )
      if vlan_id:
          kwargs['primaryNetworkComponent'] = {
              'networkVlan': {
                  'id': vlan_id,
              }
          }
  
      location = get_location(vm_)
      if location:
          kwargs['location'] = location
  
      __utils__['cloud.fire_event'](
          'event',
          'requesting instance',
          'salt/cloud/{0}/requesting'.format(name),
          args={
              'kwargs': __utils__['cloud.filter_event']('requesting', kwargs, list(kwargs)),
          },
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      try:
          response = conn.placeOrder(kwargs)
          # Leaving the following line in, commented, for easy debugging
          #response = conn.verifyOrder(kwargs)
      except Exception as exc:
          log.error(
              'Error creating %s on SoftLayer\n\n'
              'The following exception was thrown when trying to '
              'run the initial deployment: \n%s', name, exc,
              # Show the traceback if the debug logging level is enabled
              exc_info_on_loglevel=logging.DEBUG
          )
          return False
  
      def wait_for_ip():
          '''
          Wait for the IP address to become available
          '''
          nodes = list_nodes_full()
          if 'primaryIpAddress' in nodes[hostname]:
              return nodes[hostname]['primaryIpAddress']
          time.sleep(1)
          return False
  
      ip_address = salt.utils.cloud.wait_for_fun(
          wait_for_ip,
          timeout=config.get_cloud_config_value(
              'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
      )
  
      ssh_connect_timeout = config.get_cloud_config_value(
          # 15 minutes
          'ssh_connect_timeout', vm_, __opts__, 900
      )
      if not salt.utils.cloud.wait_for_port(ip_address,
                                           timeout=ssh_connect_timeout):
          raise SaltCloudSystemExit(
              'Failed to authenticate against remote ssh'
          )
  
      pass_conn = get_conn(service='SoftLayer_Account')
      mask = {
          'virtualGuests': {
              'powerState': '',
              'operatingSystem': {
                  'passwords': ''
              },
          },
      }
  
      def get_passwd():
          '''
          Wait for the password to become available
          '''
          node_info = pass_conn.getVirtualGuests(id=response['id'], mask=mask)
          for node in node_info:
              if node['id'] == response['id'] \
                      and 'passwords' in node['operatingSystem'] \
                      and node['operatingSystem']['passwords']:
                  return node['operatingSystem']['passwords'][0]['password']
          time.sleep(5)
          return False
  
      passwd = salt.utils.cloud.wait_for_fun(
          get_passwd,
          timeout=config.get_cloud_config_value(
              'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
      )
      response['password'] = passwd
      response['public_ip'] = ip_address
  
      ssh_username = config.get_cloud_config_value(
          'ssh_username', vm_, __opts__, default='root'
      )
  
      vm_['ssh_host'] = ip_address
      vm_['password'] = passwd
      ret = __utils__['cloud.bootstrap'](vm_, __opts__)
  
      ret.update(response)
  
      __utils__['cloud.fire_event'](
          'event',
          'created instance',
          'salt/cloud/{0}/created'.format(name),
          args=__utils__['cloud.filter_event']('created', vm_, ['name', 'profile', 'provider', 'driver']),
          sock_dir=__opts__['sock_dir'],
          transport=__opts__['transport']
      )
  
      return ret