Sean, We're very interested in using this module. Can you provide a step-by-step instruction on how to make this available as a provisioning module? We're running ESX 4.0 on our host server. Do we place the module into /usr/local/vcl/lib/VCL/Module/Provisioning ? What is the next step? Getting into the database somehow? Please let me know.
Thanks, Jeff On Wed, Feb 24, 2010 at 1:16 PM, Sean Dilda <s...@duke.edu> wrote: > I've written a provisioning module for VCL that we use here at Duke that > I'd like to share for possible inclusion in VCL. The module is based off > VCL 2.1. > > This module is designed to work against VirtualCenter/vCenter, but should > be able to work directly with an ESX host as well. It works a little > differently from the existing ESX modules in that it uses the VMware perl > API directly instead of calling the helper apps. In addition, it also > greatly reduces the amount of disk space and deployment time necessary. > > Instead of cloning the VM for deployment, this module uses ESX to create a > snapshot of the golden image disk, and uses that for the deployed VM. This > means the only disk space used for the deployed VM is the differences > between it and the master. Likewise, no time is needed to copy all the > bits, so creating the VM takes seconds instead of minutes. > > > Internally we call the module 'esxduke' to distinguish it from the existing > ESX module. Going forward is there a better name for this module? Also, > what should be done from here to have this included in VCL? > > > Thanks, > > > Sean > > #!/usr/bin/perl -w > > ############################################################################### > # Copyright 2010 Duke University and Apache Software Foundation > # > # Licensed to the Apache Software Foundation (ASF) under one or more > # contributor license agreements. See the NOTICE file distributed with > # this work for additional information regarding copyright ownership. > # The ASF licenses this file to You under the Apache License, Version 2.0 > # (the "License"); you may not use this file except in compliance with > # the License. You may obtain a copy of the License at > # > # http://www.apache.org/licenses/LICENSE-2.0 > # > # Unless required by applicable law or agreed to in writing, software > # distributed under the License is distributed on an "AS IS" BASIS, > # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > # See the License for the specific language governing permissions and > # limitations under the License. > > ############################################################################### > > package VCL::Module::Provisioning::esxduke; > > # Configure inheritance > use base qw(VCL::Module::Provisioning); > > # Specify the version of this module > our $VERSION = '1.00'; > > # Specify the version of Perl to use > use 5.008000; > > use strict; > use warnings; > use diagnostics; > > use VCL::utils; > use Fcntl qw(:DEFAULT :flock); > > # Use VMware's perl libraries > use VMware::VIRuntime; > use VMware::VILib; > use VMware::VIExt; > > > > > ############################################################################## > > =head1 CLASS ATTRIBUTES > > =cut > > =head2 %VMWARE_CONFIG > > Data type : hash > Description : %VMWARE_CONFIG is a hash containing the general VMWARE > configuration > for the management node this code is running on. Since the > data is > the same for every instance of the > VMWARE class, a class attribute > is used and the hash is shared among > all instances. This also > means that the data only needs to be > retrieved from the database > once. > > =cut > > #my %VMWARE_CONFIG; > > > ############################################################################## > > =head1 OBJECT METHODS > > =cut > > > #///////////////////////////////////////////////////////////////////////////// > > =head2 initialize > > Parameters : > Returns : > Description : > > =cut > > # A provisioning object is created for each request. So this initialize is > done once per request. > sub initialize { > my $self = shift; > if (!defined ($self) ) { > return 0; > } > notify($ERRORS{'DEBUG'}, 0, "Duke vmware ESX module initialized"); > return 1; > } ## end sub initialize > > sub _checkConnection{ > my $self = shift; > if (!$VMware::VICommon::is_connected) { > # Login to the ESX/VC server > my $retval; > eval { > local $SIG{__DIE__}; # We don't want vcld's die > handler getting this > $retval = Util::connect('https://' . > $self->data->get_vmhost_hostname . "/sdk/webService", > $self->data->get_vmhost_profile_username(), > $self->data->get_vmhost_profile_password()); > }; > if ($@ || !$retval) { > notify($ERRORS{'CRITICAL'}, 0, "Could not login to " > . $self->data->get_vmhost_hostname . ": " . $@); > return 0; > } > } > return 1; > } > > > #///////////////////////////////////////////////////////////////////////////// > > =head2 provision > > Parameters : hash > Returns : 1(success) or 0(failure) > Description : loads virtual machine with requested image > > =cut > > sub load { > my $self = shift; > > #check to make sure this call is for the esx module > if (ref($self) !~ /esxduke/i) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a > function, it must be called as a class method"); > return 0; > } > > my $request_data = shift; > my ($package, $filename, $line, $sub) = caller(0); > notify($ERRORS{'DEBUG'}, 0, > "****************************************************"); > > # get various useful vars from the database > my $request_id = $self->data->get_request_id; > my $reservation_id = $self->data->get_reservation_id; > my $vmhost_hostname = $self->data->get_vmhost_hostname; > my $image_name = $self->data->get_image_name; > my $computer_shortname = $self->data->get_computer_short_name; > my $vmclient_computerid = $self->data->get_computer_id; > my $vmclient_imageminram = $self->data->get_image_minram; > my $image_os_name = $self->data->get_image_os_name; > my $image_os_type = $self->data->get_image_os_type; > my $image_identity = $self->data->get_image_identity; > my $user_name = $self->data->get_user_login_id . "@" . > $self->data->get_user_affiliation_name; > > my $virtualswitch0 = > $self->data->get_vmhost_profile_virtualswitch0; > my $virtualswitch1 = > $self->data->get_vmhost_profile_virtualswitch1; > my $vmclient_eth0MAC = $self->data->get_computer_eth0_mac_address; > my $vmclient_eth1MAC = $self->data->get_computer_eth1_mac_address; > my $vmclient_OSname = $self->data->get_image_os_name; > > my $vmhost_username = $self->data->get_vmhost_profile_username(); > my $vmhost_password = $self->data->get_vmhost_profile_password(); > > $vmhost_hostname =~ /([-_a-zA-Z0-9]*)(\.?)/; > my $vmhost_shortname = $1; > > $self->_checkConnection(); > > notify($ERRORS{'OK'}, 0, "Entered ESX Duke module, loading > $image_name on $computer_shortname (on $vmhost_hostname) for $user_name > (reservation $reservation_id)"); > > my $newVm; > my $newVmPath; > my $task; > my $vmView = $self->_getvmView(0); > my $imageDatastore; > my $datacenter; > > my $fileManager = VIExt::get_file_manager(); > > # These should be somehow configurable in the future > my $resourcePoolName = "VCL-TEST"; > my $folderName = "VCL-TEST"; > my $datastoreName = "VCL-TEST-01"; > > if(open(CONF, "/etc/vcl/vcld.conf")){ > my @conf=<CONF>; > close(CONF); > foreach $line (@conf) { > #resourcePool > if($line =~ /^RESOURCEPOOLNAME=([\S]*)/){ > chomp($line); > $resourcePoolName=$1; > } > #folderName > if($line =~ /^FOLDERNAME=([\S]*)/){ > chomp($line); > $folderName=$1; > } > #datastoreName > if($line =~ /^DATASTORENAME=([\S]*)/){ > chomp($line); > $datastoreName=$1; > } > } > } > > # Get some info on our base image > my $imageView = $self->_getimageView(); > if (! $imageView) { > return 0; > } > > my $parentView = Vim::get_view(mo_ref => $imageView->{parent}); > while (ref($parentView) ne 'Datacenter') { > $parentView = Vim::get_view(mo_ref => > $parentView->{parent}); > } > $datacenter = $parentView; > > $imageDatastore = Vim::get_view(mo_ref => > @{$imageView->{datastore}}[0]); > > my $resourcePool = Vim::find_entity_view(view_type => > 'ResourcePool', filter => {'name' => $resourcePoolName}, begin_entity => > $datacenter); > if (! defined($resourcePool)) { > notify($ERRORS{'WARNING'}, 0, "ERROR: esxduke->load could > not find resource pool $resourcePoolName"); > return 0; > } > my $folder = Vim::find_entity_view(view_type => 'Folder', filter => > {'name' => $folderName}, begin_entity => $datacenter); > if (! defined($folder)) { > notify($ERRORS{'WARNING'}, 0, "ERROR: esxduke->load could > not find folder $folderName"); > return 0; > } > > if ($vmView) { > notify($ERRORS{'DEBUG'}, 0, "Removing old copy of > $computer_shortname"); > if (!$self->_removeOldVM()) { > return 0; > } > } > > # Copy file down > my $service = Vim::get_vim_service(); > my ($mode, $datacenter_foo, $datastore, $filepath) = > VIExt::parse_remote_path($imageView->{config}->{files}->{vmPathName}); > #my ($mode, $datacenter_foo, $datastore, $filepath) = > VIExt::parse_remote_path($imageView->{config}->{files}->{vmPathName}); > $filepath =~ m/(.*)\/.*/; > my $imageDir = $1; > my $resp = VIExt::http_get_file($mode, $filepath, $datastore, > $datacenter->{name}); > if (!defined($resp) || !$resp->is_success) { > notify($ERRORS{'WARNING'}, 0, "ERROR: esxduke->load could > not get config for $image_name"); > return 0; > } > # Edit file > my $newvmx = $resp->content; > $newvmx =~ s/^displayName = .*$/displayName = > \"$computer_shortname\"/gm; > $newvmx =~ s/^extendedConfigFile = .*$/extendedConfigFile = > \"$computer_shortname.vmxf\"/gm; > $newvmx =~ s/^scsi0:0.filename = .*$/scsi0:0.filename = \"FOO\"/gm; > $newvmx =~ s/^nvram = .*$/nvram = \"$computer_shortname.nvram\"/gm; > > $newvmx =~ s/^uuid.location = .*$//gm; > $newvmx =~ s/^uuid.bios = .*$//gm; > $newvmx =~ s/^sched.swap.derivedName = .*$//gm; > $newvmx =~ s/^sched.mem.max = .*$//gm; > $newvmx =~ s/^annotation = .*$//gm; > my $timeStr = localtime; > $newvmx .= "annotation = \"$image_name created for $user_name at > $timeStr\"\n"; > > $newvmx =~ s/^ethernet0.networkName = .*$/ethernet0.networkName = > \"$virtualswitch0\"/gm; > $newvmx =~ s/^ethernet1.networkName = .*$/ethernet1.networkName = > \"$virtualswitch1\"/gm; > > if (!$VMWARE_MAC_ETH0_GENERATED && defined($vmclient_eth0MAC)) { > # Make sure the address type is set right and we have a > .address line > if ($newvmx !~ /^ethernet0.addressType = \"static\"$/m) { > $newvmx .= "ethernet0.addressType = \"static\"\n"; > $newvmx .= "ethernet0.address = \"XXX\"\n"; > } > $newvmx =~ s/^ethernet0.address = .*$/ethernet0.address = > \"$vmclient_eth0MAC\"/gm; > } else { > $newvmx =~ s/^ethernet0.addressType = > \"static\"$/ethernet0.addressType = \"generated\"/gm; > } > if (!$VMWARE_MAC_ETH1_GENERATED && defined($vmclient_eth1MAC)) { > # Make sure the address type is set right and we have a > .address line > if ($newvmx !~ /^ethernet1.addressType = \"static\"$/m) { > $newvmx .= "ethernet1.addressType = \"static\"\n"; > $newvmx .= "ethernet1.address = \"XXX\"\n"; > } > $newvmx =~ s/^ethernet1.address = .*$/ethernet1.address = > \"$vmclient_eth1MAC\"/gm; > } else { > $newvmx =~ s/^ethernet1.addressType = > \"static\"$/ethernet1.addressType = \"generated\"/gm; > } > > my $imageDSUUID; > if (defined($imageDatastore->{vmfs}->{uuid})) { > $imageDSUUID = $imageDatastore->{vmfs}->{uuid}; > } else { > # Use the name if its NFS, not preferred, but I don't know > how to get the UUID for an NFS datastore > $imageDSUUID = $imageDatastore->info->name; > } > > # This is ugly, but I don't know a better way to make sure I catch > all the disks. If anyone has a better way, please let me know > my @vmxlines = split(/\n/, $newvmx); > for $line (@vmxlines) { > # Make sure the scsi filename isn't an absolute path before > we make it an absolute path > if ($line !~ /scsi\d:\d{1,2}.fileName = "\/.*"/) { > $line =~ s/scsi(\d:\d{1,2}).fileName = > "(.*)"/scsi$1.fileName = "\/vmfs\/volumes\/$imageDSUUID\/$imageDir\/$2"/; > } > } > $newvmx = join("\n", @vmxlines) . "\n"; > > # Upload > # Need to make sure this directory doesn't already exist... > _deleteDirectory($datastoreName, $computer_shortname, $datacenter); > eval { > $fileManager->MakeDirectory(name => "[$datastoreName] " . > $computer_shortname, datacenter => $datacenter); > }; > if ($@) { > notify($ERRORS{'WARNING'}, 0, "ERROR: Unable to create > directory [$datastoreName] " . $computer_shortname . ": " . > ($...@->fault_string)); > return 0; > } > > # Based on VIExt::http_put_file > my $serviceURI = URI::URL->new($service->{vim_soap}->{url}); > my $userAgent = $service->{vim_soap}->{user_agent}; > > $newVmPath = $computer_shortname . "/" . $computer_shortname . > ".vmx"; > my $attempt = 1; > while ($attempt <= 3) { > my $req = VIExt::build_http_request("PUT", "folder", > $serviceURI, $newVmPath, $datastoreName, $datacenter->{name}); > $req->header('Content-Type', 'application/octet-stream'); > $req->header('Content-Length', length($newvmx)); > $req->content($newvmx); > $resp = $userAgent->request($req); > if (!$resp || !$resp->is_success) { > notify($ERRORS{'WARNING'}, 0, "ERROR: Unable to > upload [$datastoreName] $newVmPath: " . $resp->message . ": " . > $resp->content); > $attempt += 1; > sleep 3; > next; > } else { > last; > } > } > > if (!$resp || !$resp->is_success) { > return 0; > } > if ($attempt > 1) { > notify($ERRORS{'OK'}, 0, "Uploaded new vmx file on attempt > number $attempt"); > } > > $newVmPath = "[$datastoreName]" . " $newVmPath"; > > $attempt = 1; > my $result; > while ($attempt <= 3) { > $task = $folder->RegisterVM_Task(path => $newVmPath, name => > $computer_shortname, asTemplate => "false", pool => $resourcePool); > $result = _checkTask($task, "registering > $computer_shortname"); > if (!$result) { > $attempt += 1; > sleep 3; > next; > } else { > last; > } > } > > if (!$resp) { > return 0; > } > if ($attempt > 1) { > notify($ERRORS{'OK'}, 0, "Registered VM on attempt number > $attempt"); > } > > $vmView = $self->_getvmView(); > > $task = $vmView->CreateSnapshot_Task(name => 'linked clone from > vcl-image-' . $self->data->get_image_name, memory => "false", quiesce => > "true"); > if (!_checkTask($task, "creating snapshot of $computer_shortname")) > { > return 0; > } > > if ($vmclient_OSname =~ /winxp/) { > # I am hard coding this for now... I am sure we can pass it > in or read it from the db > _customizeVm('vcl-xp', $computer_shortname , $vmView); > } > > $task = $vmView->PowerOnVM_Task(); > if (!_checkTask($task, "powering on $computer_shortname")) { > return 0; > } > > > #Set some variable > my $wait_loops = 0; > my $arpstatus = 0; > my $client_ip; > > if ($VMWARE_MAC_ETH0_GENERATED) { > # allowing vmware to generate the MAC address > # find out what MAC got assigned > # find out what IP address is assigned to this MAC > my $devices = $vmView->config->hardware->device; > my $mac_addr; > foreach my $dev (@$devices) { > next unless ($dev->isa("VirtualEthernetCard")); > notify($ERRORS{'DEBUG'}, 0, "deviceinfo->summary: > $dev->deviceinfo->summary"); > notify($ERRORS{'DEBUG'}, 0, "virtualswitch0: > $virtualswitch0"); > if ($dev->deviceInfo->summary eq $virtualswitch0) { > $mac_addr = $dev->macAddress; > last; > } > } > if (!$mac_addr) { > notify($ERRORS{'WARNING'}, 0, "Failed to find MAC > address"); > return 0; > } > notify($ERRORS{'DEBUG'}, 0, "Queried MAC address is > $mac_addr"); > > # Query ARP table for $mac_addr to find the IP (waiting for > machine to come up if necessary) > # The DHCP negotiation should add the appropriate ARP entry > for us > while (!$arpstatus) { > my $arpoutput = `arp -n`; > if ($arpoutput =~ > /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*?$mac_addr/mi) { > $client_ip = $1; > $arpstatus = 1; > notify($ERRORS{'OK'}, 0, > "$computer_shortname now has ip $client_ip"); > } > else { > if ($wait_loops > 24) { > notify($ERRORS{'WARNING'}, 0, > "waited acceptable amount of time for dhcp, please check $computer_shortname > on $vmhost_shortname"); > return 0; > } > else { > $wait_loops++; > notify($ERRORS{'OK'}, 0, "going to > sleep 10 seconds, waiting for computer to DHCP. Try $wait_loops"); > sleep 10; > } > } ## end else [ if ($arpoutput =~ > /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*?$mac_addr/mi) > } ## end while (!$arpstatus) > > > > notify($ERRORS{'OK'}, 0, "Found IP address $client_ip"); > > # Delete existing entry for $computer_shortname in > /etc/hosts (if any) > notify($ERRORS{'OK'}, 0, "Removing old hosts entry"); > my $sedoutput = `sed -i "/.*\\b$computer_shortname\$/d" > /etc/hosts`; > notify($ERRORS{'DEBUG'}, 0, $sedoutput); > > # Add new entry to /etc/hosts for $computer_shortname > `echo -e "$client_ip\t$computer_shortname" >> /etc/hosts`; > } ## end if ($VMWARE_MAC_ETH0_GENERATED) > else { > notify($ERRORS{'DEBUG'}, 0, "IP is known for > $computer_shortname"); > } > # Start waiting for SSH to come up > my $sshdstatus = 0; > $wait_loops = 0; > my $sshd_status = "off"; > notify($ERRORS{'DEBUG'}, 0, "Waiting for ssh to come up on > $computer_shortname"); > while (!$sshdstatus) { > $sshd_status = _sshd_status($computer_shortname, > $image_name, $image_os_type); > if ($sshd_status eq "on") { > $sshdstatus = 1; > notify($ERRORS{'OK'}, 0, "$computer_shortname now > has active sshd running"); > } > else { > #either sshd is off or N/A, we wait > if ($wait_loops > 150) { > notify($ERRORS{'WARNING'}, 0, "waited > acceptable amount of time for sshd to become active, please check > $computer_shortname on $vmhost_shortname"); > #need to check power, maybe reboot it. for > now fail it > return 0; > } > else { > $wait_loops++; > # to give post config a chance > notify($ERRORS{'DEBUG'}, 0, "going to sleep > 10 seconds, waiting for computer to start SSH. Try $wait_loops"); > sleep 10; > } > } # else > } #while > > # Set IP info > if ($IPCONFIGURATION ne "manualDHCP") { > #not default setting > if ($IPCONFIGURATION eq "dynamicDHCP") { > insertloadlog($reservation_id, $vmclient_computerid, > "dynamicDHCPaddress", "collecting dynamic IP address for node"); > notify($ERRORS{'DEBUG'}, 0, "Attempting to query > vmclient for its public IP..."); > #### Sean > ### Why call getdynamicaddress? It doesn't work. Should we instead just > write a local method > #### to get the ip from another means? > #### Liz > my $assignedIPaddress = > getdynamicaddress($computer_shortname, $vmclient_OSname, $image_os_type); > if ($assignedIPaddress) { > #update computer table > notify($ERRORS{'DEBUG'}, 0, " Got dynamic > address from vmclient, attempting to update database"); > if > (update_computer_address($vmclient_computerid, $assignedIPaddress)) { > notify($ERRORS{'DEBUG'}, 0, " > succesfully updated IPaddress of node $computer_shortname"); > } > else { > notify($ERRORS{'CRITICAL'}, 0, > "could not update dynamic address $assignedIPaddress for $computer_shortname > $image_name"); > return 0; > } > } ## end if ($assignedIPaddress) > else { > notify($ERRORS{'CRITICAL'}, 0, "could not > fetch dynamic address from $computer_shortname $image_name"); > insertloadlog($reservation_id, > $vmclient_computerid, "failed", "could not collect dynamic IP address for > node"); > return 0; > } > } ## end if ($IPCONFIGURATION eq "dynamicDHCP") > elsif ($IPCONFIGURATION eq "static") { > notify($ERRORS{'CRITICAL'}, 0, "STATIC ASSIGNMENT > NOT SUPPORTED. See vcld.conf"); > return 0; > #insertloadlog($reservation_id, > $vmclient_computerid, "staticIPaddress", "setting static IP address for > node"); > #if (setstaticaddress($computer_shortname, > $vmclient_OSname, $vmclient_publicIPaddress)) { > # # good set static address > #} > } > } ## end if ($IPCONFIGURATION ne "manualDHCP") > > # Perform post load tasks > return 1; > } ## end sub load > > #///////////////////////////////////////////////////////////////////////// > > =head2 node_status > > Parameters : $nodename, $log > Returns : array of related status checks > Description : checks on sshd, currentimage > > =cut > > sub node_status { > my $self = shift; > > my ($package, $filename, $line, $sub) = caller(0); > > my $vmpath = 0; > my $datastorepath = 0; > my $requestedimagename = 0; > my $vmhost_type = 0; > my $vmhost_hostname = 0; > my $vmhost_imagename = 0; > my $image_os_type = 0; > my $vmclient_shortname = 0; > my $request_forimaging = 0; > my $identity_keys = 0; > my $log = 0; > my $computer_node_name = 0; > > > # Check if subroutine was called as a class method > if (ref($self) !~ /esxduke/i) { > notify($ERRORS{'OK'}, 0, "subroutine was called as a > function"); > if (ref($self) eq 'HASH') { > $log = $self->{logfile}; > #notify($ERRORS{'DEBUG'}, $log, "self is a hash > reference"); > > $vmpath = > $self->{vmhost}->{vmprofile}->{vmpath}; > $datastorepath = > $self->{vmhost}->{vmprofile}->{datastorepath}; > $requestedimagename = > $self->{imagerevision}->{imagename}; > $vmhost_type = > $self->{vmhost}->{vmprofile}->{vmtype}->{name}; > $vmhost_hostname = $self->{vmhost}->{hostname}; > $vmhost_imagename = $self->{vmhost}->{imagename}; > $image_os_type = $self->{image}->{OS}->{type}; > $computer_node_name = $self->{computer}->{hostname}; > $identity_keys = > $self->{managementnode}->{keys}; > > } ## end if (ref($self) eq 'HASH') > # Check if node_status returned an array ref > elsif (ref($self) eq 'ARRAY') { > notify($ERRORS{'DEBUG'}, $log, "self is a array > reference"); > } > > $vmclient_shortname = $1 if ($computer_node_name =~ > /([-_a-zA-Z0-9]*)(\.?)/); > } ## end if (ref($self) !~ /esx/i) > else { > > # try to contact vm > # $self->data->get_request_data; > # get state of vm > $vmpath = > $self->data->get_vmhost_profile_vmpath; > $datastorepath = > $self->data->get_vmhost_profile_datastore_path; > $requestedimagename = $self->data->get_image_name; > $vmhost_type = $self->data->get_vmhost_type; > $vmhost_hostname = $self->data->get_vmhost_hostname; > $vmhost_imagename = $self->data->get_vmhost_image_name; > $image_os_type = $self->data->get_image_os_type; > $vmclient_shortname = $self->data->get_computer_short_name; > $request_forimaging = $self->data->get_request_forimaging(); > } ## end else [ if (ref($self) !~ /esx/i) > > notify($ERRORS{'OK'}, 0, "Entering node_status, checking status > of $vmclient_shortname"); > notify($ERRORS{'DEBUG'}, 0, "request_for_imaging: > $request_forimaging"); > notify($ERRORS{'DEBUG'}, 0, "requeseted image name: > $requestedimagename"); > > my ($hostnode, $identity); > > # Create a hash to store status components > my %status; > > # Initialize all hash keys here to make sure they're defined > $status{status} = 0; > $status{currentimage} = 0; > $status{ping} = 0; > $status{ssh} = 0; > $status{vmstate} = 0; #on or off > $status{image_match} = 0; > > if ($vmhost_type eq "blade") { > $hostnode = $1 if ($vmhost_hostname =~ > /([-_a-zA-Z0-9]*)(\.?)/); > $identity = $IDENTITY_bladerhel; > #if($vm{vmhost}{imagename} =~ /^(rhel|rh3image|rh4image|fc|rhfc)/); > } > else { > #using FQHN > $hostnode = $vmhost_hostname; > $identity = $IDENTITY_linux_lab if ($vmhost_imagename =~ > /^(realmrhel)/); > } > > if (!$identity) { > notify($ERRORS{'CRITICAL'}, 0, "could not set ssh identity > variable for image $vmhost_imagename type= $vmhost_type host= > $vmhost_hostname"); > } > > # Check if node is pingable > notify($ERRORS{'DEBUG'}, 0, "checking if $vmclient_shortname is > pingable"); > if (_pingnode($vmclient_shortname)) { > $status{ping} = 1; > notify($ERRORS{'OK'}, 0, "$vmclient_shortname is pingable > ($status{ping})"); > } > else { > notify($ERRORS{'OK'}, 0, "$vmclient_shortname is not > pingable ($status{ping})"); > $status{status} = 'RELOAD'; > return $status{status}; > } > > # > #my $vmx_directory = "$requestedimagename$vmclient_shortname"; > #my $myvmx = > "$vmpath/$requestedimagename$vmclient_shortname/$requestedimagename$vmclient_shortname.vmx"; > #my $mybasedirname = $requestedimagename; > #my $myimagename = $requestedimagename; > > notify($ERRORS{'DEBUG'}, 0, "Trying to ssh..."); > > #can I ssh into it > my $sshd = _sshd_status($vmclient_shortname, $requestedimagename, > $image_os_type); > > > #is it running the requested image > if ($sshd eq "on") { > > notify($ERRORS{'DEBUG'}, 0, "SSH good, trying to query image > name"); > > $status{ssh} = 1; > $identity = $IDENTITY_bladerhel; > my @sshcmd = run_ssh_command($vmclient_shortname, $identity, > "cat currentimage.txt"); > $status{currentimage} = $sshcmd[1][0]; > > notify($ERRORS{'DEBUG'}, 0, "Image name: > $status{currentimage}"); > > if ($status{currentimage}) { > chomp($status{currentimage}); > if ($status{currentimage} =~ /$requestedimagename/) > { > $status{image_match} = 1; > notify($ERRORS{'OK'}, 0, > "$vmclient_shortname is loaded with requestedimagename > $requestedimagename"); > } > else { > notify($ERRORS{'OK'}, 0, > "$vmclient_shortname reports current image is currentimage= > $status{currentimage} requestedimagename= $requestedimagename"); > } > } ## end if ($status{currentimage}) > } ## end if ($sshd eq "on") > > # Determine the overall machine status based on the individual > status results > if ($status{ssh} && $status{image_match}) { > $status{status} = 'READY'; > } > else { > $status{status} = 'RELOAD'; > } > > notify($ERRORS{'DEBUG'}, 0, "status set to $status{status}"); > > > if ($request_forimaging) { > $status{status} = 'RELOAD'; > notify($ERRORS{'OK'}, 0, "request_forimaging set, setting > status to RELOAD"); > } > > notify($ERRORS{'DEBUG'}, 0, "returning node status hash reference > (\$node_status->{status}=$status{status})"); > return \%status; > > } ## end sub node_status > > sub does_image_exist { > my $self = shift; > if (ref($self) !~ /esxduke/i) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a > function, it must be called as a class method"); > return 0; > } > > my $image_view = $self->_getimageView(0); > if (! $image_view) { > return 0; > } > return 1; > > } ## end sub does_image_exist > > > #///////////////////////////////////////////////////////////////////////////// > > =head2 getimagesize > > Parameters : imagename > Returns : 0 failure or size of image > Description : in size of Kilobytes > > =cut > > # Need to implement > sub get_image_size { > my $self = shift; > if (ref($self) !~ /esxduke/i) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a > function, it must be called as a class method"); > return 0; > } > > # Just a placeholder - not sure if this value even matters > return 1; > } ## end sub get_image_size > > sub power_off { > my $self = shift; > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > > my $task; > my $computer_shortname = $self->data->get_computer_short_name; > my $vmView = $self->_getvmView(); > if (!$vmView) { > return 0; > } > if ($vmView->{runtime}->{powerState}->val eq "poweredOff") { > # VM is turned off, so just return happily > return 1; > } > $task = $vmView->PowerOffVM_Task(); > if (!_checkTask($task, "powering off " . $computer_shortname)) { > return 0; > } > return 1; > } > > sub power_on { > my $self = shift; > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > > my $task; > my $computer_shortname = $self->data->get_computer_short_name; > my $vmView = $self->_getvmView(); > if (!$vmView) { > return 0; > } > if ($vmView->{runtime}->{powerState}->val eq "poweredOn") { > # VM is turned on, so just return happily > return 1; > } > $task = $vmView->PowerOnVM_Task(); > if (!_checkTask($task, "powering on " . $computer_shortname)) { > return 0; > } > return 1; > } > > sub power_reset { > my $self = shift; > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > > my $task; > my $computer_shortname = $self->data->get_computer_short_name; > my $vmView = $self->_getvmView(); > if (!$vmView) { > return 0; > } > $task = $vmView->ResetVM_Task(); > if (!_checkTask($task, "reseting on " . $computer_shortname)) { > return 0; > } > return 1; > } > > sub power_status { > my $self = shift; > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > > my $task; > my $computer_shortname = $self->data->get_computer_short_name; > my $vmView = $self->_getvmView(); > if (!$vmView) { > return; > } > $vmView->update_view_data(); > if ($vmView->runtime->powerState->val eq 'poweredOn') { > return "on"; > } elsif ($vmView->runtime->powerState->val eq 'poweredOff') { > return "off"; > } else { > notify($ERRORS{'WARNING'}, 0, "Unable to determin power > status. VMware reports powerState: " . $vmView->runtime->powerState->val); > return; > } > } > > > #///////////////////////////////////////////////////////////////////////////// > > =head2 capture > > Parameters : $request_data_hash_reference > Returns : 1 if sucessful, 0 if failed > Description : Creates a new vmware image. > > =cut > > sub capture { > my $self = shift; > if (ref($self) !~ /esxduke/i) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a > function, it must be called as a class method"); > return 0; > } > > my ($package, $filename, $line, $sub) = caller(0); > > # Store some hash variables into local variables > # to pass to write_current_image routine > my $request_data = $self->data->get_request_data; > > if (!$request_data) { > notify($ERRORS{'WARNING'}, 0, "unable to retrieve request > data hash"); > return 0; > } > > # Store some hash variables into local variables > my $request_id = $self->data->get_request_id; > my $reservation_id = $self->data->get_reservation_id; > > my $image_id = $self->data->get_image_id; > my $image_os_name = $self->data->get_image_os_name; > my $image_identity = $self->data->get_image_identity; > my $image_os_type = $self->data->get_image_os_type; > my $image_name = $self->data->get_image_name(); > > my $computer_id = $self->data->get_computer_id; > my $computer_shortname = $self->data->get_computer_short_name; > my $computer_nodename = $computer_shortname; > my $computer_hostname = $self->data->get_computer_hostname; > my $computer_type = $self->data->get_computer_type; > > my $vmtype_name = $self->data->get_vmhost_type_name; > my $vmhost_vmpath = > $self->data->get_vmhost_profile_vmpath; > my $vmprofile_vmdisk = > $self->data->get_vmhost_profile_vmdisk; > my $vmprofile_datastorepath = > $self->data->get_vmhost_profile_datastore_path; > my $vmhost_hostname = $self->data->get_vmhost_hostname; > my $host_type = $self->data->get_vmhost_type; > my $vmhost_imagename = $self->data->get_vmhost_image_name; > > my ($hostIdentity, $hostnodename); > if ($host_type eq "blade") { > $hostnodename = $1 if ($vmhost_hostname =~ > /([-_a-zA-Z0-9]*)(\.?)/); > $hostIdentity = $IDENTITY_bladerhel; > } > else { > #using FQHN > $hostnodename = $vmhost_hostname; > $hostIdentity = $IDENTITY_linux_lab if ($vmhost_imagename =~ > /^(realmrhel)/); > } > # Assemble a consistent prefix for notify messages > my $notify_prefix = "req=$request_id, res=$reservation_id:"; > > > # Print some preliminary information > notify($ERRORS{'OK'}, 0, "$notify_prefix new name: $image_name"); > notify($ERRORS{'OK'}, 0, "$notify_prefix computer_name: > $computer_shortname"); > notify($ERRORS{'OK'}, 0, "$notify_prefix vmhost_hostname: > $vmhost_hostname"); > notify($ERRORS{'OK'}, 0, "$notify_prefix vmtype_name: > $vmtype_name"); > > my $vmView = $self->_getvmView(); > if (!$vmView) { > return 0; > } > > my $imageFolderName = "VCL-TEST"; > my $imageDatastoreName = "VCL-IMAGES-TEST-01"; > > if(open(CONF, "/etc/vcl/vcld.conf")){ > my @conf=<CONF>; > close(CONF); > foreach $line (@conf) { > #folderName > if($line =~ /^IMAGEFOLDERNAME=([\S]*)/){ > chomp($line); > $imageFolderName=$1; > } > #datastoreName > if($line =~ /^IMAGEDATASTORENAME=([\S]*)/){ > chomp($line); > $imageDatastoreName=$1; > } > } > } > > my $parentView = Vim::get_view(mo_ref => $vmView->{parent}); > while (ref($parentView) ne 'Datacenter') { > $parentView = Vim::get_view(mo_ref => > $parentView->{parent}); > } > my $datacenter = $parentView; > my $datastoreView; > my $datastores = Vim::get_views(mo_ref_array => > $datacenter->{datastore}); > foreach (@$datastores) { > if ($_->{info}->{name} eq $imageDatastoreName) { > $datastoreView = $_; > last; > } > } > if (!defined($datastoreView)) { > notify($ERRORS{'CRITICAL'}, 0, "Unable to find datastore > $imageDatastoreName"); > return 0; > } > my $folder = Vim::find_entity_view(view_type => 'Folder', filter => > {'name' => $imageFolderName}, begin_entity => $datacenter); > if (! defined($folder)) { > notify($ERRORS{'CRITICAL'}, 0, "ERROR: esxduke->capture > could not find folder $imageFolderName"); > return 0; > } > > # Modify currentimage.txt > if (write_currentimage_txt($self->data)) { > notify($ERRORS{'OK'}, 0, "$notify_prefix currentimage.txt > updated on $computer_shortname"); > } > else { > notify($ERRORS{'WARNING'}, 0, "$notify_prefix unable to > update currentimage.txt on $computer_shortname"); > return 0; > } > > # Set some vm paths and names > my $vmx_directory = "$reservation_id$computer_shortname"; > my $vmx_image_name = "$reservation_id$computer_shortname"; > my $vmx_path = > "$vmhost_vmpath/$vmx_directory/$vmx_image_name.vmx"; > > my @sshcmd; > > # Check if pre_capture() subroutine has been implemented by the OS > module > if ($self->os->can("pre_capture")) { > # Call OS pre_capture() - it should perform all OS steps > necessary to capture an image > # pre_capture() should shut down the computer when it is > done > notify($ERRORS{'OK'}, 0, "calling OS module's pre_capture() > subroutine"); > > if (!$self->os->pre_capture({end_state => 'off'})) { > notify($ERRORS{'WARNING'}, 0, "OS module > pre_capture() failed"); > return 0; > } > > } > # Get the power status, make sure computer is off > my $power_status = $self->power_status(); > notify($ERRORS{'DEBUG'}, 0, "retrieved power status: > $power_status"); > if ($power_status eq 'off') { > notify($ERRORS{'OK'}, 0, "verified $computer_nodename power > is off"); > } > elsif ($power_status eq 'on') { > notify($ERRORS{'WARNING'}, 0, "$computer_nodename power is > still on, turning computer off"); > > # Attempt to power off computer > if ($self->power_off()) { > notify($ERRORS{'OK'}, 0, "$computer_nodename was > powered off"); > } > else { > notify($ERRORS{'WARNING'}, 0, "failed to power off > $computer_nodename"); > return 0; > } > } > else { > notify($ERRORS{'WARNING'}, 0, "failed to determine power > status of $computer_nodename"); > return 0; > } > > # Clone with new image name: $image_name > > my $relocateSpec = VirtualMachineRelocateSpec->new(datastore => > $datastoreView, transform => > VirtualMachineRelocateTransformation->new('sparse')); > my $cloneSpec = VirtualMachineCloneSpec->new(powerOn => 0, template > => 1, location => $relocateSpec); > > notify($ERRORS{'OK'}, 0, "Cloning $computer_shortname to > vcl-image-$image_name"); > > my $task = $vmView->CloneVM_Task(folder => $folder, name => > "vcl-image-" . $image_name, spec => $cloneSpec); > return _checkTask($task, "Cloning $computer_shortname"); > > } ## end sub capture > > > sub _getvmView { > my $self = shift; > my $is_warning = shift; > my $notify_level = $ERRORS{'WARNING'}; > > if (defined($is_warning) && !$is_warning) { > $notify_level = $ERRORS{'DEBUG'}; > } > > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > if (defined($self->{_vmView})) { > return $self->{_vmView}; > } > > $self->_checkConnection(); > my $computer_shortname = $self->data->get_computer_short_name; > my $vmView = Vim::find_entity_view(view_type => 'VirtualMachine', > filter => {'name' => $computer_shortname }); > if (!$vmView) { > notify($notify_level, 0, "Could not find VM > $computer_shortname"); > return 0; > } > $self->{_vmView} = $vmView; > > return $vmView; > } > > sub _getimageView { > my $self = shift; > my $is_crit = shift; > my $notify_level = $ERRORS{'CRITICAL'}; > > if (defined($is_crit) && !$is_crit) { > $notify_level = $ERRORS{'DEBUG'}; > } > > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > if (defined($self->{_imageView})) { > return $self->{_imageView}; > } > > $self->_checkConnection(); > my $image_name = $self->data->get_image_name; > my $imageView = Vim::find_entity_view(view_type => 'VirtualMachine', > filter => {'name' => "vcl-image-$image_name"}); > if (!$imageView) { > notify($notify_level, 0, "Could not find image > vcl-image-$image_name"); > return 0; > } > if ($imageView->{snapshot}) { > # This is always crit. If we're called from does_image_exist > we want to log the weird state of the image existing but being invalid > notify($ERRORS{'CRITICAL'}, 0, "ERROR: vcl-image-$image_name > is an invalid image, it has a snapshot"); > return 0; > } > $self->{_imageView} = $imageView; > > return $imageView; > } > > sub _removeOldVM { > > my $self = shift; > unless (ref($self) && $self->isa('VCL::Module')) { > notify($ERRORS{'CRITICAL'}, 0, "subroutine can only be > called as a VCL::Module module object method"); > return 0; > } > > my $task; > my (@deviceSpecs, $vmDevices, $vmConfigSpec); > > my $vmView = $self->_getvmView(); > > if ($vmView->{runtime}->{powerState}->val ne "poweredOff") { > notify($ERRORS{'DEBUG'}, 0, "Powering off " . > $vmView->{name}); > $task = $vmView->PowerOffVM_Task(); > if (!_checkTask($task, "powering off " . $vmView->{name})) { > return 0; > } > } > > # We simply unregister the VM. The _deleteDirectory function will > # clean up the files. If we were to Destroy the VM, VMware would > # wipe out the disk of the image, which we need to avoid. > $vmView->UnregisterVM(); > > $self->{_vmView} = undef; > return 1; > > } > > sub _checkTask { > my ($task, $taskName) = @_; > > my $taskView = Vim::get_view(mo_ref => $task); > while (1) { > # Sometimes FileManager->DeleteDatastoreFile() gives us an > odd task, so this is to give us a shot of making it a normal task > if (!defined $taskView->{info}) { > my $attempt = 1; > while ($attempt <= 3) { > $taskView->update_view_data(); > if (defined $taskView->{info}) { > last; > } else { > $attempt += 1; > sleep 1; > } > } > if (!defined $taskView->{info}) { > notify($ERRORS{'WARNING'}, 0, "ERROR: Could > not get valid task for $taskName"); > return 0; > } > } > > if ($taskView->info->state->val eq "success") { > return 1; > } elsif ($taskView->info->state->val eq "error") { > notify($ERRORS{'WARNING'}, 0, "ERROR: $taskName: " . > $taskView->info->error->localizedMessage); > return 0; > } > sleep 1; > $taskView->update_view_data(); > } > } > > sub _customizeVm { > my ($customSpec, $nodeName, $view ) = @_; > > my $customView = Vim::get_view(mo_ref => > Vim::get_service_content()->customizationSpecManager); > my $customizationSpec = $customView->GetCustomizationSpec ('name' => > $customSpec)->spec; > > # We need to set the machine name in this spec > _setMachineName($nodeName, $customizationSpec); > my $task = $view->CustomizeVM_Task(spec => $customizationSpec); > if (_checkTask($task, "customizing $nodeName")){ > notify($ERRORS{'OK'}, 0, "success setting custom specs"); > } > } > > sub _setMachineName { > my ($vmName, $customizationSpec) = @_; > > my @machineName = split(/\./,$vmName); > my $cust_name = CustomizationFixedName->new (name => > $machineName[0]); > $customizationSpec->identity->userData->computerName ($cust_name); > return; > } > > sub _deleteDirectory { > my ($dsName, $dirname, $datacenter) = @_; > my $ds; > > foreach my $ds2 (@{$datacenter->{'datastore'}}) { > my $ds_view = Vim::get_view(mo_ref => $ds2); > if ($ds_view->info->name eq $dsName) { > $ds = $ds_view; > last; > } > } > > if (!defined($ds)) { > notify($ERRORS{'WARNING'}, 0, "Could not find datastore > $dsName"); > return 0; > } > > my $ds_browser = Vim::get_view(mo_ref => $ds->browser); > > my $search_spec = HostDatastoreBrowserSearchSpec->new(matchPattern > => [$dirname]); > my $browse_result = $ds_browser->SearchDatastore(datastorePath => > "[$dsName]", searchSpec => $search_spec); > # Only do the delete if the file exists > if (defined $browse_result->file) { > eval { > my $fileManager = Vim::get_view(mo_ref => > Vim::get_service_content()->fileManager); > my $task = > $fileManager->DeleteDatastoreFile_Task(name => "[$dsName] $dirname", > datacenter => $datacenter); > if (!_checkTask($task, "deleting [$dsName] > $dirname")) { > return 0; > } > }; > if ($@) { > notify($ERRORS{'WARNING'}, 0, "Error trying to > delete [$dsName] $dirname: " . ($...@->fault_string)); > } > } > } > > > > initialize(); > > END { > Util::disconnect(); > } > > > #///////////////////////////////////////////////////////////////////////////// > > 1; > __END__ > > =head1 SEE ALSO > > L<http://cwiki.apache.org/VCL/> > > =cut > >
