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.

PowerShell iApp Template Control

Problem this snippet solves:

The following PowerShell script illustrates how to support the BIG-IP .tmpl file format for Application Templates. It includes support for importing and exporting Application Templates to/from .tmpl format.

Code :

#----------------------------------------------------------------------------
# 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-2012
# 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.
#----------------------------------------------------------------------------
param (
  $BIGIP = $null,
  $User = $null,
  $Pass = $null,
  $Command = $null,
  $TemplateFile = $null,
  $TemplateName = $null,
  [switch]$Force = $false
)
$script:Dir = $(Split-Path $MyInvocation.MyCommand.Definition);
$script:Name = $($MyInvocation.MyCommand.Name);
#-------------------------------------------------------------------------
# function Show-Usage
#-------------------------------------------------------------------------
function Show-Usage()
{
  Write-Host @"
Usage: $($script:Name) [options]
         -BIGIP bigip_address
         -User  bigip_username
         -Pass bigip_password
         -Command [import|export|exportall] 
         -TemplateFile localfile
         -TemplateName name_of_template
         [-Force]
  
Examples

List local templates.
  .\$($script:Name) -BIGIP bigip -User user -Pass pass -Command import
  
Import local .tmpl file to BIG-IP.
  .\$($script:Name) -BIGIP bigip -User user -Pass pass -Command import -TemplateFile filename
  
List templates configured on BIG-IP.
  .\$($script:Name) -BIGIP bigip -User user -Pass pass -Command export
  
Export specified template to local .\Templates folder.
  .\$($script:Name) -BIGIP bigip -User user -Pass pass -Command export -TemplateName template_name
  
Export all templates to local .\Templates folder.  
  .\$($script:Name) -BIGIP bigip -User user -Pass pass -Command exportall
  
"@
  exit;
}


#----------------------------------------------------------------------------
function Get-NextToken()
#----------------------------------------------------------------------------
{
  param($Template = $null, $FirstToken);
  $Value = "";
  
  $idxStart = $Template.IndexOf($FirstToken);
  if ( -1 -ne $idxStart )
  {
    $idxStart += $FirstToken.Length + 1;
    
    $idxEnd = $Template.IndexOfAny( (" ", "`t", "`r", "`n"), $idxStart);
    if ( -1 -ne $idxEnd )
    {
      $Value = $Template.SubString($idxStart, $idxEnd - $idxStart);
    }
  }
  $Value;
}

#----------------------------------------------------------------------------
function Extract-Section()
#----------------------------------------------------------------------------
{
  param($Template = $null,
    $Section = $null
  );
  
  $Value = $null;
  
  $idxStart = $Template.IndexOf("$Section {");
  $idxEnd = -1;
  if ( -1 -ne $idxStart )
  {
    $idxStart += $Section.Length + 2;
    $p = 1;
    for($i = $idxStart; $i -lt $Template.Length; $i++)
    {
      switch ($Template[$i])
      {
        "{" {
          $p++;
        }
        "}" {
          $p--; 
          if ( $p -eq 0 ) {
            $idxEnd = $i;
            $i = $Template.Length;
            break;
          }
        }
      }
    }
    if ( -1 -ne $idxEnd )
    {
      #Write-Host "START: $idxStart, END: $idxEnd, LEN: $($idxEnd-$idxStart)";
      $Value = $Template.SubString($idxStart, $idxEnd-$idxStart).Trim();
    }
  }
  $Value;
}

#----------------------------------------------------------------------------
function New-Template()
#----------------------------------------------------------------------------
{
  $t = 1 | Select Name, Description, HtmlHelp, Implementation, Presentation;
  $t;
}

#----------------------------------------------------------------------------
function Parse-Template()
#----------------------------------------------------------------------------
{
  param($Template = $null);
  $t = $null;
  
  if ( $Template.StartsWith("sys application template") )
  {
    
    #Write-Host "Name: '$name'";
  
    $t = New-Template;
    
    $t.Name = Get-NextToken $Template "sys application template";
    $definition = Extract-Section $Template "definition";
    $t.HtmlHelp       = Extract-Section $definition "html-help";
    $t.Implementation = Extract-Section $definition "implementation";
    $t.Presentation   = Extract-Section $definition "presentation";
  }
  $t;
}

#----------------------------------------------------------------------------
function Import-Template()
#----------------------------------------------------------------------------
{
  param(
    $TemplateFile = $null,
    [Boolean]$Force = $false
  );
  
  $content = [System.IO.File]::ReadAllText((Resolve-Path $TemplateFile).Path) 
  $t = Parse-Template -Template $content;
  $bContinue = $true;
  
  if ( $null -ne $t )
  {
    Write-Host "CREATING Template: '$($t.Name)'...";
    try 
    {
      (Get-F5.iControl).ManagementApplicationTemplate.create( @($t.Name) );
    }
    catch
    {
      $bContinue = $Force;
      if ( $bContinue )
      {
        Write-Host "Template exists, overwriting...";
      }
      else
      {
        Write-Host "Template exists, stopping import.  Use '-Force' to overwrite.";
      }
    }
    
    if ( $bContinue )
    {
      Write-Host "SETTING IMPLEMENTATION...";
      (Get-F5.iControl).ManagementApplicationTemplate.set_action_implementation( @($t.Name), @( @("definition")), @( @($t.Implementation)) );
      Write-Host "SETTING PRESENTATION...";
      (Get-F5.iControl).ManagementApplicationTemplate.set_action_presentation( @($t.Name), @( @("definition")), @( @($t.Presentation)) );
      Write-Host "SETTING PRESENTATION HELP...";
      (Get-F5.iControl).ManagementApplicationTemplate.set_action_presentation_help( @($t.Name), @( @("definition")), @( @($t.HtmlHelp)) );
    }
  }
}

#----------------------------------------------------------------------------
function Export-Template()
#----------------------------------------------------------------------------
{
  param(
    $TemplateFile = $null,
    $TemplateName = $null,
    [Boolean]$Force = $false
  );
  
  $t = New-Template;
  $t.Name = $TemplateName;
  
  $descA = (Get-F5.iControl).ManagementApplicationTemplate.get_description( @($t.Name) );
  $implAofA = (Get-F5.iControl).ManagementApplicationTemplate.get_action_implementation( @($t.Name), @( @("definition")) );
  $presAofA = (Get-F5.iControl).ManagementApplicationTemplate.get_action_presentation( @($t.Name), @( @("definition")) );
  $helpAofA = (Get-F5.iControl).ManagementApplicationTemplate.get_action_presentation_help( @($t.Name), @( @("definition")) );

  $t.Description = $descA[0];
  if ( $t.Description.Length -eq 0 ) { $t.Description = "none"; }
  $t.Implementation = $implAofA[0][0];
  $t.Presentation = $presAofA[0][0];
  $t.HtmlHelp = $helpAofA[0][0];

  $s = "sys application template ";
  $s += Split-Path -Leaf $t.Name;
  $s += " {`r`n";
  # Begin Action
  $s += " "*4;
  $s += "actions {`r`n";
  
  # Begin definition
  $s += " "*8;
  $s += "definition {`r`n";

  # Help
  $s += " "*12;
  $s += "html-help {`r`n";
  $s += $t.HtmlHelp;
  if ( $t.HtmlHelp.Length -gt 0 ) { $s += "`r`n"; }
  $s += "}`r`n";
  
  # Implementation
  $s += " "*12;
  $s += "implementation {`r`n";
  $s += $t.Implementation;
  if ( $t.Implementation.Length -gt 0 ) { $s += "`r`n"; }
  $s += "}`r`n";
  
  # Presentation
  $s += " "*12;
  $s += "presentation {`r`n";
  $s += $t.Presentation;
  if ( $t.Presentation.Length -gt 0 ) { $s += "`r`n"; }
  $s += "}`r`n";
  
  $s += " "*12;
  $s += "role-acl none`r`n";
  $s += " "*12;
  $s += "run-as none`r`n";
  
  # End Definition
  $s += " "*8;
  $s += "}`r`n";
  
  # End Action
  $s += " "*4;
  $s += "}`r`n";

  $s += " "*4;
  $s += "description $($t.Description)`r`n";
  $s += " "*4;
  $s += "partition $( (Split-Path $t.Name).SubString(1) )`r`n";
  
  #End template
  $s += "}";

  if ( $null -eq $TemplateFile )
  {
    $TemplateFile = ".\Templates\" + (Split-Path -Leaf $t.Name) + ".tmpl";
  }
 
  $s | Out-File $TemplateFile;
  
  Write-Host "Template '$TemplateName' saved to file '$TemplateFile'";
}

function Export-AllTemplates()
{
  param(
    [Boolean]$Force = $false
  );
  
  $templates = List-Templates;
  foreach($template in $templates)
  {
    Export-Template -TemplateName $template -Force $Force;
  }
}

#----------------------------------------------------------------------------
function List-Templates()
#----------------------------------------------------------------------------
{
  (Get-F5.iControl).ManagementApplicationTemplate.get_list();
}

function List-LocalTemplates()
{
  "Local Templates Available for Import";
  "-------------------------";
  $files = Get-ChildItem ".\Templates";
  foreach($file in $files) { $file.Name; }
}

#----------------------------------------------------------------------------
function Do-Initialize()
#----------------------------------------------------------------------------
{
  if ( (Get-PSSnapin | Where-Object { $_.Name -eq "iControlSnapIn"}) -eq $null )
  {
    Add-PSSnapIn iControlSnapIn
  }
  $success = Initialize-F5.iControl -HostName $BIGIP -Username $User -Password $Pass;
  
  return $success;
}

#-------------------------------------------------------------------------
# Main Application Logic
#-------------------------------------------------------------------------
if ( ($BIGIP -eq $null) -or ($User -eq $null) -or ($Pass -eq $null) )
{
  Show-Usage;
}

if ( Do-Initialize )
{
  if ( $null -eq $Command )
  {
    Show-Usage;
  }
  else
  {
    switch ($Command)
    {
      "import"
      {
        if ( $null -eq $TemplateFile )
        {
          List-LocalTemplates;
        }
        else
        {
          if ( [System.IO.File]::Exists((Resolve-Path $TemplateFile).Path) )
          {
            Import-Template -TemplateFile $TemplateFile ($Force -eq $True);
          }
          else
          {
            Write-Error "ERROR: File '$TemplateFile' Does Not Exist!";
          }
        }
      }
      "export"
      {
        if ( $null -eq $TemplateName )
        {
          List-Templates;
        }
        elseif ( $null -ne $TemplateName )
        {
          Export-Template -TemplateFile $TemplateFile -TemplateName $TemplateName ($Force -eq $True)
        }
        else
        {
          Show-Usage;
        }
      }
      "exportall"
      {
        Export-AllTemplates ($Force -eq $True)
      }
      default
      {
        Show-Usage;
      }
    }
  }
}
Published Mar 09, 2015
Version 1.0
devops
iApps
iControl
microsoft powershell with icontrol
No CommentsBe the first to comment