docs: def install(name=None, sources=None, saltenv='base', **kwargs):
      '''
      Install the passed package. Can install packages from the following
      sources:
  
      * Locally (package already exists on the minion
      * HTTP/HTTPS server
      * FTP server
      * Salt master
  
      Returns a dict containing the new package names and versions:
  
      .. code-block:: python
  
          {'<package>': {'old': '<old-version>',
                         'new': '<new-version>'}}
  
      CLI Examples:
  
      .. code-block:: bash
  
          # Installing a data stream pkg that already exists on the minion
  
          salt '*' pkg.install sources='[{"<pkg name>": "/dir/on/minion/<pkg filename>"}]'
          salt '*' pkg.install sources='[{"SMClgcc346": "/var/spool/pkg/gcc-3.4.6-sol10-sparc-local.pkg"}]'
  
          # Installing a data stream pkg that exists on the salt master
  
          salt '*' pkg.install sources='[{"<pkg name>": "salt://pkgs/<pkg filename>"}]'
          salt '*' pkg.install sources='[{"SMClgcc346": "salt://pkgs/gcc-3.4.6-sol10-sparc-local.pkg"}]'
  
      CLI Example:
  
      .. code-block:: bash
  
          # Installing a data stream pkg that exists on a HTTP server
          salt '*' pkg.install sources='[{"<pkg name>": "http://packages.server.com/<pkg filename>"}]'
          salt '*' pkg.install sources='[{"SMClgcc346": "http://packages.server.com/gcc-3.4.6-sol10-sparc-local.pkg"}]'
  
      If working with solaris zones and you want to install a package only in the
      global zone you can pass 'current_zone_only=True' to salt to have the
      package only installed in the global zone. (Behind the scenes this is
      passing '-G' to the pkgadd command.) Solaris default when installing a
      package in the global zone is to install it in all zones. This overrides
      that and installs the package only in the global.
  
      CLI Example:
  
      .. code-block:: bash
  
          # Installing a data stream package only in the global zone:
          salt 'global_zone' pkg.install sources='[{"SMClgcc346": "/var/spool/pkg/gcc-3.4.6-sol10-sparc-local.pkg"}]' current_zone_only=True
  
      By default salt automatically provides an adminfile, to automate package
      installation, with these options set::
  
          email=
          instance=quit
          partial=nocheck
          runlevel=nocheck
          idepend=nocheck
          rdepend=nocheck
          space=nocheck
          setuid=nocheck
          conflict=nocheck
          action=nocheck
          basedir=default
  
      You can override any of these options in two ways. First you can optionally
      pass any of the options as a kwarg to the module/state to override the
      default value or you can optionally pass the 'admin_source' option
      providing your own adminfile to the minions.
  
      Note: You can find all of the possible options to provide to the adminfile
      by reading the admin man page:
  
      .. code-block:: bash
  
          man -s 4 admin
  
      CLI Example:
  
      .. code-block:: bash
  
          # Overriding the 'instance' adminfile option when calling the module directly
          salt '*' pkg.install sources='[{"<pkg name>": "salt://pkgs/<pkg filename>"}]' instance="overwrite"
  
      SLS Example:
  
      .. code-block:: yaml
  
          # Overriding the 'instance' adminfile option when used in a state
  
          SMClgcc346:
            pkg.installed:
              - sources:
                - SMClgcc346: salt://srv/salt/pkgs/gcc-3.4.6-sol10-sparc-local.pkg
              - instance: overwrite
  
      .. note::
          The ID declaration is ignored, as the package name is read from the
          ``sources`` parameter.
  
      CLI Example:
  
      .. code-block:: bash
  
          # Providing your own adminfile when calling the module directly
  
          salt '*' pkg.install sources='[{"<pkg name>": "salt://pkgs/<pkg filename>"}]' admin_source='salt://pkgs/<adminfile filename>'
  
          # Providing your own adminfile when using states
  
          <pkg name>:
            pkg.installed:
              - sources:
                - <pkg name>: salt://pkgs/<pkg filename>
              - admin_source: salt://pkgs/<adminfile filename>
  
      .. note::
          The ID declaration is ignored, as the package name is read from the
          ``sources`` parameter.
      '''
      if salt.utils.data.is_true(kwargs.get('refresh')):
          log.warning('\'refresh\' argument not implemented for solarispkg '
                      'module')
  
      # pkgs is not supported, but must be passed here for API compatibility
      pkgs = kwargs.pop('pkgs', None)
      try:
          pkg_params, pkg_type = __salt__['pkg_resource.parse_targets'](
              name, pkgs, sources, **kwargs
          )
      except MinionError as exc:
          raise CommandExecutionError(exc)
  
      if not pkg_params:
          return {}
  
      if not sources:
          log.error('"sources" param required for solaris pkg_add installs')
          return {}
  
      try:
          if 'admin_source' in kwargs:
              adminfile = __salt__['cp.cache_file'](kwargs['admin_source'], saltenv)
          else:
              adminfile = _write_adminfile(kwargs)
  
          old = list_pkgs()
          cmd_prefix = ['/usr/sbin/pkgadd', '-n', '-a', adminfile]
  
          # Only makes sense in a global zone but works fine in non-globals.
          if kwargs.get('current_zone_only') == 'True':
              cmd_prefix += '-G '
  
          errors = []
          for pkg in pkg_params:
              cmd = cmd_prefix + ['-d', pkg, 'all']
              # Install the package{s}
              out = __salt__['cmd.run_all'](cmd,
                                            output_loglevel='trace',
                                            python_shell=False)
  
              if out['retcode'] != 0 and out['stderr']:
                  errors.append(out['stderr'])
  
          __context__.pop('pkg.list_pkgs', None)
          new = list_pkgs()
          ret = salt.utils.data.compare_dicts(old, new)
  
          if errors:
              raise CommandExecutionError(
                  'Problem encountered installing package(s)',
                  info={'errors': errors, 'changes': ret}
              )
      finally:
          # Remove the temp adminfile
          if 'admin_source' not in kwargs:
              try:
                  os.remove(adminfile)
              except (NameError, OSError):
                  pass
  
      return ret