For more information regarding the security incident at F5, the actions we are taking to address it, and our ongoing efforts to protect our customers, click here.

Perl Config Sync

Problem this snippet solves:

This sample illustrates how to use the ConfigSync interfaces in perl.

Code :

#!/usr/bin/perl
#----------------------------------------------------------------------------
# The contents of this file are subject to the "END USER LICENSE AGREEMENT FOR F5
# Software Development Kit for iControl"; you may not use this file except in
# compliance with the License. The License is included in the iControl
# Software Development Kit.
#
# Software distributed under the License is distributed on an "AS IS"
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
# the License for the specific language governing rights and limitations
# under the License.
#
# The Original Code is iControl Code and related documentation
# distributed by F5.
#
# The Initial Developer of the Original Code is F5 Networks,
# Inc. Seattle, WA, USA. Portions created by F5 are Copyright (C) 1996-2004 F5 Networks,
# Inc. All Rights Reserved.  iControl (TM) is a registered trademark of F5 Networks, Inc.
#
# Alternatively, the contents of this file may be used under the terms
# of the GNU General Public License (the "GPL"), in which case the
# provisions of GPL are applicable instead of those above.  If you wish
# to allow use of your version of this file only under the terms of the
# GPL and not to allow others to use your version of this file under the
# License, indicate your decision by deleting the provisions above and
# replace them with the notice and other provisions required by the GPL.
# If you do not delete the provisions above, a recipient may use your
# version of this file under either the License or the GPL.
#----------------------------------------------------------------------------

#use SOAP::Lite + trace => qw(method debug);
use SOAP::Lite;
use MIME::Base64;

$ENV{PERL_LWP_SSL_VERIFY_HOSTNAME} = 0;

$| = 1;

BEGIN { push (@INC, ".."); }
use iControlTypeCast;

$sHost = $ARGV[0];
$sPort = $ARGV[1];
$sUID = $ARGV[2];
$sPWD = $ARGV[3];
$sCOMMAND = $ARGV[4];
$sArg1 = $ARGV[5];
$sArg2 = $ARGV[6];

#----------------------------------------------------------------------------
# Validate Arguments
#----------------------------------------------------------------------------

my $sConfigName = "";
my $sLocalFile = "";
my $sSaveMode = "";
my $sProtocol;
my $defaultChunkSize = 65536/2;

my $FileChainType =
{
  0 => "FILE_UNDEFINED",
  1 => "FILE_FIRST",
  2 => "FILE_MIDDLE",
  3 => "FILE_UNUSED",
  4 => "FILE_LAST",
  5 => "FILE_FIRST_AND_LAST",
};
my $FileChainTypeValue =
{
  "FILE_UNDEFINED" => 0,
  "FILE_FIRST" => 1,
  "FILE_MIDDLE" => 2,
  "FILE_UNUSED" => 3,
  "FILE_LAST" => 4,
  "FILE_FIRST_AND_LAST" => 5,
};

my $FILE_UNDEFINED = "FILE_UNDEFINED";
my $FILE_FIRST = "FILE_FIRST";
my $FILE_MIDDLE = "FILE_MIDDLE";
my $FILE_UNUSED = "FILE_UNUSED";
my $FILE_LAST = "FILE_LAST";
my $FILE_FIRST_AND_LAST = "FILE_FIRST_AND_LAST";

my $SaveMode = 
{
  0 => "SAVE_FULL",
  1 => "SAVE_HIGH_LEVEL_CONFIG",
  2 => "SAVE_BASE_LEVEL_CONFIG",
};
my $SaveModeValue =
{
  "SAVE_FULL" => 0,
  "SAVE_HIGH_LEVEL_CONFIG" => 1,
  "SAVE_BASE_LEVEL_CONFIG" => 2,
};

my $SAVE_FULL = "SAVE_FULL";
my $SAVE_HIGH_LEVEL_CONFIG = "SAVE_HIGH_LEVEL_CONFIG";
my $SAVE_BASE_LEVEL_CONFIG = "SAVE_BASE_LEVEL_CONFIG";

my $SyncMode =
{
  0 => "CONFIGSYNC_BASIC",
  1 => "CONFIGSYNC_RUNNING",
  2 => "CONFIGSYNC_ALL",
};
my $SyncModeValue =
{
  "CONFIGSYNC_BASIC" => 0,
  "CONFIGSYNC_RUNNING" => 1,
  "CONFIGSYNC_ALL" => 2,
};

my $CONFIGSYNC_BASIC = "CONFIGSYNC_BASIC";
my $CONFIGSYNC_RUNNING = "CONFIGSYNC_RUNNING";
my $CONFIGSYNC_ALL = "CONFIGSYNC_ALL";


#----------------------------------------------------------------------------
# Verify connection info
#----------------------------------------------------------------------------
if ( ($sHost eq "") or ($sUID eq "") or ($sPWD eq "") )
{
  &usage();
}

if ( ($sPort ne "80") and ($sPort ne "8080") )
{
  $sProtocol = "https";
}
else
{
  $sProtocol = "http";
}

#----------------------------------------------------------------------------
# Transport Information
#----------------------------------------------------------------------------
sub SOAP::Transport::HTTP::Client::get_basic_credentials
{
  return "$sUID" => "$sPWD";
}

$ConfigSync = SOAP::Lite
  -> uri('urn:iControl:System/ConfigSync')
  -> readable(1)
  -> proxy("$sProtocol://$sHost:$sPort/iControl/iControlPortal.cgi");
eval { $ConfigSync->transport->http_request->header
(
  'Authorization' => 
    'Basic ' . MIME::Base64::encode("$sUID:$sPWD", '')
); };

&checkParameters(); 


#----------------------------------------------------------------------------
# Get Command Parameters 
#----------------------------------------------------------------------------
sub getParamsAndGo
{
  my $theCommandID = $_[0];
  if ( 1 eq $theCommandID )
  {
    print " Filename for configuration backup (empty for default): ";
    chomp ($configName = );
    if ( "" eq $configName )
    {
      $configName = generateConfigName();
    }
    $localFile = $sConfigName;

    print "Backing up configuration $configName\n";
  
    $success = &backupConfiguration($configName, $localFile, 1);
    if ( 1 == $success )
    {
      print "Backup succeeded\n";
    }
    else
    {
      print "Backup failed\n";
    }
         
  }
  elsif ( 2 eq  $theCommandID)
  {
    print " Config back up file to restore: ";
    chomp ($sConfigName = );
    print " Sync devices after install? (y/n): ";
    chomp ($sDoSync = );
    $sLocalFile = $sConfigName;
    $sSaveMode = "full";

    print "Restoring configuration $sLocalFile\n";
    $success = &restoreConfiguration($sLocalFile, $sDoSync, 1);
    if ( 1 == $success )
    {
      print "Restore succeeded\n";
    }
    else
    {
      print "Restore failed\n";
    }
  }
  elsif ( 3 eq $theCommandID )
  {
    usage();
  }
  else
  {
    print "Synching\n\n";
  }
}

#----------------------------------------------------------------------------
# Check Parameters 
#----------------------------------------------------------------------------
sub checkParameters
{
  if
  (
    ("list" ne $sCOMMAND) and
    ("checksum" ne $sCOMMAND) and
    ("delete" ne $sCOMMAND) and
    ("save" ne $sCOMMAND) and
    ("install" ne $sCOMMAND) and
    ("rollback" ne $sCOMMAND) and
    ("download" ne $sCOMMAND) and
    ("upload" ne $sCOMMAND) and
    ("download-file" ne $sCOMMAND) and
    ("upload-file" ne $sCOMMAND) and
    ("backup" ne $sCOMMAND) and
    ("restore" ne $sCOMMAND) and
    ("sync" ne $sCOMMAND)
  )
  {
    &usage();
  }
    
  if ( "list" eq $sCOMMAND )
  {
    &listConfigurations();
  }
    
  if ( "checksum" eq $sCOMMAND )
  {
    &checksumConfiguration($sArg1);
  }
    
  if ( "delete" eq $sCOMMAND )
  {
    &deleteConfiguration($sArg1);
  }
    
  if ( "save" eq $sCOMMAND )
  {
    if ( "" eq $sArg1 )
    {
      $sArg1 = generateConfigName();
    }
    &saveConfiguration($sArg1, &saveModeFromArg($sArg2));
  }
    
  if ( "install" eq $sCOMMAND )
  {
    &installConfiguration($sArg1);
  }
    
  if ( "rollback" eq $sCOMMAND )
  {
    &rollbackConfiguration();
  }
    
  if ( "download" eq $sCOMMAND )
  {
    &downloadConfiguration($sArg1, $sArg2);
  }

  if ( "upload" eq $sCOMMAND )
  {
    &uploadConfiguration($sArg1, $sArg2);
  }

  if ( "download-file" eq $sCOMMAND )
  {
    &downloadFile($sArg1, $sArg2);
  }

  if ( "upload-file" eq $sCOMMAND )
  {
    &uploadFile($sArg1, $sArg2);
  }

  if ( "backup" eq $sCOMMAND )
  {
    $configName = generateConfigName();
    $localFile = $configName;

    print "Backing up configuration $configName\n";
  
    $success = &backupConfiguration($configName, $localFile, 1);
    if ( 1 == $success )
    {
      print "Backup succeeded\n";
    }
    else
    {
      print "Backup failed\n";
    }
  }

  if ( "restore" eq $sCOMMAND )
  {
    print "Restoring configuration $sArg1\n";
    $success = &restoreConfiguration($sArg1, 0, 1);
    if ( 1 == $success )
    {
      print "Restore succeeded\n";
    }
    else
    {
      print "Restore failed\n";
    }
  }

  if ( "sync" eq $sCOMMAND )
  {
    &syncConfiguration(&syncModeFromArg($sArg1));
  }
}

#----------------------------------------------------------------------------
# sub usage()
#----------------------------------------------------------------------------
sub usage()
{
  my ($subKey) = (@_);

  print "Usage: ConfigSync.pl host port uid pwd command [command_args]\n";
  print "    command\n";
  print "    --------\n";

  if ( ("" eq $subKey) or ("list" eq $subKey) )
  {
    print "    list\n";
    print "              Lists available configuration files on the server.\n";
    print "        Args: None\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("checksum" eq $subKey) )
  {
#    print "    checksum  config_name\n";
#    print "              Retrieves the checksum for the given configuration file.\n";
#    print "\n";
  }
  if ( ("" eq $subKey) or ("save" eq $subKey) )
  {
    print "    save      Creates a snapshot of the current configuration.\n";
    print "        Args: config_name [full | high | base]\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("install" eq $subKey) )
  {
    print "    install   Installs a given configuration file.\n";
    print "        Args: config_name\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("rollback" eq $subKey) )
  {
    print "    rollback  Performs a rollback to the last loaded configuration.\n";
    print "        Args: None\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("delete" eq $subKey) )
  {
    print "    delete    Deletes a given configuration file.\n";
    print "        Args: config_name\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("download" eq $subKey) )
  {
    print "    download  Downloads a given configuration file from the server.\n";
    print "        Args: config_name local_file\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("upload" eq $subKey) )
  {
    print "    upload    Uploads a configuration to the server from the client machine.\n";
    print "        Args: local_file config_name\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("download-file" eq $subKey) )
  {
    print "download-file Downloads a given file file from the server.\n";
    print "        Args: remote_file local_file\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("upload-file" eq $subKey) )
  {
    print "  upload-file Uploads a file to the server from the client machine.\n";
    print "        Args: local_file remote_file\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("sync" eq $subKey) )
  {
    print "    sync      Signals a configuration sync between HA devices.\n";
    print "        Args: [basic | running | all]\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("backup" eq $subKey) )
  {
    print "    backup    Saves configuration and downloads the configuration file.\n";
    print "        Args: None\n";
    print "\n";
  }
  if ( ("" eq $subKey) or ("restore" eq $subKey) )
  {
    print "    restore   Restores a configuration from the client machine.\n";
    print "        Args: local_file\n";
  }
  exit(1);
}

#============================================================================
#
# Helper Methods
#
#============================================================================

#----------------------------------------------------------------------------
# sub generateConfigName
#----------------------------------------------------------------------------
sub generateConfigName()
{
  ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
  $year += 1900;
  $sName = sprintf("%s-%04d%02d%02d_%02d%02d%02d.ucs", $sHost, $year, $mon, $mday, $hour, $min, $sec);
  return $sName;
}

#----------------------------------------------------------------------------
# sub saveModeFromArg
#----------------------------------------------------------------------------
sub saveModeFromArg()
{
  my ($sSaveModeArg) = (@_);
  my $sSaveMode = $SAVE_FULL;
  
  if ( ("full" ne $sSaveModeArg) and ("high" ne $sSaveModeArg) and ("base" ne $sSaveModeArg) )
  {
    $sSaveModeArg = "full";
  }

  if ( "full" eq $sSaveModeArg )
  {
    $sSaveMode = $SAVE_FULL;
  }
  elsif ( "high" eq $sSaveModeArg )
  {
    $sSaveMode = $SAVE_HIGH_LEVEL_CONFIG;
  }
  elsif ( "base" eq $sSaveModeArg )
  {
    $sSaveMode = $SAVE_BASE_LEVEL_CONFIG;
  }
  return $sSaveMode;
}

#----------------------------------------------------------------------------
# syncModeFromArg
#----------------------------------------------------------------------------
sub syncModeFromArg()
{
  my $sSyncModeArg = @_;
  my $sSyncMode = $CONFIGSYNC_ALL;

  if ( ("basic" ne $sSyncModeArg) and ("running" ne $sSyncModeArg) and ("all" ne $sSyncModeArg) )
  {
    $sSyncModeArg = "all";
  }
  
  if ( "all" eq $sSyncModeArg )
  {
    $sSyncMode = $CONFIGSYNC_ALL;
  }
  if ( "basic" eq $sSyncModeArg )
  {
    $sSyncMode = $CONFIGSYNC_BASIC;
  }
  if ( "running" eq $sSyncModeArg )
  {
    $sSyncMode = $CONFIGSYNC_RUNNING;
  }

  return $sSyncMode;
}


#============================================================================
#
# Command Methods
#
#============================================================================

#----------------------------------------------------------------------------
# sub listConfigurations
#----------------------------------------------------------------------------
sub listConfigurations()
{
  $soap_response = $ConfigSync->get_configuration_list();
  if ( $soap_response->fault )
  {
    print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
  }
  else
  {
    my @ConfigFileEntryList = @{$soap_response->result};
    print "Available Configurations:\n";
    my $configNumber = 0;
    foreach my $ConfigFileEntry (@ConfigFileEntryList)
    {
      print "    (",
        substr($ConfigFileEntry->{"file_datetime"}, 0, -1),
        ") : '",
        $ConfigFileEntry->{"file_name"},
        "'\n";
      $configNumber++;
    }
  }
}

#----------------------------------------------------------------------------
# sub checksumConfiguration
#----------------------------------------------------------------------------
sub checksumConfiguration()
{
  my ($configName, $quiet) = (@_);
  my $success = 0;

  if ( "" eq $configName )
  {
    &usage("checksum");
  }

  eval
  {
    $soap_response = $ConfigSync->get_configuration_checksum
    (
      SOAP::Data->name(filename => $configName)
    );
  };

  if ( $soap_response and $soap_response->fault )
  {
    if ( 1 != $quiet )
    {
      print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
    }
  }
  else
  {
    $success = 1;
    $checksum = $soap_response->result;
    if ( 1 != $quiet )
    {
      print "Configuration '$sConfigName' checksum: '$checksum'\n";
    }
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub deleteConfiguration
#----------------------------------------------------------------------------
sub deleteConfiguration()
{
  my ($configName, $quiet) = (@_);
  my $success = 0;

  if ( "" eq $configName )
  {
    &usage("delete");
  }
  
  eval
  {
    $soap_response = $ConfigSync->delete_configuration
    (
      SOAP::Data->name(filename => $configName)
    );
  };

  if ( $soap_response and $soap_response->fault )
  {
    if ( 1 != $quiet )
    {
      print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
    }
  }
  else
  {
    $success = 1;
    if ( 1 != $quiet )
    {
      print "Configuration '$configName' deleted successfully!\n";
    }
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub saveConfiguration
#----------------------------------------------------------------------------
sub saveConfiguration()
{
  my ($configName, $saveMode, $quiet) = (@_);
  my $success = 0;

  if ( ("" eq $configName) or ("" eq $saveMode) )
  {
    &usage("save");
  }
  
  $soap_response = $ConfigSync->save_configuration
  (
    SOAP::Data->name(filename => $configName),
    SOAP::Data->name(save_flag => $saveMode)
  );
  if ( $soap_response->fault )
  {
    if ( 1 != $quiet )
    {
      print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
    }
  }
  else
  {
    $success = 1;
    if ( 1 != $quiet )
    {
      print "Configuration '$configName' saved successfully!\n";
    }
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub installConfiguration
#----------------------------------------------------------------------------
sub installConfiguration()
{
  my ($configName, $quiet) = (@_);
  my $success = 0;

  if ( "" eq $configName )
  {
    &usage("install");
  }

  eval
  {
    $soap_response = $ConfigSync->install_configuration
    (
      SOAP::Data->name(filename => $configName)
    );
  };

  if ( $soap_response and $soap_response->fault )
  {
    if ( 1 != $quiet )
    {
      print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
    }
  }
  else
  {
    $success = 1;
    if ( 1 != $quiet )
    {
      print "Configuration '$configName' installed successfully!\n";
    }
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub rollbackConfiguration
#----------------------------------------------------------------------------
sub rollbackConfiguration()
{
  my ($quiet) = (@_);
  my $success = 0;

  eval
  {
    $soap_response = $ConfigSync->rollback_configuration();
  };

  if ( $soap_response and $soap_response->fault )
  {
    if ( 1 != $quiet )
    {
      print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
    }
  }
  else
  {
    $success = 1;
    if ( 1 != $quiet )
    {
      print "Configuration rollback successful!\n";
    }
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub downloadConfiguration
#----------------------------------------------------------------------------
sub downloadConfiguration()
{
  my ($configName, $localFile, $quiet) = (@_);
  $success = 0;

  if ( "" eq $localFile )
  {
    $localFile = $configName;
  }

  if ( "" eq $configName )
  {
    &usage("download");
  }

  open (LOCAL_FILE, ">$localFile") or die("Can't open $localFile for output: $!");
  binmode(LOCAL_FILE);

  my $file_offset = 0;
  my $chunk_size = $defaultChunkSize;
  my $chain_type = $FILE_UNDEFINED;
     my $bContinue = 1;

     print "\n";
  while ( 1 == $bContinue )
  {
    $soap_response = $ConfigSync->download_configuration
    (
      SOAP::Data->name(config_name => $configName),
      SOAP::Data->name(chunk_size => $chunk_size),
      SOAP::Data->name(file_offset => $file_offset)
    );

    if ( $soap_response->fault )
    {
      if ( 1 != $quiet )
      {
        print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
      }
      $bContinue = 0;
    }
    else
    {
      $FileTransferContext = $soap_response->result;
      $file_data = $FileTransferContext->{"file_data"};
      $chain_type = $FileTransferContext->{"chain_type"};
      @params = $soap_response->paramsout;
      $file_offset = @params[0];

      # Append Data to File
      print LOCAL_FILE $file_data;

#      if ( 1 != $quiet )
#      {
        print "Bytes Transferred: $file_offset\n";
#      }

      if ( ("FILE_LAST" eq $chain_type) or
           ("FILE_FIRST_AND_LAST" eq $chain_type) )
      {
        $bContinue = 0;
        $success = 1;
      }
    }
  }
  print "\n";

  close(LOCAL_FILE);

  return $success;
}

#----------------------------------------------------------------------------
# sub uploadConfiguration
#----------------------------------------------------------------------------
sub uploadConfiguration()
{
  my ($localFile, $configName, $quiet) = (@_);
  $success = 0;

  if ( "" eq $configName )
  {
    $configName = $localFile;
  }

  if ( "" eq $localFile )
  {
    &usage("upload");
  }

  $bContinue = 1;
  $chain_type = $FILE_FIRST;
  $preferred_chunk_size = $defaultChunkSize;
  $chunk_size = $defaultChunkSize;
  $total_bytes = 0;

  open(LOCAL_FILE, "<$localFile") or die("Can't open $localFile for input: $!");
  binmode(LOCAL_FILE);

  while (1 == $bContinue )
  {
    $file_data = "";
    $bytes_read = read(LOCAL_FILE, $file_data, $chunk_size);

    if ( $preferred_chunk_size != $bytes_read )
    {
      if ( $total_bytes == 0 )
      {
        $chain_type = $FILE_FIRST_AND_LAST;
      }
      else
      {
        $chain_type = $FILE_LAST;
      }
      $bContinue = 0;
    }
    $total_bytes += $bytes_read;

    $FileTransferContext =
    {
      file_data => SOAP::Data->type(base64 => $file_data),
      chain_type => $chain_type
    };


    $soap_response = $ConfigSync->upload_configuration
    (
      SOAP::Data->name(config_name => $configName),
      SOAP::Data->name(file_context => $FileTransferContext)
    );

    if ( $soap_response->fault )
    {
#      if ( 1 != $quiet )
#      {
        print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
#      }
      $success = 0;
      $bContinue = 0;
    }
    else
    {
#      if ( 1 != $quiet )
#      {
        print "Uploaded $total_bytes bytes\n";
#      }
      $success = 1;
    }

    $chain_type = $FILE_MIDDLE;
  }
  print "\n";

  close(LOCAL_FILE);

  return $success;
}

#----------------------------------------------------------------------------
# sub downloadFile
#----------------------------------------------------------------------------
sub downloadFile()
{
  my ($configName, $localFile, $quiet) = (@_);
  $success = 0;

  if ( "" eq $localFile )
  {
    $localFile = $configName;
  }

  if ( "" eq $configName )
  {
    &usage("download");
  }

  open (LOCAL_FILE, ">$localFile") or die("Can't open $localFile for output: $!");
  binmode(LOCAL_FILE);

  my $file_offset = 0;
  my $chunk_size = $defaultChunkSize;
  my $chain_type = $FILE_UNDEFINED;
     my $bContinue = 1;

     print "\n";
  while ( 1 == $bContinue )
  {
    $soap_response = $ConfigSync->download_file
    (
      SOAP::Data->name(file_name => $configName),
      SOAP::Data->name(chunk_size => $chunk_size),
      SOAP::Data->name(file_offset => $file_offset)
    );

    if ( $soap_response->fault )
    {
      if ( 1 != $quiet )
      {
        print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
      }
      $bContinue = 0;
    }
    else
    {
      $FileTransferContext = $soap_response->result;
      $file_data = $FileTransferContext->{"file_data"};
      $chain_type = $FileTransferContext->{"chain_type"};
      @params = $soap_response->paramsout;
      $file_offset = @params[0];

      # Append Data to File
      print LOCAL_FILE $file_data;

#      if ( 1 != $quiet )
#      {
        print "Bytes Transferred: $file_offset\n";
#      }

      if ( ("FILE_LAST" eq $chain_type) or
           ("FILE_FIRST_AND_LAST" eq $chain_type) )
      {
        $bContinue = 0;
        $success = 1;
      }
    }
  }
  print "\n";

  close(LOCAL_FILE);

  return $success;
}

#----------------------------------------------------------------------------
# sub uploadFile
#----------------------------------------------------------------------------
sub uploadFile()
{
  my ($localFile, $configName, $quiet) = (@_);
  $success = 0;

  if ( "" eq $configName )
  {
    $configName = $localFile;
  }

  if ( "" eq $localFile )
  {
    &usage("upload");
  }

  $bContinue = 1;
  $chain_type = $FILE_FIRST;
  $preferred_chunk_size = $defaultChunkSize;
  $chunk_size = $defaultChunkSize;
  $total_bytes = 0;

  open(LOCAL_FILE, "<$localFile") or die("Can't open $localFile for input: $!");
  binmode(LOCAL_FILE);

  while (1 == $bContinue )
  {
    $file_data = "";
    $bytes_read = read(LOCAL_FILE, $file_data, $chunk_size);

    if ( $preferred_chunk_size != $bytes_read )
    {
      if ( $total_bytes == 0 )
      {
        $chain_type = $FILE_FIRST_AND_LAST;
      }
      else
      {
        $chain_type = $FILE_LAST;
      }
      $bContinue = 0;
    }
    $total_bytes += $bytes_read;

    $FileTransferContext =
    {
      file_data => SOAP::Data->type(base64 => $file_data),
      chain_type => $chain_type
    };


    $soap_response = $ConfigSync->upload_file
    (
      SOAP::Data->name(file_name => $configName),
      SOAP::Data->name(file_context => $FileTransferContext)
    );

    if ( $soap_response->fault )
    {
#      if ( 1 != $quiet )
#      {
        print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
#      }
      $success = 0;
      $bContinue = 0;
    }
    else
    {
#      if ( 1 != $quiet )
#      {
        print "Uploaded $total_bytes bytes\n";
#      }
      $success = 1;
    }

    $chain_type = $FILE_MIDDLE;
  }
  print "\n";

  close(LOCAL_FILE);

  return $success;
}

#----------------------------------------------------------------------------
# sub syncConfiguration
#----------------------------------------------------------------------------
sub syncConfiguration()
{
  my ($syncFlag, $quiet) = (@_);
  my $success = 0;

  if ( "" eq $syncFlag )
  {
    &usage("sync");
  }

  $soap_response = $ConfigSync->synchronize_configuration
  (
    SOAP::Data->name(sync_flag => $syncFlag)
  );
  if ( $soap_response->fault )
  {
    if ( 1 != $quiet )
    {
      print $soap_response->faultcode, " ", $soap_response->faultstring, "\n";
    }
  }
  else
  {
    $success = 1;
    if ( 1 != $quiet )
    {
      print "Configuration synchronized successfully!\n";
    }
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub backupConfiguration
#----------------------------------------------------------------------------
sub backupConfiguration()
{
  my ($configName, $localFile, $quiet) = (@_);

  if ( "" eq $configName )
  {
    $configName = generateConfigName();
  }
  if ( "" eq $localFile )
  {
    $localFile = $configName;
  }

  if ( ("" eq $configName) or ("" eq $localFile) )
  {
    &usage("backup");
  }

  sleep(1);
  $success = &saveConfiguration($configName, $SAVE_FULL, $quiet);
  if ( 1 == $success )
  {
    sleep(1);
    $success = &downloadConfiguration($configName, $localFile, $quiet);
    if ( 1 == $success )
    {
      if ( 1 != $quiet )
      {
        print "Configuration file $configName successfully backed up.\n";
      }
    }
    sleep(1);
    $success = &deleteConfiguration($configName, $quiet);
  }
  return $success;
}

#----------------------------------------------------------------------------
# sub restoreConfiguration
#----------------------------------------------------------------------------
sub restoreConfiguration()
{
  my ($localFile, $doSync, $quiet) = (@_);

  $configName = $localFile;

  if ( ("" eq $configName) or ("" eq $localFile) )
  {
    &usage("restore");
  }

  sleep(1);
  $success = &uploadConfiguration($localFile, $configName, $quiet);
  if ( 1 == $success )
  {
    sleep(1);
    $success = &installConfiguration($configName, $quiet);
    if ( 1 == $success )
    {
      if ( ("1" eq $doSync) or ("y" eq $doSync) or ("Y" eq $doSync) )
      {
        # Give server time to recover from restart.
        sleep(5);
        &syncConfiguration(&syncModeFromArg("all"), $quiet);
      }
    }
    sleep(1);
    &deleteConfiguration($configName, $quiet);
  }
  return $success;
}
Published Mar 08, 2015
Version 1.0
devops
iControl
perl
No CommentsBe the first to comment