docs: def present(name, brand, zonepath, properties=None, resources=None):
      '''
      Ensure a zone with certain properties and resources
  
      name : string
          name of the zone
      brand : string
          brand of the zone
      zonepath : string
          path of the zone
      properties : list of key-value pairs
          dict of properties
      resources : list of key-value pairs
          dict of resources
  
      .. note::
          If the zone does not exist it will not be installed.
          You can use the ```zone.installed``` state for this.
  
      .. note::
          Default resource selectors:
              - fs: dir
              - net: mac-addr
              - device: match
              - rctl: name
              - attr: name
              - dataset: name
              - admin: user
  
      .. warning::
          Properties and resource will not be removed when they
          are absent from the state!
  
          For properties, simple set them to ```None```.
  
          For resources, add the ```resource_prune``` property
          and set it to ```True```. Also specify the
          ```resource_selector_property``` if the default is not
          the one you want.
  
      '''
      ret = {'name': name,
             'changes': {},
             'result': None,
             'comment': []}
  
      ## sanitize defaults
      if not properties:
          properties = []
      if not resources:
          resources = []
      properties.append(OrderedDict({"brand": brand}))
      properties.append(OrderedDict({"zonepath": zonepath}))
  
      zones = __salt__['zoneadm.list'](installed=True, configured=True)
  
      ## test mode only has limited support
      if __opts__['test']:
          ret['result'] = None
          ret['comment'].append('Cannot determine of changes would happen to the zone {0}.'.format(name))
  
      ## create zone if needed
      if name not in zones:
          if __opts__['test']:
              ## we pretend we created the zone
              res_create = {'status': True}
              ret['comment'] = []
          else:
              ## create and install
              res_create = __salt__['zonecfg.create'](name, brand, zonepath)
          if res_create['status']:
              ret['result'] = True
              ret['changes'][name] = 'created'
              ret['comment'].append('The zone {0} was created.'.format(name))
  
      if not __opts__['test']:
          ret['result'] = True
          if isinstance(properties, list):
              for prop in properties:
                  if not isinstance(prop, OrderedDict) or len(prop) != 1:
                      log.warning('zone.present - failed to parse property: %s', prop)
                      continue
                  for key, value in prop.items():
                      res = None
                      if not value:
                          res = property_absent(name, key)
                      elif value:
                          res = property_present(name, key, value)
                      if res:
                          ret['result'] = ret['result'] if res['result'] else False
                          ret['comment'].append(res['comment'])
                          if res['changes']:
                              if 'property' not in ret['changes']:
                                  ret['changes']['property'] = {}
                              ret['changes']['property'] = merge_dict(ret['changes']['property'], res['changes'])
          if isinstance(resources, list):
              for resource in resources:
                  if not isinstance(prop, OrderedDict) or len(prop) != 1:
                      log.warning('zone.present - failed to parse resource: %s', resource)
                      continue
                  for key, value in resource.items():
                      zonecfg = __salt__['zonecfg.info'](name, show_all=True)
                      resource_cfg = {}
                      resource_cfg['resource_type'] = key
                      if isinstance(value, list):
                          for respv in value:
                              resource_cfg.update(dict(respv))
  
                      resource_prune = False
                      resource_selector_property = None
                      if 'resource_prune' in resource_cfg:
                          resource_prune = resource_cfg['resource_prune']
                          del resource_cfg['resource_prune']
                      if 'resource_selector_property' in resource_cfg:
                          resource_selector_property = resource_cfg['resource_selector_property']
                          del resource_cfg['resource_selector_property']
                      if not resource_selector_property and key in _zonecfg_resource_default_selectors:
                          resource_selector_property = _zonecfg_resource_default_selectors[key]
  
                      res = None
                      if resource_prune:
                          res = resource_absent(
                              name,
                              resource_cfg['resource_type'],
                              resource_selector_property=resource_selector_property,
                              resource_selector_value=resource_cfg[resource_selector_property] if resource_selector_property else None,
                          )
                      else:
                          resource_cfg['resource_selector_property'] = resource_selector_property
                          if resource_selector_property in resource_cfg:
                              resource_cfg['resource_selector_value'] = resource_cfg[resource_selector_property]
                          else:
                              resource_cfg['resource_selector_value'] = None
                          resource_cfg['name'] = name  # we do this last because name can also be a attrib value
                          res = resource_present(**resource_cfg)
                      if res:
                          ret['result'] = ret['result'] if res['result'] else False
                          ret['comment'].append(res['comment'])
                          if res['changes']:
                              if 'resource' not in ret['changes']:
                                  ret['changes']['resource'] = {}
                              ret['changes']['resource'] = merge_dict(ret['changes']['resource'], res['changes'])
  
      if isinstance(ret['comment'], list):
          ret['comment'] = "\n".join(ret['comment'])
  
      return ret