Cannot change the entry door of the Linux guest OS by the perl script customization

Default gateway Linux can be changed using script (modified from vmclone.pl) below.

Someone at - it gives help on this?

#!/usr/bin/perl -w
#
# Copyright (c) 2007 VMware, Inc.  All rights reserved.
#



use strict;
use warnings;



use FindBin;
use lib "$FindBin::Bin/../";



use VMware::VIRuntime;
use XML::LibXML;
use AppUtil::VMUtil;
use AppUtil::HostUtil;
use AppUtil::XMLInputUtil;



$Util::script_version = "1.0";



sub check_missing_value;



my %opts = (
   vmhost => {
      type => "=s",
      help => "The name of the host",
      required => 1,
   },
   vmname => {
      type => "=s",
      help => "The name of the Virtual Machine",
      required => 1,
   },
   vmname_destination => {
      type => "=s",
      help => "The name of the target virtual machine",
      required => 1,
   },
   filename => {
      type => "=s",
      help => "The name of the configuration specification file",
      required => 0,
      default => "../sampledata/vmclone.xml",
   },
   customize_guest => {
      type => "=s",
      help => "Flag to specify whether or not to customize guest: yes,no",
      required => 0,
      default => 'no',
   },
   customize_vm => {
      type => "=s",
      help => "Flag to specify whether or not to customize virtual machine: "
            . "yes,no",
      required => 0,
      default => 'no',
   },
   schema => {
      type => "=s",
      help => "The name of the schema file",
      required => 0,
      default => "../schema/vmclone.xsd",
   },
   datastore => {
      type => "=s",
      help => "Name of the Datastore",
      required => 0,
   },
);



Opts::add_options(%opts);
Opts::parse();
Opts::validate(\&validate);



Util::connect();



clone_vm();



Util::disconnect();




# Clone vm operation
# Gets destination host, compute resource views, and
# datastore info for creating the configuration
# specification to help create a clone of an existing
# virtual machine.
# ====================================================
sub clone_vm {
   my $vm_name = Opts::get_option('vmname');
   my $vm_views = Vim::find_entity_views(view_type => 'VirtualMachine',
                                        filter => {'name' =>$vm_name});
   if(@$vm_views) {
      foreach (@$vm_views) {
         my $host_name =  Opts::get_option('vmhost');
         my $host_view = Vim::find_entity_view(view_type => 'HostSystem',
                                         filter => {'name' => $host_name});
                                         
         if (!$host_view) {
            Util::trace(0, "Host '$host_name' not found\n");
            return;
         }
         # bug 449530
         my $disk_size = get_disksize();
         if($disk_size eq -1 || $disk_size eq "") {
            $disk_size = 0;
            my $devices = $_->config->hardware->device;
            foreach my $device (@$devices) {
               if (ref $device eq "VirtualDisk") {
                  $disk_size = $disk_size + $device->capacityInKB;
               }
            }
         }
         if ($host_view) {
            my $comp_res_view = Vim::get_view(mo_ref => $host_view->parent);
            my $ds_name = Opts::get_option('datastore');
            my %ds_info = HostUtils::get_datastore(host_view => $host_view,
                                     datastore => $ds_name,
                                     disksize => $disk_size);
            if ($ds_info{mor} eq 0) {
               if ($ds_info{name} eq 'datastore_error') {
                  Util::trace(0, "\nDatastore $ds_name not available.\n");
                  return;
               }
               if ($ds_info{name} eq 'disksize_error') {
                  Util::trace(0, "\nThe free space available is less than the"
                               . " specified disksize or the host"
                               . " is not accessible.\n");
                  return;
               }
            }



            my $relocate_spec =
            VirtualMachineRelocateSpec->new(datastore => $ds_info{mor},
                                          host => $host_view,
                                          pool => $comp_res_view->resourcePool);
            my $clone_name = Opts::get_option('vmname_destination');
            my $clone_spec ;
            my $config_spec;
            my $customization_spec;



            if ((Opts::get_option('customize_vm') eq "yes")
                && (Opts::get_option('customize_guest') ne "yes")) {
               $config_spec = get_config_spec();
               $clone_spec = VirtualMachineCloneSpec->new(powerOn => 1,template => 0,
                                                       location => $relocate_spec,
                                                       config => $config_spec,
                                                       );
            }
            elsif ((Opts::get_option('customize_guest') eq "yes")
                && (Opts::get_option('customize_vm') ne "yes")) {
               $customization_spec = get_customization_spec
                                              (Opts::get_option('filename'));
               $clone_spec = VirtualMachineCloneSpec->new(
                                                   powerOn => 1,
                                                   template => 0,
                                                   location => $relocate_spec,
                                                   customization => $customization_spec,
                                                   );
            }
            elsif ((Opts::get_option('customize_guest') eq "yes")
                && (Opts::get_option('customize_vm') eq "yes")) {
               $customization_spec = get_customization_spec
                                              (Opts::get_option('filename'));
               $config_spec = get_config_spec();
               $clone_spec = VirtualMachineCloneSpec->new(
                                                   powerOn => 1,
                                                   template => 0,
                                                   location => $relocate_spec,
                                                   customization => $customization_spec,
                                                   config => $config_spec,
                                                   );
            }
            else {
               $clone_spec = VirtualMachineCloneSpec->new(
                                                   powerOn => 1,
                                                   template => 0,
                                                   location => $relocate_spec,
                                                   );
            }
            Util::trace (0, "\nCloning virtual machine '" . $vm_name . "' ...\n");



            eval {
               $_->CloneVM(folder => $_->parent,
                              name => Opts::get_option('vmname_destination'),
                              spec => $clone_spec);
               Util::trace (0, "\nClone '$clone_name' of virtual machine"
                             . " '$vm_name' successfully created.");
            };



            if ($@) {
               if (ref($@) eq 'SoapFault') {
                  if (ref($@->detail) eq 'FileFault') {
                     Util::trace(0, "\nFailed to access the virtual "
                                    ." machine files\n");
                  }
                  elsif (ref($@->detail) eq 'InvalidState') {
                     Util::trace(0,"The operation is not allowed "
                                   ."in the current state.\n");
                  }
                  elsif (ref($@->detail) eq 'NotSupported') {
                     Util::trace(0," Operation is not supported by the "
                                   ."current agent \n");
                  }
                  elsif (ref($@->detail) eq 'VmConfigFault') {
                     Util::trace(0,
                     "Virtual machine is not compatible with the destination host.\n");
                  }
                  elsif (ref($@->detail) eq 'InvalidPowerState') {
                     Util::trace(0,
                     "The attempted operation cannot be performed "
                     ."in the current state.\n");
                  }
                  elsif (ref($@->detail) eq 'DuplicateName') {
                     Util::trace(0,
                     "The name '$clone_name' already exists\n");
                  }
                  elsif (ref($@->detail) eq 'NoDisksToCustomize') {
                     Util::trace(0, "\nThe virtual machine has no virtual disks that"
                                  . " are suitable for customization or no guest"
                                  . " is present on given virtual machine" . "\n");
                  }
                  elsif (ref($@->detail) eq 'HostNotConnected') {
                     Util::trace(0, "\nUnable to communicate with the remote host, "
                                    ."since it is disconnected" . "\n");
                  }
                  elsif (ref($@->detail) eq 'UncustomizableGuest') {
                     Util::trace(0, "\nCustomization is not supported "
                                    ."for the guest operating system" . "\n");
                  }
                  else {
                     Util::trace (0, "Fault" . $@ . ""   );
                  }
               }
               else {
                  Util::trace (0, "Fault" . $@ . ""   );
               }
            }
         }
      }
   }
   else {
      Util::trace (0, "\nNo virtual machine found with name '$vm_name'\n");
   }
}


# It returns the customization spec as per the input XML file

sub get_customization_spec {
   my ($filename) = @_;
   my $parser = XML::LibXML->new();
   my $tree = $parser->parse_file($filename);
   my $root = $tree->getDocumentElement;
   my @cspec = $root->findnodes('Customization-Spec');



   # Default Values
   my $computername = "compname";
   #my $timezone = 190;
   #my $userpassword;
   my $domain;
   my $ipAddress;
   my @gateway;
   my $subnetMask;
   my @dnsServerList;
   
  
   foreach (@cspec) {
      if ($_->findvalue('Virtual-Machine-Name')) {
         $computername = $_->findvalue('Virtual-Machine-Name');
      }
      if ($_->findvalue('Domain')) {
         $domain = $_->findvalue('Domain');
      }
      if ($_->findvalue('ipAddress')) {
         $ipAddress = $_->findvalue('ipAddress');
      }    
      if ($_->findvalue('gateway')) {
         @gateway = split (',',$_->findvalue('gateway'));
      }      
      if ($_->findvalue('subnetMask')) {
         $subnetMask = $_->findvalue('subnetMask');
      }     
      if ($_->findvalue('dnsServerList')) {
         @dnsServerList = split (',',$_->findvalue('dnsServerList'));
      }     
   }
  
   # globalIPSettings
   my @dnsSuffixList = [$domain];
   my $customization_global_settings = CustomizationGlobalIPSettings->new(dnsServerList => \@dnsServerList,
                                                                            dnsSuffixList =>@dnsSuffixList);
   my $customization_identity_settings = CustomizationIdentitySettings->new();



   # identity
   # my $password =
   #   CustomizationPassword->new(plainText=>"true", value=> $userpassword); $computername
      
   my $cust_fixname = CustomizationFixedName->new (name => $computername);



   my $cust_linuxprep =
      CustomizationLinuxPrep->new(domain => $domain,
                                hostName => $cust_fixname,
                                hwClockUTC =>"false",
                                timeZone =>"Asia/Shanghai");



   # nicSettingMap
   my $customization_fixed_ip = CustomizationFixedIp->new(ipAddress => $ipAddress);



   my $cust_ip_settings =
      CustomizationIPSettings->new(ip => $customization_fixed_ip,
                                    dnsDomain => $domain,
                                    gateway => \@gateway,
                                    subnetMask => $subnetMask);



   my $cust_adapter_mapping =
      CustomizationAdapterMapping->new(adapter => $cust_ip_settings);



   my @cust_adapter_mapping_list = [$cust_adapter_mapping];
   
   # customization spec
   my $customization_spec =
      CustomizationSpec->new (identity=>$cust_linuxprep,
                              globalIPSettings=>$customization_global_settings,
                              nicSettingMap=>@cust_adapter_mapping_list);
    #                          options=>$CustomizationOptions);
   return $customization_spec;
}



#Gets the config_spec for customizing the memory, number of cpu's
# and returns the spec
sub get_config_spec() {



   my $parser = XML::LibXML->new();
   my $tree = $parser->parse_file(Opts::get_option('filename'));
   my $root = $tree->getDocumentElement;
   my @cspec = $root->findnodes('Virtual-Machine-Spec');
   my $vmname ;
   my $vmhost  ;
   my $guestid;
   my $datastore;
   my $disksize = 4096;  # in KB;
   my $memory = 256;  # in MB;
   my $num_cpus = 1;
   my $nic_network;
   my $nic_poweron = 1;



   foreach (@cspec) {
   
      if ($_->findvalue('Guest-Id')) {
         $guestid = $_->findvalue('Guest-Id');
      }
      if ($_->findvalue('Memory')) {
         $memory = $_->findvalue('Memory');
      }
      if ($_->findvalue('Number-of-CPUS')) {
         $num_cpus = $_->findvalue('Number-of-CPUS');
      }
      $vmname = Opts::get_option('vmname_destination');
   }



   my $vm_config_spec = VirtualMachineConfigSpec->new(
                                                  name => $vmname,
                                                  memoryMB => $memory,
                                                  numCPUs => $num_cpus,
                                                  guestId => $guestid );
   return $vm_config_spec;
}



sub get_disksize {
   my $disksize = -1;
   my $parser = XML::LibXML->new();
   
   eval {
      my $tree = $parser->parse_file(Opts::get_option('filename'));
      my $root = $tree->getDocumentElement;
      my @cspec = $root->findnodes('Virtual-Machine-Spec');



      foreach (@cspec) {
         $disksize = $_->findvalue('Disksize');
      }
   };
   return $disksize;
}



# check missing values of mandatory fields
sub check_missing_value {
   my $valid= 1;
   my $filename = Opts::get_option('filename');
   my $parser = XML::LibXML->new();
   my $tree = $parser->parse_file($filename);
   my $root = $tree->getDocumentElement;
   my @cust_spec = $root->findnodes('Customization-Spec');
   my $total = @cust_spec;



   if (!$cust_spec[0]->findvalue('Virtual-Machine-Name')) {
      Util::trace(0,"\nERROR in '$filename':\n computername value missing ");
      $valid = 0;
   }
   if (!$cust_spec[0]->findvalue('Domain')) {
      Util::trace(0,"\nERROR in '$filename':\n domain value missing ");
      $valid = 0;
   }
   if (!$cust_spec[0]->findvalue('ipAddress')) {
      Util::trace(0,"\nERROR in '$filename':\n ipAddress value missing ");
      $valid = 0;
   }
   if (!$cust_spec[0]->findvalue('gateway')) {
      Util::trace(0,"\nERROR in '$filename':\n gateway value missing ");
      $valid = 0;
   }
   if (!$cust_spec[0]->findvalue('subnetMask')) {
      Util::trace(0,"\nERROR in '$filename':\n subnetMask value missing ");
      $valid = 0;
   }
   if (!$cust_spec[0]->findvalue('dnsServerList')) {
      Util::trace(0,"\nERROR in '$filename':\n dnsServerList value missing ");
      $valid = 0;
   }
   return $valid;
}



sub validate {
   my $valid= 1;
   if ((Opts::get_option('customize_vm') eq "yes")
                || (Opts::get_option('customize_guest') eq "yes")) {



      $valid = XMLValidation::validate_format(Opts::get_option('filename'));
      if ($valid == 1) {
         $valid = XMLValidation::validate_schema(Opts::get_option('filename'),
                                             Opts::get_option('schema'));
         if ($valid == 1) {
            $valid = check_missing_value();
         }
      }
   }



    if (Opts::option_is_set('customize_vm')) {
       if ((Opts::get_option('customize_vm') ne "yes")
             && (Opts::get_option('customize_vm') ne "no")) {
          Util::trace(0,"\nMust specify 'yes' or 'no' for customize_vm option");
          $valid = 0;
       }
       
    }
    if (Opts::option_is_set('customize_guest')) {
       if ((Opts::get_option('customize_guest') ne "yes")
             && (Opts::get_option('customize_guest') ne "no")) {
          Util::trace(0,"\nMust specify 'yes' or 'no' for customize_guest option");
          $valid = 0;
       }
    }
   return $valid;
}



__END__