From 416ab8a37f1b07dc9f6c0fb3ff1a8ff2036510b5 Mon Sep 17 00:00:00 2001 From: Sebastian Schmelzer Date: Thu, 2 Sep 2010 17:50:49 +0200 Subject: change dir structure --- .../plugins/vmware/OpenSLX/OSPlugin/vmware.pm | 836 +++++++++++++++++++++ 1 file changed, 836 insertions(+) create mode 100644 src/os-plugins/plugins/vmware/OpenSLX/OSPlugin/vmware.pm (limited to 'src/os-plugins/plugins/vmware/OpenSLX/OSPlugin') diff --git a/src/os-plugins/plugins/vmware/OpenSLX/OSPlugin/vmware.pm b/src/os-plugins/plugins/vmware/OpenSLX/OSPlugin/vmware.pm new file mode 100644 index 00000000..7e55019c --- /dev/null +++ b/src/os-plugins/plugins/vmware/OpenSLX/OSPlugin/vmware.pm @@ -0,0 +1,836 @@ +# Copyright (c) 2008..2010 - OpenSLX GmbH +# +# This program is free software distributed under the GPL version 2. +# See http://openslx.org/COPYING +# +# If you have any feedback please consult http://openslx.org/feedback and +# send your suggestions, praise, or complaints to feedback@openslx.org +# +# General information about OpenSLX can be found at http://openslx.org/ +# ----------------------------------------------------------------------------- +# vmware.pm +# - declares necessary information for the vmware plugin +# ----------------------------------------------------------------------------- +package OpenSLX::OSPlugin::vmware; + +use strict; +use warnings; + +use base qw(OpenSLX::OSPlugin::Base); + +use File::Basename; +use File::Path; + +use OpenSLX::Basics; +use OpenSLX::Utils; +use OpenSLX::DistroUtils; + +sub new +{ + my $class = shift; + + my $self = { + name => 'vmware', + }; + + return bless $self, $class; +} + +sub getInfo +{ + my $self = shift; + + return { + description => unshiftHereDoc(<<' End-of-Here'), + Module for enabling services of VMware Inc. on an OpenSLX stateless + client. This plugin might use pre-existing installations of VMware + tools or install addional variants and versions. + End-of-Here + precedence => 70, + required => [ qw( desktop ) ], + }; +} + +sub getAttrInfo +{ + # returns a hash-ref with information about all attributes supported + # by this specific plugin + my $self = shift; + + # This default configuration will be added as attributes to the default + # system, such that it can be overruled for any specific system by means + # of slxconfig. + return { + # attribute 'active' is mandatory for all plugins + 'vmware::active' => { + applies_to_systems => 1, + applies_to_clients => 1, + description => unshiftHereDoc(<<' End-of-Here'), + should the 'vmware'-plugin be executed during boot? + End-of-Here + content_regex => qr{^(0|1)$}, + content_descr => '1 means active - 0 means inactive', + default => '1', + }, + # attribute 'imagesrc' defines where we can find vmware images + 'vmware::imagesrc' => { + applies_to_systems => 1, + applies_to_clients => 1, + description => unshiftHereDoc(<<' End-of-Here'), + Where do we store our vmware images? NFS? Filesystem? + End-of-Here + #TODO: check if the input is valid + #content_regex => qr{^(0|1)$}, + content_descr => 'Allowed values: path or URI', + default => '', + }, + # attribute 'bridge' defines if bridged network mode should be + # switched on + 'vmware::bridge' => { + applies_to_systems => 1, + applies_to_clients => 1, + description => unshiftHereDoc(<<' End-of-Here'), + Should the bridging (direct access of the vmware clients + to the ethernet the host is connected to) be enabled + End-of-Here + content_regex => qr{^(0|1)$}, + content_descr => 'Allowed values: 0 or 1', + default => '1', + }, + # attribute 'vmnet1' defines if the host connection network mode + # should be switched on and NAT should be enabled + 'vmware::vmnet1' => { + applies_to_systems => 1, + applies_to_clients => 1, + description => unshiftHereDoc(<<' End-of-Here'), + Format ServerIP/Netprefix without NAT + Format ServerIP/Netprefix,NAT enables NAT/Masquerading + End-of-Here + #TODO: check if the input is valid + #content_regex => qr{^(0|1)$}, + content_descr => 'Allowed value: IP/Prefix[,NAT]', + default => '192.168.101.1/24,NAT', + }, + # attribute 'vmnet8' defines if vmware specific NATed network mode + # should be switched on + 'vmware::vmnet8' => { + applies_to_systems => 1, + applies_to_clients => 1, + description => unshiftHereDoc(<<' End-of-Here'), + Format ServerIP/Netprefix. Last octet will be omitted + End-of-Here + #TODO: check if the input is valid + #content_regex => qr{^(0|1)$}, + content_descr => 'Allowed value: IP/Prefix. Last octet will be omitted', + default => '192.168.102.x/24', + }, + # attribute 'kind' defines which set of VMware binaries should be + # activated ('local' provided with the main installation set). + 'vmware::kind' => { + applies_to_vendor_os => 0, + applies_to_systems => 1, + applies_to_clients => 1, + description => unshiftHereDoc(<<' End-of-Here'), + Which set of VMware binaries to use: installed (local) or provided by the + plugin itself (vmpl1.0, vmpl2.0, vmpl2.5, vmpl3.X)? + End-of-Here + # only allow the supported once... + # TODO: modify if we know which of them work + #content_regex => qr{^(local|vmws(5\.5|6.0)|vmpl(1\.0|2\.0))$}, + content_regex => qr{^(local|vmpl3\.0||vmpl2\.0|vmpl1\.0|vmpl2\.5)$}, + content_descr => 'Allowed values: local, vmpl2.0', + #TODO: what if we don't have a local installation. default + # is still local. Someone has a clue how to test + # it and change the default value? + default => 'local', + }, + ## + ## only stage1 setup options: different kinds to setup + 'vmware::local' => { + applies_to_vendor_os => 1, + applies_to_system => 0, + applies_to_clients => 0, + description => unshiftHereDoc(<<' End-of-Here'), + Set's up stage1 configuration for a local installed + vmplayer or vmware workstation + End-of-Here + content_regex => qr{^(1|0)$}, + content_descr => '1 means active - 0 means inactive', + default => '1', + }, + 'vmware::vmpl2.0' => { + applies_to_vendor_os => 1, + applies_to_system => 0, + applies_to_clients => 0, + description => unshiftHereDoc(<<' End-of-Here'), + Install and configure vmplayer v2 + End-of-Here + content_regex => qr{^(1|0)$}, + content_descr => '1 means active - 0 means inactive', + default => '0', + }, + 'vmware::vmpl2.5' => { + applies_to_vendor_os => 1, + applies_to_system => 0, + applies_to_clients => 0, + description => unshiftHereDoc(<<' End-of-Here'), + Install and configure vmplayer v2 + End-of-Here + content_regex => qr{^(1|0)$}, + content_descr => '1 means active - 0 means inactive', + default => '0', + }, + 'vmware::vmpl1.0' => { + applies_to_vendor_os => 1, + applies_to_system => 0, + applies_to_clients => 0, + description => unshiftHereDoc(<<' End-of-Here'), + Install and configure vmplayer v1 + End-of-Here + content_regex => qr{^(1|0)$}, + content_descr => '1 means active - 0 means inactive', + default => '0', + }, + 'vmware::pkgpath' => { + applies_to_vendor_os => 1, + applies_to_system => 0, + applies_to_clients => 0, + description => unshiftHereDoc(<<' End-of-Here'), + Path to VMware packages + End-of-Here + #TODO + #content_regex => qr{^(1|0)$}, + content_descr => '1 means active - 0 means inactive', + default => '/root/vmware-pkgs', + }, + # ** set of attributes for the installation of VM Workstation/Player + # versions. More than one package could be installed in parallel. + # To be matched to/triggerd by 'vmware::kind' + }; +} + + +sub preInstallationPhase() +{ + my $self = shift; + my $info = shift; + + $self->{pluginRepositoryPath} = $info->{'plugin-repo-path'}; + $self->{pluginTempPath} = $info->{'plugin-temp-path'}; + $self->{openslxBasePath} = $info->{'openslx-base-path'}; + $self->{openslxConfigPath} = $info->{'openslx-config-path'}; + $self->{attrs} = $info->{'plugin-attrs'}; + $self->{vendorOsPath} = $info->{'vendor-os-path'}; + + my $pkgpath = $self->{attrs}->{'vmware::pkgpath'}; + my $vmpl10 = $self->{attrs}->{'vmware::vmpl1.0'}; + my $vmpl20 = $self->{attrs}->{'vmware::vmpl2.0'}; + my $vmpl25 = $self->{attrs}->{'vmware::vmpl2.5'}; + my $local = $self->{attrs}->{'vmware::local'}; + + if ($local == 0 && $vmpl10 == 0 && $vmpl20 == 0 && $vmpl25 == 0) { + print "\n\n * At least one kind needs to get installed/activated:\n"; + print " vmware::local=1 or\n"; + print " vmware::vmpl1.0=1 or\n"; + print " vmware::vmpl2.0=1\n"; + print " vmware::vmpl2.5=1\n"; + print " * vmware plugin was not installed!\n\n"; + exit 1; + } + + if (! -d $pkgpath && ($vmpl10 == 1 || $vmpl20 == 1 || $vmpl25 == 1)) { + print "\n\n * vmware::pkgpath: no such directory $pkgpath!\n"; + print " See wiki about vmware Plugin\n"; + print " * vmware plugin was not installed!\n\n"; + exit 1; + } + + # test just for the case we only set up local vmware + if (-d $pkgpath && ($vmpl10 == 1 || $vmpl20 == 1 || $vmpl25 == 1)) { + # todo: ask oliver about a similiar function + # like copyFile() just for directorys + # or fix the manual after checked the source of + # copyFile() function. check if copyFile etc. perldoc + # is somewhere in the wiki documented else do it! + system("cp -r $pkgpath $self->{pluginRepositoryPath}/packages"); + } +} + +sub installationPhase +{ + my $self = shift; + my $info = shift; + + $self->{pluginRepositoryPath} = $info->{'plugin-repo-path'}; + $self->{pluginTempPath} = $info->{'plugin-temp-path'}; + $self->{openslxBasePath} = $info->{'openslx-base-path'}; + $self->{openslxConfigPath} = $info->{'openslx-config-path'}; + $self->{attrs} = $info->{'plugin-attrs'}; + + # copy common part of run-virt.include to the appropriate place for + # inclusion in stage4 + copyFile("$self->{openslxBasePath}/lib/plugins/vmware/files/run-virt.include", + "$self->{pluginRepositoryPath}/"); + + # kinds we will configure and install + # TODO: write a list of installed/setted up and check it in stage3 + # this will avoid conflict of configured vmware version in + # stage3 which are not setted up or installed in stage1 + if ($self->{attrs}->{'vmware::local'} == 1) { + $self->_localInstallation(); + } + if ($self->{attrs}->{'vmware::vmpl2.0'} == 1) { + $self->_vmpl2Installation(); + } + if ($self->{attrs}->{'vmware::vmpl1.0'} == 1) { + $self->_vmpl1Installation(); + } + if ($self->{attrs}->{'vmware::vmpl2.5'} == 1) { + $self->_vmpl25Installation(); + } + + ## prepration for our faster wrapper script + # rename the default vmplayer script and create a link. + # uninstall routine takes care about plugin remove. + # stage3 copys our own wrapper script + if (-e "/usr/bin/vmplayer" && ! -e "/usr/bin/vmplayer.slx-back") { + rename("/usr/bin/vmplayer", "/usr/bin/vmplayer.slx-bak"); + } + # the same with vmware, if ws is installed + if (-e "/usr/bin/vmware" && ! -e "/usr/bin/vmware.slx-bak") { + rename("/usr/bin/vmware", "/usr/bin/vmware.slx-bak"); + } + +} + +sub removalPhase +{ + my $self = shift; + my $info = shift; + + # restore old start scripts - to be discussed + my @files = qw( vmware vmplayer ); + foreach my $file (@files) { + if (-e "/usr/bin/$file.slx-bak") { + unlink("/usr/bin/$file"); + rename("/usr/bin/$file.slx-bak", "/usr/bin/$file"); + } + } + return; +} + +sub checkStage3AttrValues +{ + my $self = shift; + my $stage3Attrs = shift; + my $vendorOSAttrs = shift; + my @problems; + + my $vm_kind = $stage3Attrs->{'vmware::kind'} || ''; + my $vmimg = $stage3Attrs->{'vmware::imagesrc'} || ''; + + if ($vm_kind eq 'local' && ! -x "/usr/lib/vmware/bin/vmplayer") { + push @problems, _tr( + "No local executeable installation of vmware found! Using it as virtual machine wouldn't work!" + ); + } + + if ($vm_kind eq 'local' && + ! -d "/opt/openslx/plugin-repo/vmware/local") { + push @problems, _tr( + "local vmware installation not configured by slxos-plugin!" + ); + } + + if ($vm_kind eq 'vmpl1.0' && + ! -d "/opt/openslx/plugin-repo/vmware/vmpl1.0/vmroot") { + push @problems, _tr( + "No OpenSLX installation of VMware Player 1 found or installation failed. Using it as virtual machine wouldn't work!" + ); + } + + if ($vm_kind eq 'vmpl2.0' && + ! -d "/opt/openslx/plugin-repo/vmware/vmpl2.0/vmroot") { + push @problems, _tr( + "No OpenSLX installation of VMware Player 2.0 found or installation failed. Using it as virtual machine wouldn't work!" + ); + } + + if ($vm_kind eq 'vmpl2.5' && + ! -d "/opt/openslx/plugin-repo/vmware/vmpl2.5/vmroot") { + push @problems, _tr( + "No OpenSLX installation of VMware Player 2.5 found or installation failed. Using it as virtual machine wouldn't work!" + ); + } + + if ($vm_kind eq 'vmpl3.X' && + ! -d "/opt/openslx/plugin-repo/vmware/vmpl3.X/vmroot") { + push @problems, _tr( + "No OpenSLX installation of VMware Player 3.X found or installation failed. Using it as virtual machine wouldn't work!" + ); + } + + return if !@problems; + + return \@problems; +} + + +####################################### +## local, non-general OpenSLX functions +####################################### + +# Write the runlevelscript +# usage: _writeRunlevelScript("$vmpath", "$kind") +sub _writeRunlevelScript +{ + my $self = shift; + my $vmpath = shift; + my $kind = shift; + my $initfile = newInitFile(); + + my $script = ""; + my $modpath = ""; + my $modlist = ""; + # vmpath is to be redefined here ... + if ($kind =~ /local*/) { + $vmpath = ""; + $modpath = "/lib/modules/\$(uname -r)/misc"; + } elsif ($kind =~ /vmpl*/) { + $vmpath = "/opt/openslx/plugin-repo/vmware/${kind}"; + $modpath = "${vmpath}/vmroot/modules"; + } + + $initfile->setName("vmware-slx"); + $initfile->setDesc("Setup environment for VMware Workstation or Player ($kind)."); + + # functions ... + $modlist = "vmnet vmmon"; + $script = unshiftHereDoc(<<" End-of-Here"); + # VMplayer common stuff + insmod ${modpath}/vmmon.ko || return 1 + insmod ${modpath}/vmnet.ko || return 1 + End-of-Here + if ($kind eq 'local3X' || $kind eq 'vmpl3.X') { + $script .= unshiftHereDoc(<<" End-of-Here"); + # VMplayer 3.X specific stuff + insmod ${modpath}/vmci.ko + insmod ${modpath}/vmblock.ko + insmod ${modpath}/vsock.ko + End-of-Here + $modlist .= "vsock vmci vmblock"; + } elsif ($kind eq 'local20' || $kind eq 'local25' || $kind eq 'vmpl2.0' || $kind eq 'vmpl2.5') { + $script .= unshiftHereDoc(<<" End-of-Here"); + # VMplayer 2.X specific stuff + insmod ${modpath}/vmblock.ko + End-of-Here + $modlist .= "vmblock"; + } + $initfile->addFunction( + "load_modules", + "$script" + ); + $initfile->addFunction( + "unload_modules", + "rmmod $modlist 2>/dev/null" + ); + # vmnet0,1,8 (bridge, nat, host-only) interface definition + $script = unshiftHereDoc(<<" End-of-Here"); + # let point the path directly to the directory where the binary lives + location="$vmpath/usr/bin" + if [ -n "\$vmnet0" ] ; then + # the path might be directly point to the plugin dir + End-of-Here + if ($kind eq 'vmpl1.0' || $kind eq 'vmpl2.0' || $kind eq 'local10' || $kind eq 'local20') { + $script .= " \$location/vmnet-bridge -d /var/run/vmnet-bridge-0.pid /dev/vmnet0 eth0\n"; + } else { + $script .= " \$location/vmnet-bridge -d /var/run/vmnet-bridge-0.pid -n 0\n"; + } + $script .= unshiftHereDoc(<<" End-of-Here"); + fi + if [ -n "\$vmnet1" ] ; then + \$location/vmnet-netifup -d /var/run/vmnet-netifup-vmnet1.pid \\ + /dev/vmnet1 vmnet1 + ip addr add \$vmnet1 dev vmnet1 + ip link set vmnet1 up + if [ -n "\$vmnet1nat" ] ; then + echo "1" >/proc/sys/net/ipv4/conf/vmnet1/forwarding 2>/dev/null + echo "1" >/proc/sys/net/ipv4/conf/br0/forwarding 2>/dev/null + #iptables -A -s vmnet1 -d br0 + fi + /opt/openslx/uclib-rootfs/usr/sbin/udhcpd \\ + -S /etc/vmware/udhcpd/udhcpd-vmnet1.conf + fi + if [ -n "\$vmnet8" ] ; then + \$location/vmnet-netifup -d /var/run/vmnet-netifup-vmnet8.pid \\ + /dev/vmnet8 vmnet8 + ip addr add \$vmnet8 dev vmnet8 + ip link set vmnet8 up + echo "1" >/proc/sys/net/ipv4/conf/vmnet8/forwarding 2>/dev/null + echo "1" >/proc/sys/net/ipv4/conf/br0/forwarding 2>/dev/null + iptables -t nat -A POSTROUTING -o br0 -j MASQUERADE + /opt/openslx/uclib-rootfs/usr/sbin/udhcpd \\ + -S /etc/vmware/udhcpd/udhcpd-vmnet8.conf + fi + End-of-Here + $initfile->addFunction( + "vmnetif", + "$script" + ); + # vmblock for handling e.g. removable USB devices + $script = unshiftHereDoc(<<" End-of-Here"); + # let point the path directly to the directory where the binary lives + $vmpath/usr/bin/vmware-usbarbitrator + End-of-Here + $initfile->addFunction( + "vmblock", + "$script" + ); + $script = unshiftHereDoc(<<" End-of-Here"); + # include default directories + . /etc/opt/openslx/openslx.conf + # load the configuration file + . \${OPENSLX_DEFAULT_CONFDIR}/plugins/vmware/vmware.conf + # hack to access the first serial/parallel port + chmod a+rw /dev/ttyS0 + chmod a+rw /dev/parport0 + load_modules + vmnetif + End-of-Here + # start the USB arbitrator on higher VMware/player versions (3.0+) + if ($kind eq 'vmpl3.X' || $kind eq 'local3X') { + $script .= unshiftHereDoc(<<" End-of-Here"); + vmblock + End-of-Here + } + $initfile->addToCase( + "start", + "$script" + ); + $script = unshiftHereDoc(<<" End-of-Here"); + killall vmnet-netifup vmnet-natd vmnet-bridge vmware vmplayer \\ + vmware-tray vmnet-dhcpd 2>/dev/null + # might take a while until all services are shut down + sleep 1 + unload_modules + End-of-Here + $initfile->addToCase( + "stop", + "$script" + ); + $initfile->addToCase( + "status", + "vmstatus" + ); + $initfile->addToCase( + "restart", + "\$0 stop && \$0 start" + ); + + my $distro = (split('-',$self->{'os-plugin-engine'}->distroName()))[0]; + my $runlevelscript = getInitFileForDistro($initfile, $distro); + # todo: because we dont have distribution or version dependend + # init scripts we could put it directly into /etc/init.d... + spitFile("$self->{'pluginRepositoryPath'}/vmware-slx", $runlevelscript); +} + + +# writes the wrapper script for vmware workstation and player, depending +# on the flag. If player: just player wrapper, if ws: ws+player wrapper +# usage: _writeWrapperScript("$vmpath", "$kind", "player") +# _writeWrapperScript("$vmpath", "$kind", "ws") +sub _writeWrapperScript +{ + my $self = shift; + my $vmpath = shift; + my $kind = shift; + my $type = shift; + my @files; + + if ("$type" eq "ws") { + @files = qw(vmware vmplayer); + } else { + @files = qw(vmplayer); + } + + foreach my $file (@files) { + # create our own simplified version of the vmware and player wrapper + # Depending on the configured kind it will be copied in stage3 + # because of tempfs of /var but not /usr we link the file + # to /var/..., where we can write in stage3 + my $script = unshiftHereDoc(<<" End-of-Here"); + #!/bin/sh + # written by OpenSLX-plugin 'vmware' in Stage1 + # radically simplified version of the original script $file by VMware Inc. + End-of-Here + + # kinda ugly and we only need it for local. Preserves errors + if ($kind ne "local") { + $script .= unshiftHereDoc(<<" End-of-Here"); + export LD_LIBRARY_PATH=$vmpath/lib + export GDK_PIXBUF_MODULE_FILE=$vmpath/libconf/etc/gtk-2.0/gdk-pixbuf.loaders + export GTK_IM_MODULE_FILE=$vmpath/libconf/etc/gtk-2.0/gtk.immodules + export FONTCONFIG_PATH=$vmpath/libconf/etc/fonts + export PANGO_RC_FILE=$vmpath/libconf/etc/pango/pangorc + # possible needed... but what are they good for? + #export GTK_DATA_PREFIX= + #export GTK_EXE_PREFIX= + #export GTK_PATH= + End-of-Here + } + + $script .= unshiftHereDoc(<<" End-of-Here"); + PREFIX=$vmpath # depends on the vmware location + exec "\$PREFIX"'/lib/wrapper-gtk24.sh' \\ + "\$PREFIX"'/lib' \\ + "\$PREFIX"'/bin/$file' \\ + "\$PREFIX"'/libconf' "\$@" + End-of-Here + + # TODO: check if these will be overwritten if we have more as + # local defined (add the version/type like vmpl1.0, vmws5.5, ...) + # then we have a lot of files easily distinguishable by there suffix + spitFile("$self->{'pluginRepositoryPath'}/$kind/$file", $script); + chmod 0755, "$self->{'pluginRepositoryPath'}/$kind/$file"; + } +} + +sub _writeVmwareConfigs { + my $self = shift; + my $kind = shift; + my $vmpath = shift; + my %versionhash = (vmversion => "", vmbuildversion => ""); + my $vmversion = ""; + my $vmbuildversion = ""; + my $config = ""; + + %versionhash = _getVersion($vmpath); + + $config .= "version=\"".$versionhash{vmversion}."\"\n"; + $config .= "buildversion=\"".$versionhash{vmbuildversion}."\"\n"; + spitFile("$self->{'pluginRepositoryPath'}/$kind/vmware.conf", $config); + chmod 0755, "$self->{'pluginRepositoryPath'}/$kind/vmware.conf"; + + $config = "libdir = \"$vmpath\"\n"; + spitFile("$self->{'pluginRepositoryPath'}/$kind/config", $config); + chmod 0755, "$self->{'pluginRepositoryPath'}/$kind/config"; +} + +sub _getVersion { + + my $vmpath = shift; + my $vmversion = ""; + my $vmbuildversion = ""; + my %versioninfo = (vmversion => "", vmbuildversion => ""); + + # get version information about installed vmplayer + if (open(FH, "$vmpath/bin/vmplayer")) { + $/ = undef; + my $data = ; + close FH; + # depending on the installation it could differ and has multiple build + # strings + if ($data =~ m{[^\d\.](\d\.\d) build-(\d+)}) { + $vmversion = $1; + $vmbuildversion = $2; + } + if ($data =~ m{\0(2\.[05])\.[0-9]}) { + $vmversion = $1; + } + # else { TODO: errorhandling if file or string doesn't exist } + chomp($vmversion); + chomp($vmbuildversion); + + + $versioninfo{vmversion} = $vmversion; + $versioninfo{vmbuildversion} = $vmbuildversion; + } + return %versioninfo; +} + +######################################################################## +## Functions, which setup the different environments (local, ws-v(5.5|6), +## player-v(1|2) +## Seperation makes this file more readable. Has a bigger benefit as +## one big copy function. Makes integration of new versions easier. +######################################################################## + +# local installation +sub _localInstallation +{ + my $self = shift; + + my $kind = "local"; + my $vmpath = "/usr/lib/vmware"; + my $vmbin = "/usr/bin"; + my %versionhash = (vmversion => "", vmbuildversion => ""); + my $vmversion = ""; + my $vmbuildversion = ""; + + # if vmware ws is installed, vmplayer is installed, too. + # we will only use vmplayer + if (-e "/usr/lib/vmware/bin/vmplayer") { + + ## Get and write version information + %versionhash = _getVersion($vmpath); + $vmversion = $versionhash{vmversion}; + $vmbuildversion = $versionhash{vmbuildversion}; + + # set version information + # VMplayer 2.0 + if ($vmversion eq "2.0" || $vmversion eq "6.0") { + $kind="local20"; + # VMplayer 2.5 + } elsif ($vmversion eq "2.5" || $vmversion eq "6.5") { + $kind="local25"; + # VMplayer 3.0, 3.1, Workstation 7.0, 7.1 + } elsif ($vmversion eq "3.0" || $vmversion eq "7.0" || + $vmversion eq "3.1" || $vmversion eq "7.1") { $kind="local3X"; + } + # Create runlevel script depending on detected version + $self->_writeRunlevelScript("$vmpath", "$kind"); + + # Create wrapper scripts, kind of localNN is set to local + if ( $kind =~ /local*/ ) { $kind = "local"; } + if (-e "/usr/lib/vmware/bin/vmware") { + $self->_writeWrapperScript("$vmpath", "$kind", "ws"); + } + if (-e "/usr/lib/vmware/bin/vmplayer") { + $self->_writeWrapperScript("$vmpath", "$kind", "player"); + } + + # copy nvram file + my $pluginFilesPath + = "$self->{'openslxBasePath'}/lib/plugins/$self->{'name'}/files"; + my @files = qw(nvram); + foreach my $file (@files) { + copyFile("$pluginFilesPath/$file", "$self->{'pluginRepositoryPath'}/$kind"); + } + + } # else { TODO: errorhandling if file or string doesn't exist } + + ## creating needed config /etc/vmware/config + $self->_writeVmwareConfigs("$kind", "$vmpath"); +} + +sub _vmpl2Installation { + my $self = shift; + + my $kind = "vmpl2.0"; + my $vmpath = "/opt/openslx/plugin-repo/vmware/$kind/vmroot/lib/vmware"; + my $vmbin = "/opt/openslx/plugin-repo/vmware/$kind/vmroot/bin"; + + my $pluginFilesPath + = "$self->{'openslxBasePath'}/lib/plugins/$self->{'name'}/files"; + my $installationPath = "$self->{'pluginRepositoryPath'}/$kind"; + + mkpath($installationPath); + + ## + ## Copy needed files + + # copy 'normal' needed files + my @files = qw( nvram install-vmpl.sh ); + foreach my $file (@files) { + copyFile("$pluginFilesPath/$file", "$installationPath"); + } + + # Install the binarys from given pkgpath + system("/bin/sh /opt/openslx/plugin-repo/$self->{'name'}/$kind/install-vmpl.sh $kind"); + + # Create runlevel script + $self->_writeRunlevelScript($vmpath, $kind); + + # Create wrapperscripts + $self->_writeWrapperScript("$vmpath", "$kind", "player"); + + # Creating needed config /etc/vmware/config + $self->_writeVmwareConfigs("$kind", "$vmpath"); + +} + +sub _vmpl25Installation { + my $self = shift; + + my $kind = "vmpl2.5"; + my $vmpath = "/opt/openslx/plugin-repo/vmware/$kind/vmroot/lib/vmware"; + my $vmbin = "/opt/openslx/plugin-repo/vmware/$kind/vmroot/bin"; + my $vmversion = "6.5"; + my $vmbuildversion = "TODO_we_need_it_for_enhanced_runvmware_config_in_stage1"; + + my $pluginFilesPath + = "$self->{'openslxBasePath'}/lib/plugins/$self->{'name'}/files"; + my $installationPath = "$self->{'pluginRepositoryPath'}/$kind"; + + mkpath($installationPath); + + # copy 'normal' needed files + my @files = qw( nvram install-vmpl.sh ); + foreach my $file (@files) { + copyFile("$pluginFilesPath/$file", "$installationPath"); + } + + # Install the binarys from given pkgpath + system("/bin/sh /opt/openslx/plugin-repo/$self->{'name'}/$kind/install-vmpl.sh $kind"); + + # Create runlevel script + $self->_writeRunlevelScript($vmpath, $kind); + + # Create wrapperscripts + $self->_writeWrapperScript("$vmpath", "$kind", "player"); + + # Creating needed config /etc/vmware/config + $self->_writeVmwareConfigs("$kind", "$vmpath"); + +} + +sub _vmpl1Installation { + my $self = shift; + + my $kind = "vmpl1.0"; + my $vmpath = "/opt/openslx/plugin-repo/vmware/$kind/vmroot/lib/vmware"; + my $vmbin = "/opt/openslx/plugin-repo/vmware/$kind/vmroot/bin"; + my $vmversion = "5.5"; + my $vmbuildversion = "TODO_we_need_it_for_enhanced_runvmware_config_in_stage1"; + + my $pluginFilesPath + = "$self->{'openslxBasePath'}/lib/plugins/$self->{'name'}/files"; + my $installationPath = "$self->{'pluginRepositoryPath'}/$kind"; + + mkpath($installationPath); + + # copy 'normal' needed files + my @files = qw( nvram install-vmpl.sh ); + foreach my $file (@files) { + copyFile("$pluginFilesPath/$file", "$installationPath"); + } + + # Download and install the binarys + system("/bin/sh /opt/openslx/plugin-repo/$self->{'name'}/$kind/install-vmpl.sh $kind"); + + # Create runlevel script + $self->_writeRunlevelScript($vmpath, $kind); + + # create wrapper scripts + $self->_writeWrapperScript("$vmpath", "$kind", "player"); + + # creating needed config /etc/vmware/config + $self->_writeVmwareConfigs("$kind", "$vmpath"); + +} + +# The bridge configuration needs the bridge module to be present in early +# stage3 +sub suggestAdditionalKernelModules +{ + my $self = shift; + my $makeInitRamFSEngine = shift; + + my @suggestedModules; + + push @suggestedModules, qw( bridge ); + + return @suggestedModules; +} + +1; -- cgit v1.2.3-55-g7522