Subversion Repositories configs

"""

Copyright 2008-2019 VMware, Inc.  All rights reserved. -- VMware Confidential

VMware VMX component installer.

"""

GCONF_DEFAULTS = 'xml:readwrite:/etc/gconf/gconf.xml.defaults'

DEST = LIBDIR/'vmware'

CONFIG = DEST/'setup/vmware-config'

CUPSLIBDIR = LIBDIR/'cups'

SETTINGS = \

    {'libdir': DEST,

     'bindir': BINDIR,

     'initscriptdir': INITSCRIPTDIR,

     'gksu.rootMethod': 'sudo' if 'SUDO_USER' in ENV else 'su',

     'NETWORKING': 'yes',

     'VMBLOCK_CONFED': 'yes',

     'VMCI_CONFED': 'yes',

     'VSOCK_CONFED': 'yes',

     'authd.fullpath': SBINDIR/'vmware-authd',

    }

vmwareSentinel = '# Automatically generated by the VMware Installer - DO NOT REMOVE\n'

MIN_NESTED_TOOLS_VERSION = '8.9.0'

MIN_EQUIVALENT_KERNEL_VERSION = (3, 9)

# Present requirement is a RHEL6-like environment.

MIN_GLIBC_VERSION = (2, 12)

MIN_KERNEL_VERSION = (2, 6, 32)

# Player and Workstation both depend on some configuration living

# in /etc/vmware

ETCDIR = Destination('/etc/vmware')

class VMX(Installer):

   def InitializeQuestions(self, old, new, upgrade):

      self.AddQuestion('ClosePrograms', key='ClosePrograms', text='',

                       required=True, default='Yes', level='REQUIRED')

      # Check whether we're in a VM or on real hardware.  If we're in a VM, verify that the

      # proper version of Tools is already installed.

      self.inVM = False

      self.checkVMTempFile = self.GetFilePath('extra/checkvm')

      # Get the directory above our installer and write checkvm to it so we can run it

      tmpdir = path(ENV['VMWARE_INSTALLER']).dirname().dirname()

      self.checkvmBin = tmpdir/'checkvm'

      path(self.checkVMTempFile).copy(self.checkvmBin)

      self.checkvmBin.chmod(0o755)

      path(self.checkVMTempFile).remove()

      # Check the environment for forceInstallInVM.  This check is here in InitializeQuestions

      # because it is run before InitializeInstall, where this variable is also used.

      self.forceInstallInVM = False

      try:

         txt = ENV['VMWARE_FORCE_INSTALL_IN_VM']

         if txt == 'yes':

            self.forceInstallInVM = True

      except KeyError:

         pass # Okay if it hasn't been set

      ret = self.RunCommand(self.checkvmBin, ignoreErrors=True)

      if ret.retCode == 0:

         # We are running in a virtual machine, don't install VSock and VMCI

         log.Info('Running inside a virtual machine!')

         self.inVM = True

         if self.forceInstallInVM:

            log.Info('But forcing install as if we are not.')

            self.inVM = False

         if self.inVM:

            # Now we need to check if Tools is installed.  If they are, we need to see if

            # they are a recent enough version to make this work.  If they aren't, then

            # notify the user that they are out of luck and must upgrade to a newer version

            # of Tools.

            minVersion = MIN_NESTED_TOOLS_VERSION

            toolsVersion = self.getToolsVersion()

            if not self.forceInstallInVM: # Only check if they haven't been overridden

               if not toolsVersion:

                  # vmci & vsock is upstreamed since kernel 3.9, and kernel 3.9 doesn't

                  # need vmblock. So, in a distro with kernel later than 3.9, even if

                  # there's no entire vmware tools, driver version is also acceptable.

                  kernelVersion = self.getHostKernelVersion()

                  if self.isVersionOkay(kernelVersion, MIN_EQUIVALENT_KERNEL_VERSION):

                     log.Info('Kernel version is acceptable.')

                  else:

                     log.Info('Kernel version is too old. Related modules will be configured.')

                     msg = 'You are installing inside a virtual machine. It is' \

                           ' recommended that you should install at least version' \

                           ' %s of VMware Tools before installing this product.' \

                           ' This product will work without VMware Tools, but if' \

                           ' you choose to install VMware Tools after installing' \

                           ' this product, the two products may not work together.' \

                           % minVersion

                     log.Warn(msg)

                     self.UserMessage ('Warning: %s' % msg)

                     self.inVM = False

               elif not self.isToolsVersionOkay(toolsVersion, minVersion):

                  self.UserMessage('You must have at least version %s of VMware' % minVersion + \

                                   ' Tools installed to install this product inside a virtual machine.' + \

                                   ' Your version is %s.  Please update VMware Tools.' % toolsVersion)

                  raise Exception('Tools version %s is too low to install inside a VM.')

      elif ret.retCode == 1:

         # We are on normal hardware.

         log.Info('Running on a real machine!')

         self.inVM = False

      else:

         log.Warn('Something went wrong detecting whether we are in a VM or not.  Assuming we are not.')

         self.inVM = False

   def InitializeInstall(self, old, new, upgrade):

      if self._checkXenPresence():

         log.Warn('This system is running a Xen kernel. You cannot run VMs under the Xen kernel.')

      if path('/dev/kvm').exists():

         log.Warn('This system has KVM enabled. You cannot run VMs with KVM enabled.')

      self.AddTarget('File', 'bin/*', BINDIR)

      self.AddTarget('File', 'sbin/*', SBINDIR)

      self.AddTarget('File', 'lib/*', DEST)

      self.AddTarget('File', 'roms/*', DEST/'roms')

      self.AddTarget('File', 'etc/init.d/vmware', SYSCONFDIR/'init.d/vmware')

      # Install the proper modules.xml file depending on whether we're installing on a real

      # machine or inside a VM

      if not self.inVM or self.forceInstallInVM:

         self.AddTarget('File', 'extra/modules.xml', DEST/'modules/modules.xml')

      else:

         # Use the nested VM modules.xml file and mark modules that Tools provides as unconfigured

         # so Modconfig doesn't try to rebuild them and the init script doesn't try to manage them

         self.AddTarget('File', 'extra/modules.nestedVM.xml', DEST/'modules/modules.xml')

         SETTINGS['VMCI_CONFED'] = 'no'

         SETTINGS['VSOCK_CONFED'] = 'no'

         SETTINGS['VMBLOCK_CONFED'] = 'no'

      # Symlink all binaries to appLoader.

      for i in ('vmware-modconfig', 'vmware-modconfig-console',

                'vmware-gksu', 'vmware-vmblock-fuse'):

        self.AddTarget('Link', DEST/'bin/appLoader', DEST/'bin'/i)

      self.SetPermission(DEST/'bin/*', BINARY)

      self.SetPermission(SYSCONFDIR/'init.d/vmware', BINARY)

      self.SetPermission(DEST/'bin/vmware-vmx*', SETUID)

      self.SetPermission(DEST/'lib/libvmware-gksu.so/gksu-run-helper', BINARY)

      self.SetPermission(SBINDIR/'vmware-authd', SETUID)

      # modprobe.d script.  Only install this on systems where modprobe.d

      # exists.

      if path('/etc/modprobe.d').exists():

         self.AddTarget('File', 'etc/modprobe.d/modprobe-vmware-fuse.conf',

                        '/etc/modprobe.d/vmware-fuse.conf')

      # Add a link for internationalization directory

      self.AddTarget('Link', DEST/'icu', SYSCONFDIR/'vmware/icu')

   def PreTransactionUninstall(self, old, new, upgrade):

      self.AddQuestion('ClosePrograms', key='ClosePrograms', text='',

                       required=True, default='Yes', level='REQUIRED')

   def PreInstall(self, old, new, upgrade):

      # Remove all modules in case some were left behind somehow.  For

      # example, the installation database could have been blown away.

      ret, kvers, _ = self.RunCommand('uname', '-r')

      kvers = kvers.strip()

      modules = ('vmmon', 'vmnet')

      if not self.inVM:

         modules = modules + ('vmblock', 'vmci', 'vsock')

      base = path('/lib/modules/%s/misc' % kvers)

      for module in modules:

         for ext in ('o', 'ko'):

            mod = '%s.%s' % (module, ext)

            (base/mod).remove(ignore_errors=True)

   def PreUninstall(self, old, new, upgrade):

      script = INITSCRIPTDIR/'vmware'

      # Stop and deconfigure services

      if ENV.get('VMWARE_SKIP_SERVICES'):

         log.Info('Skipping stopping services')

      elif INITSCRIPTDIR and self._scriptRunnable(script) and self.RunCommand(script, 'stop', ignoreErrors=True).retCode != 0:

         log.Error('Unable to stop VMware services')

      # Deconfigure services

      inits = self.LoadInclude('initscript')

      inits.DeconfigureService('vmware')

      # This must be the last thing done since the actions above may

      # depend on it.

      for key in list(SETTINGS.keys()):

         self.RunCommand(CONFIG, '-d', key)

      # Remove prelink appLoader exclusion.

      self._configurePrelink(False)

   def PostUninstall(self, old, new, upgrade):

      # Modules have been removed during uninstall.  We need to be sure to

      # run depmod to pick up that change.  Don't fail if for some reason

      # depmod can't be executed though.

      self.RunCommand('depmod', '-a', ignoreErrors=True)

   def PostInstall(self, old, new, upgrade):

      for key, val in list(SETTINGS.items()):

         self.RunCommand(CONFIG, '-s', key, val)

      bootstrap = ETCDIR/'bootstrap'

      # Create the bootstrap file.

      bootstrap.unlink(ignore_errors=True)

      # Fill it.

      for i in ('PREFIX', 'BINDIR', 'SBINDIR', 'LIBDIR', 'DATADIR',

                'SYSCONFDIR', 'DOCDIR', 'MANDIR', 'INCLUDEDIR', 'INITDIR',

                'INITSCRIPTDIR'):

         bootstrap.write_text('%s="%s"\n' % (i, globals()[i]), append=True)

      # Register it.

      # XXX: Skip registration for this change.  Allow the installer to handle

      # deletion.  A later change will correct this.

      # self.RegisterFile(bootstrap, fileType='ConfigFile')

      # Configure Gtk+.

      # @todo: make it its own component

      libconf = DEST/'libconf'

      replace = libconf/'etc/gtk-3.0/gdk-pixbuf.loaders'

      template = '@@LIBCONF_DIR@@'

      self.RunCommand('sed', '-e', 's,%s,%s,g' % (template, libconf),

                      '-i', replace)

      # Add prelink appLoader exclusion.

      self._configurePrelink(True)

      # Set up virtual networking

      self._configureNetworking(old, new)

      # Set up the vmware service script

      inits = self.LoadInclude('initscript')

      inits.ConfigureService('vmware',

                             'This service starts and stops VMware services',

                             '$network $syslog', # Start

                             '$network $syslog', # Stop

                             '',

                             '',

                             19,

                             8)

      # Make sure to start services

      script = INITSCRIPTDIR/'vmware'

      if INITSCRIPTDIR and script.exists():

         self.RunCommand(script, 'stop', ignoreErrors=True)

         self.RunCommand(script, 'start')

      # If no INITDIR was given, notify the user that the vmware service must

      # be manually set up

      if not INITDIR:

         self.UserMessage('No rc*.d style init script directories were given to the installer. '

                          'You must manually add the necessary links to ensure that the vmware '

                          'service at %s is automatically started and stopped on startup and shutdown.' % str(INITSCRIPTDIR/'vmware'))

   def _scriptRunnable(self, script):

      """ Returns True if the script exists and is in a runnable state """

      return script.isexe() and script.isfile() and self.RunCommand(script, 'validate').retCode == 100

   def _AddLineToFile(self, fil, text, addToEnd=True):

      """

      Add a line/consecutive lines to a file, surrounded by the VMware Sentinel.

      ### This method only adds a single line to a file ###

      ### You cannot make more than one modification per file ###

      @param fil: The file name.  Either a string or path object

      @param text: The text to add.  This function appends a \n

      @param addToEnd: Add to the end of the file?  If false, to the beginning.

      @return: True on successful modification, False if the file did not exist.

      """

      fil = path(fil) # Make sure it's a path object

      if fil.exists():

         txt = fil.text()

         # Modify the text

         if addToEnd:

            txt = ''.join([txt, vmwareSentinel, text, '\n', vmwareSentinel])

         else:

            txt = ''.join([vmwareSentinel, text, '\n', vmwareSentinel, txt])

         # Write it back to the file

         fil.write_text(txt)

         return True

      else:

         log.Info('Attempted to modify file %s, does not exist.' % fil)

         return False

   def _RemoveLineFromFile(self, fil):

      """

      Remove a line bracketed by the VMware Sentinel

      @param fil: The file name.  Either a string or path object

      @return: True on successful modification, False if the file did not exist.

      """

      fil = path(fil) # Make sure it's a path object

      if fil.exists():

         txt = fil.text()

         m = re.sub(vmwareSentinel + '.*\n' + vmwareSentinel,

                    '', txt, re.DOTALL)

         fil.write_text(m)

         return True

      else:

         log.Info('Attempted to modify file %s, does not exist.' % fil)

         return False

   def _configurePrelink(self, enable):

      """

      Configures prelinking by adding appLoader exclusion.

      @param enable: True if to add exclusion, False if to remove it.

      """

      prelink = path('/etc/prelink.conf')

      if prelink.exists():

         # XXX: It would probably be good to refactor this into some

         # sort of helper function that can add and remove lines from

         # files.

         skipPrelink = [ '# appLoader will segfault if prelinked.',

                         '-b %s' % (DEST/'bin/appLoader') ]

         lines = prelink.lines(encoding='utf-8', retain=False)

         # Strip whitespace from lines so that trailing whitespace

         # won't impact matching lines.

         lines = [line.strip() for line in lines]

         if enable:

            if skipPrelink[-1] not in lines:

               lines += skipPrelink

               log.Info('Added appLoader prelink exclusion to %s.', prelink)

            else:

               log.Warn('appLoader skip prelinking already present.')

         else:

            found = False

            for line in skipPrelink:

               if line in lines:

                  found = True

                  lines.remove(line)

            if found:

               log.Info('Removed appLoader prelink exclusion from %s.', prelink)

         # XXX: This can technically fail.  Actually, there are a

         # whole host of things that can fail in this function.  On

         # one hand we would like to catch errors and correct them

         # while being fairly resilient at installation time.

         #

         # One option might be to have a @failok decoration for things

         # that can fail loudly for internal builds but do not cause

         # installations to fail in release builds.

         prelink.write_lines(lines, encoding='utf-8')

      else:

         log.Info('Prelink not present, skipping configuration.')

   def _validate_cpu_flags(self, reqFlags):

      """

      Checks to ensure that every CPU on the given machine has all the

      flags passed in the reqFlags list.

      @param: A list of the flags that must be present.

      @returns: True on all necessary flags present, False othewise.

      """

      flagSec = False

      cpuInfoFile = '/proc/cpuinfo'

      try:

         cpuInfo = open(cpuInfoFile, mode='r')

         for line in cpuInfo:

            if line.startswith('flags'):

               flagSec = True

               flagsFound = line.split(' ')

               for flag in reqFlags:

                  if flag not in flagsFound:

                     return False

         return flagSec

      except IOError:

         raise Exception('Could not open %s' % (cpuInfoFile))

      finally:

         if cpuInfo:

            cpuInfo.close()

   def PreTransactionInstall(self, old, new, upgrade):

      if ENV.get('VMWARE_SKIP_VERSION_CHECKS'):

         return  # skip all checks

      # CPU flags check

      # TODO: also check for vt / ept / (AMD equivalent)

      reqFlags = ['lm']

      cpuOk = self._validate_cpu_flags(reqFlags)

      kernelOk = self.isVersionOkay(self.getHostKernelVersion(),

                                    MIN_KERNEL_VERSION)

      glibcOk = self.isVersionOkay(self.getHostGlibcVersion(),

                                   MIN_GLIBC_VERSION)

      if not cpuOk:

         self.UserMessage('One or more of your processors does not have the '

                          'necessary 64bit extensions to run VMware '

                          'virtual machines.')

      if not kernelOk:

         self.UserMessage('The Linux kernel version on this system is '

                          'insufficient for running VMware virtual machines. '

                          'Linux kernel version %s or later is required.'

                          % str(MIN_KERNEL_VERSION))

      if not glibcOk:

         self.UserMessage('The glibc library version on this system is '

                          'insufficient for running VMware virtual machines. '

                          'Glibc library version %s or later is required.'

                          % str(MIN_GLIBC_VERSION))

      if not cpuOk or not glibcOk or not kernelOk:

         raise Exception('Host not supported by this product.')

   def PostTransactionInstall(self, old, new, upgrade):

      # Build modules with modconfig.  This can't happen during the other install

      # phases because VMIS has locked the database and modconfig invokes another

      # version of VMIS to register the compiled modules.

      if ENV.get('VMWARE_SKIP_MODULES'):

         log.Info('Skipping kernel module installation')

      else:

         # run depmod -a before modconfig in case we are upgrading from a version

         # that did not properly do this after uninstalling modules. modconfig

         # uses modules.dep to determine upstream status of modules, therefore

         # it might get confused if modules.dep is not up-to-date.

         self.RunCommand('depmod', '-a', ignoreErrors=True)

         ret = self.RunCommand(BINDIR/'vmware-modconfig', '--console', '--install-all')

         if ret.retCode == 0:

            log.Info('Successfully installed kernel modules')

         else:

            log.Info('Unable to install kernel modules')

            log.Info('stdout: %s' % ret.stdout)

            log.Info('stderr: %s' % ret.stderr)

   def _checkXenPresence(self):

      """

      Checks whether this install is within a Xen domain,

      that is running on a Xen kernel.  Returns True if so.

      """

      xenTest = path('/proc/xen/capabilities')

      return xenTest.exists() and len(xenTest.text())

   def _escape(self, string):

      """ Escapes a string for use in a shell context """

      # XXX: Borrowed from util/shell.py: Escape.  Break that into a component-side

      # include file and remove this method once that's done.

      return "'%s'" % string.replace("'", '"\'"')

   def _configureNetworking(self, old, new):

      if 'VMWARE_SKIP_NETWORKING' in ENV:

         return

      vnetlib = BINDIR/'vmware-networks'

      backup = ENV.get('VMWARE_RESTORE_NETWORKING')

      backup = backup and path(backup)

      locations = ENV.get('VMWARE_MIGRATE_NETWORKING')

      locations = locations and path(locations)

      if backup and backup.owner == 'root':

         log.Info('Restoring previous network settings from %s', backup)

         backup.copy('/etc/vmware/networking')

         backup.remove()

         old = 1

      elif locations and locations.owner == 'root' and not old:

         log.Info('Migrating old network settings from %s', locations)

         if self.RunCommand(vnetlib, '--migrate-network-settings', locations, ignoreErrors=True).retCode == 0:

            locations.remove()

            return True

         else:

            log.Info('Migrating network settings failed, forcing new network settings')

            old = 0

            new = 1

      # old might be None so make it 0 for the purposes of vnetlib.

      old = old or 0

      return self.RunCommand(vnetlib, '--postinstall', '%s,%s,%s' % ('vmware-player', old, new),

                             ignoreErrors=True).retCode == 0

   def getToolsVersion(self):

      toolboxCmd = path('/usr/bin/vmware-toolbox-cmd')

      toolbox = path('/usr/bin/vmware-toolbox')

      ret = None

      if toolboxCmd:

         ret = self.RunCommand(toolboxCmd, '--version', ignoreErrors=True)

      elif toolbox:

         ret = self.RunCommand(toolbox, '--version', ignoreErrors=True)

      else:

         # Cannot find Tools version...

         return None

      if ret and ret.retCode == 0:

         toolsVersion = ret.stdout

         # Parse it

         toolsVersion = re.findall('\d+\.\d+\.\d+', toolsVersion)

         if toolsVersion:

            toolsVersion = toolsVersion[0]

            log.Info('Found Tools version %s' % toolsVersion)

            return toolsVersion

         else:

            # Something went wrong in the process...  No Tools version found...

            return None

      else:

         return None

   def isToolsVersionOkay(self, version, minVersion):

      if not version:

         return False

      versions = self.LoadInclude('versions')

      if versions.CompareVersionString(version, minVersion) >= 0:

         log.Info('Tools version is compatible.')

         return True

      else:

         log.Info('Tools version is too old.')

         return False

   def getHostGlibcVersion(self):

      """Return host's glibc version as a tuple."""

      try:

         import subprocess

         out = subprocess.check_output(["ldd", "--version"]).decode()

         brand = out.split('\n', 1)[0]

      except subprocess.CalledProcessError:

         log.Info('Unable to query glibc version.')

         return None

      # brand = full ldd brand string, e.g. 'ldd (Distro GLIBC N.NN) 2.17'

      log.Info('Glibc brand string ' + brand)

      try:

          # versionStr = glibc version, e.g. '2.17'

          versionStr = brand.split(' ')[-1]

          glibcVersion = tuple([int(x) for x in versionStr.split(".")])

          log.Info('Found glibc version ' + str(glibcVersion))

          return glibcVersion

      except Exception as e:

          log.Info('Unable to parse glibc version: ' + str(e))

          return None

   def getHostKernelVersion(self):

      """Return host's kernel version as a tuple."""

      import platform

      # releaseStr = full kernel version, e.g. '3.10.0-327.el7.x86_64'

      releaseStr = platform.release()

      log.Info('Kernel release string ' + releaseStr)

      # versionStr = kernel numeric version, e.g. '3.10.0'

      try:

          versionStr = releaseStr.split("-")[0]

          kernelVersion = tuple([int(x) for x in versionStr.split(".")])

          log.Info('Found Linux kernel version ' + str(kernelVersion))

          return kernelVersion

      except Exception as e:

          log.Info('Unable to parse kernel version: ' + str(e))

          return None

   def isVersionOkay(self, version, minVersion):

      if not version:

         return True  # Do not error out on parse failure

      elif version < minVersion:

         return False

      else:

         return True