Attune Documentation¶

Everything you need to know about Attune.

First steps¶

Are you new to Attune or to scripting? This is the place to start!

From scratch: Overview
Tutorial: Linux or macOS

Getting Help¶

Having trouble? We’d like to help!

Try the FAQ - it’s got answer to many common questions
Connect to our Discord Community.
Report bugs with Attune in our ticket tracker.

How the documentation is organised¶

Attune has a lot of documentation. A high-level overview of how it’s organised will help you know where to look for certain things:

Tutorials take you by the hand through a series of steps to create jobs. Start here if you’re new to Attune or scripting. Also look at the “First steps”.
Topic guides discuss key topics and concepts at a fairly high level and provide useful background information and explanation.
Reference guides contain technical reference of Attune. They describe how it works and how to use it but assume that you have a basic understanding of key concepts.
How-to guides are recipes. They guide you through the steps involved in addressing key problems and use-cases. They are more advanced than tutorials and assume some knowledge of how Attune works.

Getting Started¶

New to Attune? Or to scripting in general? Well, you came to the right place: read this material to quickly get up and running.

Attune at a glance¶

Attune automates and orchestrates scripts, commands, and processes exactly as they would be manually typed into a device.

Easily and quickly develop simple and bespoke IT/OT automation with ServerTribe’s Attune.

Build with Popular Scripting Languages
Rapidly Build Automated Processes
Portable and Sharable IP
Full-stack Multi-server Orchestration
Centralised Scheduler
Automated Document Generation

Attune is our flexible IT Automation & Orchestration solution, a self-documenting central source of reusable proven processes, files and backups to build and maintain your IT/OT infrastructure. Attune is used on enterprise critical infrastructure through to NUCs and home network infrastructure.

Video: Demonstration of creating an automated process in Attune.

If you’d like a live online demonstration of Attune and the opportunity to ask questions, please contact ServerTribe.

Framework and methodology¶

Attune is divided into 3 workspaces:

Design,
Plan, and
Run.

Video: Intro to Attune in 2 Minutes

Design

The Design Workspace is where you create your automated and reusable building blocks.

Plan

The Plan Workspace is where you’ll plan a job to run a blueprint and which values are connected to the parameters in the blueprint. A single blueprint can be used for many jobs with different values.

Schedules can be planned to orchestrate multiple Jobs.

Run

The Run Workspace is where you control your Jobs, Debug your jobs and view your historical logs.

Install Attune¶

Start using ServerTribe’s Attune RIGHT NOW, it’s quick and easy to get started.

Download Attune App

If you want the Attune server platform, please contact ServerTribe.

Engage the community¶

Creating your first Linux or macOS Project¶

Let’s learn by example.

Throughout this tutorial, we’ll walk you through the creation and running of an automated process.

It’ll consist of three parts:

Design
Plan
Run

We’ll assume you have Attune installed already. This tutorial is written for Attune v23.7.3 targeting a Linux or macOS machine.

Note

If you’re having trouble going through this tutorial, please head over to the Getting Help section.

Part 1 - Design¶

Create a project¶

In the Attune application, navigate to the Design workspace and create a new project.

Open the Project dropdown
Select New Project at the bottom of the list
Choose Create blank project
Enter a Project Name such as: Linux Tutorial
Select Create
Select Switch Project

This will create and select the new Project. Verify that the new project is selected in the Project dropdown.

Create parameters¶

Open the Parameters drawer in the Design workspace and create the parameters listed in the table below.

Parameters¶
Type	Name
Linux/Unix Node	`Tutorial Node`
Linux/Unix Credential	`Tutorial User`
Basic Node	`Tcp Ping Node`
Text	`Continue Tutorial`

Close the Parameters drawer when you’re finished.

Create files¶

Open the Files drawer in the Design workspace and create the two files as per below.

Firstly, create a version controlled file:

Select Create File Archive
Set the Type: Version Controlled Files
Enter the Name: Tutorial Config
Select Create

Create a file within the file you created:

Select the root folder ./
Select Create File
Enter the Name: config.cfg
Select Create
Select the config.cfg you created
Enter the code below

Tutorial Host: {node.hostname}
Tutorial User: {credentials.user}

Select Save

Secondly, create a large file archive:

Select Create File Archive
Set the Type: Version Controlled Files
Enter the Name: Tutorial Large File
Select Create
Drag a file and drop it on the Replace Contents section.

Close the Files drawer when you’re finished.

Create a blueprint¶

Create a new blueprint.

Select Create Blueprint
Set the Blueprint Name: Linux Tutorial Blueprint
Select Create

Create the steps¶

Execute Linux script¶

Select the blueprint you created. On the step select the Create Step Option.

Note

The following script will intentionally fail to later demonstrate fixing a running job.

Script:

echo "The operation failed."

exit 1

Select Save

Note

At this point you can skip to Part 2.

Execute Linux script with responses¶

Select the previous step you created. On the step select the Create Step Option.

Execute Linux Script With Responses¶
Type	`Execute Linux Script With Responses`
Name	`Linux Tutorial execute linux step with responses`
Target Node	`Tutorial Node`
Credential	`Tutorial User`
Prompt Response	`Continue?==={continueTutorial}`

Script:

echo "Continue?"
read response

lowercase_string=$(echo "$response" | tr '[:upper:]' '[:lower:]')

if [ "$lowercase_string" == "yes" ] || [ "$lowercase_string" == "y" ]; then
    echo "You responded: {continueTutorial}!"
else
    echo "You responded: {continueTutorial}! This step will stop!"
    exit 1
fi

Select Save

Tcp ping¶

Select the previous step you created. On the step select the Create Step Option.

Tcp Ping¶
Type	`Tcp Ping`
Name	`Linux Tutorial tcp ping`
Target Node	`Tcp Ping Node`

Select Save
Drag the step to the beginning of the Blueprint

Group step¶

Select the last step in the Blueprint. On the step select the Create Step Option.

Group Step¶
Type	`Group Step`
Name	`Linux Tutorial group step`

Select Save

Push files¶

Select the group step in the Blueprint. On the step select the Create Step Option. Select > Under to create the step in the group step.

Push Files¶
Type	`Push Files`
Name	`Linux Tutorial push files`
Target Node	`Tutorial Node`
Credential	`Tutorial User`
Files	`Tutorial Large File`
Remote Path	`~/attuneTutorial/`

Select Save

Push compiled files¶

Select the previous step you created. On the step select the Create Step Option.

Push Compiled Files¶
Type	`Push Compiled Files`
Name	`Linux Tutorial push compiled files`
Target Node	`Tutorial Node`
Credential	`Tutorial User`
Files	`Tutorial Config`
Remote Path	`~/attuneTutorial/`

Check the config.cfg file.

config.cfg¶
Mako Parameter	Type	Attune Parameter
`node`	`Linux/Unix Node`	`Tutorial Node`
`credentials`	`Linux/Unix Credential`	`Tutorial User`

Select Test Dynamic File Generation and verify there are no errors in the Mako script
Select Save

Cleanup the files¶

Select the previous step you created. On the step select the Create Step Option.

Script:

directory="~/attuneTutorial/"

if [ -d $directory ]; then
    cd $directory
    echo "Listing all files in $directory:"
    ls -ltrh
    echo "Displaying the contents of config.cfg:"
    cat config.cfg
    echo "Moving out of $directory to prepare for deletion."
    cd ~
    echo "Removing the directory $directory and its contents."
    rm -rf $directory
else
    echo "$directory doesn't exist!"
fi

Select Save

Link existing step¶

Select the group step in the Blueprint. On the step select the Link Existing Step Option. Select V After to link a step after the group step.

Set Step: Linux Tutorial execute linux step
Select Link

Commit your project changes¶

Select Commit
Set the Commit Message: Created Linux Tutorial Blueprint
Select Commit

Congratulations, you have created your Blueprint.

Part 2 - Plan¶

In the Attune application, navigate to the Plan workspace.

Create values¶

Open the Values drawer in the Design workspace and create the three values required for the job.

Linux/Unix Node¶

Select Create Value
Populate the form

Linux/Unix Node¶
Type	Linux/Unix Node
Name	{name of your device}
IP Address	{device IP address}
Hostname	{hostname}
Domain Name	{domain name}

Select Create

Linux/Unix Credential¶

Select Create Value
Populate the form

Linux/Unix Credential¶
Type	Linux/Unix Credential
Name	{name of your user}
User	{username}

Select Create
Find the value and update the Password

Basic Node¶

Select Create Value
Populate the form

Linux/Unix Node¶
Type	Basic Node
Name	`search.brave.com`
IP Address	`search.brave.com`
Hostname	`search`
Domain Name	`brave.com`

Select Create

Text¶

Select Create Value
Populate the form

Text¶
Type	Text
Name	`yes`
Variable	`yes`

Select Create

Close the Values drawer when you’re finished.

Create the tree¶

Create the tree of your environment.

Select Create Tree
Set the Name: {environment name}
Select Create
Expand the dropdown on the first node in your tree and select Create Node
Set the Name: {device hostname}
Select Create

Create the plan¶

Create the plan for your tutorial job.

Expand the dropdown on the device node and select Create Plan
Set the Name: {hostname} Linux Tutorial Job
Select Create
Select the plan you created
Add Blueprint
Select Save
Populate the Values

Plan Inputs¶
Parameter	Value
Tutorial Node	select the device
Tutorial User	select the credentials
Tcp Ping Node	select the ping node `search.brave.com`
Continue Tutorial	select `yes`

Select Save

Congratulations, you have created your Plan.

Part 3 - Run¶

In the Attune application, navigate to the Run workspace.

Search for and select you Job
Select Reset Job
Select play

Fix the error¶

Fix the script on the failed step and resume the job.

Select the failed step Linux Tutorial execute linux step
Select Edit Step
Replace the Script with the following

echo "This step works!"

Select Save
Select Run only this step
Verify the step run successfully
Select Run job from select step

Reset the Job and archive the current logs¶

Review the logs for each steps then archive.

Inspect each step
Select Reset the job and archive the current logs
Select the History tab
Inspect the most recent log

Tutorial completed¶

Congratulations, you have completed the tutorial.

Using Attune¶

Introductions to all the key parts of Attune you’ll need to know:

IT/OT Automation and Orchestration¶

Attune automates and orchestrates scripts, commands, and processes exactly as they would be manually typed into a device.

Attune is an agentless solution that connects to nodes and operating systems with WinRM and ssh protocols. Attunes steps are written in the popular shell scripting languages:

Batch
PowerShell
Bash
Python
Perl
SQL

Rapidly build your first Attune automated jobs copying your existing scripts to begin your automation journey.

If you don’t have Attune, Download Attune App.

If you want the Attune Server platform, please contact ServerTribe.

Rapidly Debug Your Scripts and Continue The Job

Attune provides the ability to modify scripts in the steps during a running job without requiring the job to be restarted.

Traditionally an error in a procedure could stop the entire process, requiring the process to be restarted. By writing steps that remain unchanged when run multiple times, these steps can be tested and re-tested without refreshing the system and the job can be continued.

Rapidly deliver automated procedures with Attune’s simple in job debugging and editing.

Portable, Sharable Procedures

Your team can export Attune’s procedures to a file, and then import them into another Attune. These procedure exports contain all the scripts, comments, and even archives or installers, ready to drop into another Attune server and execute.

Attune has variables, used to create reusable procedures.

Variables take the place of servers, strings, passwords, usernames, and more.

Reusable procedures reduces time, effort, and improve quality assurance.

Full-stack Orchestration

Build physical servers from bare metal with DELL’s iDRAC. Attune uses the redfish APIs to shutdown, boot, reboot, and install the operating system on physical servers.

Spin up and rebuild virtual machines, increase disk space, add network adapters, and install operating systems.

iDRAC
ESXi
VMWare Workstation
oVirt
RHEV
KVM
Parallels
VirtualBox

Powerfully Simple Multi-Server Coordination

Attune can run steps on multiple servers, as multiple users, within the one Job, enabling environment wide coordination.

Simplify Scheduled Tasks

Simplify your teams management of scheduled tasks across the data centre. Attune has a built in job scheduler that centralises the management of scheduled tasks across Windows and Linux servers.

Automated Document Generation

Attune inherently captures and centralises your support team’s knowledge.

Captures logs of jobs in a centralised location. Historical logs are archived for future investigation.

Industry ITIL requirements have driven Attunes unique design to generate and export the step by step documentation.

Your team can export the automated procedures as instructions to run the steps manually. This is helpful for working in an isolated environment without Attune access.

Learn more, book an online demonstration!

Architecture and Deployment¶

This page provides a high level overview of Attune’s software architecture.

Attune is available as a desktop application or deployed as a Server for the web application.

Attune Desktop Application¶

The Attune App that can be downloaded, installed and run in minutes. The Attune App only runs jobs while the app is open. The Attune application is supported on the follow operating systems:

MacOS
Windows

App Resource Requirements:

Minimum: 1 CPU, 512MB RAM, 500MB

Recommended: 2 CPUs, 2GB RAM, 1GB

Download Attune App

Attune Server and Web Application¶

The Attune Server is a headless, standalone server running in a cloud or server environment, using a Web App as the admin interface. The following web browsers are supported:

Brave
Chrome
Mozilla Firefox
Microsoft Edge

Attune Server is deployed as a VM Template and is supported on the following operating systems:

RHEL 7
RHEL 8
CentOS 7
CentOS 8
Oracle Linux 7
Oracle Linux 8

The following diagram shows two instances of Attune server deployed in a Pre-Production and Production environments.

https://www.servertribe.com/wp-content/uploads/2022/05/After_Attune-2.jpg

App Resource Requirements:

Minimum: 1 CPU, 512MB RAM, 6GB

Recommended: 8 CPUs, 8GB RAM, 500GB

Learn more, book an online demonstration!

Design Best Practices¶

Projects¶

Creating Projects

Ideally, you aim to initiate a Project with a defined purpose, crafting it as a modular building block for seamless integration into end-to-end automated workflows.

Use a name that describes the purpose of the Project. If the Project will be shared publicly, consider Search Engine Optimisation (SEO) when naming the Project. Attune generates the files for GitHub Pages to generate a website for your Project.

The following examples are Projects created to be modular building blocks:

The following examples link Blueprints from the above Projects to automate an end-to-end process:

Kickstart RHEL Red Hat Enterprise Linux on ESXi
Kickstart RHEL Red hat Enterprise Linux on oVirt

This promotes code reusability and makes it easier to update and maintain specific pieces of functionality.

Project Descriptions

Use the Project description to desscribe the purpose of the Project. A quality Project description encourages collaboration, maintainability, and knowledge transfer.

Project Management

You can version control your Projects, ensure you frequently commit your changes. Publish and push your commits to Git repositories. Leverage publicly shared Projects such as Attune Automation on GitHub.

Blueprints¶

Creating Blueprints

Blueprints are to complete a required process. Make best effort to use Parameters so that you minimise the number of Blueprints to maintain. Use a name that describes the process being performed. If the Project will be shared publicly, consider Search Engine Optimisation (SEO) when naming the Project. Attune generates the files for GitHub Pages to generate a website for your Project.

The following examples are Blueprints that perform a process and align with the purpose of the Kickstart RHEL Red Hat Enterprise Linux Project:

This promotes code reusability and makes it easier to update and maintain specific pieces of functionality.

Blueprint Descriptions

Use the Blueprint description to describe the process performed by the Blueprint. A quality Blueprint description encourages collaboration, maintainability, and knowledge transfer.

Steps¶

Break down your script into small, discrete steps, each dedicated to performing a specific action. Additionally, ensure that your scripts are designed to be idempotent, meaning they can be run multiple times without causing unexpected side effects. This approach not only enhances the clarity of your code but also simplifies the debugging process, making it more efficient and less error-prone.

Parameters¶

Using Parameters in Steps and Files greatly increases the flexibility of the Blueprints. Ensure that names are intuitive and that comments clearly describe the expected value to help users when populating the Plans.

Documentation Best Practices¶

Effective project communication is paramount, and Attune provides a robust platform to facilitate this.

This article outlines best practices for crafting clear and concise documentation.

Clear and Concise project Communication¶

The significance of clear and concise project communication cannot be overstated. It forms the foundation of successful software development. Documentation serves as a critical tool in aligning all stakeholders ensuring a shared understanding of project objectives and requirements. In its absence, miscommunication and confusion may emerge, resulting in delays, errors, and project setbacks.

Benefits of Clear Communication

Clear and concise project communication creates effective team collaboration. By offering precise instructions, guidelines, and expectations, documentation facilitates seamless teamwork, minimising misunderstandings and enhancing productivity and efficiency. Moreover, clear documentation expedites the onboarding of new team members, as they can swiftly grasp the project’s structure, codebase, and requirements.

Attune Documentation¶

The Attune platform empowers all users to add and modify comments and descriptions on all items from projects and Blueprints through to Values and Schedules. The comments and descriptions are easily accessed in the platform, however are also used to populate a repository README.md file and webpage documentation. The webpage documentation is rendered in GitHub Pages.

Attune’s support for Markdown makes it an ideal option for crafting clear and well-formatted documentation. Markdown is an intuitive lightweight markup language. Utilising Markdown can significantly improve the readability and visual aesthetics of the documentation.

Writing the project Description¶

A project description is a crucial component of any Attune project. It serves as the entry point for the project, providing an overview of its purpose, features, and more. Creating a comprehensive project description allows you to effectively communicate the project’s value and encourage collaboration with other developers.

1. Start with a project objective

Begin the project description with a brief objective of the project. Clearly state the purpose, goals, and intended audience of the project. This helps readers quickly understand the project and whether it aligns with their needs.

2. Include prerequisite instructions

Provide detailed instructions on prerequisite steps for the project. Include any dependencies, system requirements, and step-by-step instructions. This helps other developers get started with the project quickly and reduces potential issues related to installation. In this step, use numbered lists instead of bullet points.

3. Highlight key features

Showcase the key features and functionalities of the project. This lets readers quickly grasp what the project offers and its potential benefits. Use bullet points or concise descriptions to highlight the main features.

4. Provide usage examples

Include usage examples to help readers understand how to use the project effectively. This can include code snippets, command-line examples, or screenshots demonstrating the project in action. Real-world examples make it easier for readers to relate to the project and envision how it can solve their problems.

5. Document API references

If the project exposes an API, document the API endpoints, request/response formats, and authentication requirements. This helps developers integrate the project with their applications and ensures a smooth integration process.

Writing the Blueprint Description¶

Similar to the project description, a Blueprint description is a crucial component of any Attune Blueprint. It serves as the entry point for the Blueprint, providing an overview of its purpose, features, and more. Creating a comprehensive Blueprint description allows you to effectively communicate the Blueprint’s value and encourage collaboration with other developers.

1. Start with a blueprint objective

Begin the Blueprint description with a brief objective of the Blueprint. Clearly state the purpose, goals, and intended audience of the Blueprint. This helps readers quickly understand the Blueprint and whether it aligns with their needs.

2. Include prerequisite instructions

Provide detailed instructions on prerequisite steps for the Blueprint. Include any dependencies, system requirements, and step-by-step instructions. This helps other developers get started with the Blueprint quickly and reduces potential issues related to installation. In this step, use numbered lists instead of bullet points.

3. Highlight key features

Showcase the key features and functionalities of the Blueprint. This lets readers quickly grasp what the Blueprint offers and its potential benefits. Use bullet points or concise descriptions to highlight the main features.

4. Provide usage examples

Include usage examples to help readers understand how to use the Blueprint effectively. This can include code snippets, command-line examples, or screenshots demonstrating the Blueprint in action. Real-world examples make it easier for readers to relate to the Blueprint and envision how it can solve their problems.

5. Document API references

If the Blueprint exposes an API, document the API endpoints, request/response formats, and authentication requirements. This helps developers integrate the Blueprint with their applications and ensures a smooth integration process.

Automate Operating System Installation¶

The section on automating operating system installation outlines best practices for using Attune Projects to streamline the installation process across various controllers such as:

It covers three main areas:

Creating ISO Image: This involves setting up distinct Attune Projects for each operating system, with Blueprints for creating various OS release ISOs. Projects are named following a specific pattern and include parameters for the device used to build the ISO image, the new operating system’s name, and configurations like the user account and boot loader type. It also includes steps for testing the installation and cleaning up build files post-installation.

Building the Machine: This part focuses on creating separate Attune Projects for each controller, aiming to make Blueprints as operating system agnostic as possible. The naming convention for these projects and parameters required, such as the device running scripts, the controller or host machine, and the build machine, are outlined. It also includes specifics like CPU count and boot ISO directory.

Putting it all Together (Glue Projects): The final section deals with glue projects, designed to simplify creating Plans for the complete workflow of building or rebuilding a machine. It emphasises the importance of pre-defining parameters and consolidating duplicate parameters in these projects. The naming convention for these projects integrates the operating system, installation method, and controller type.

Overall, the guide provides a comprehensive framework for automating operating system installations using Attune Projects, emphasising structure, naming conventions, and parameterisation to ensure efficiency and scalability.

Creating ISO Image¶

Each operating system will have its own self contained Attune Project with Blueprints to create the various operating system release ISO’s.

Project Naming

The Projects to create the ISO’s are named the following way:

Automate {os_name} Installation with {method}.

os_name examples:

Red Hat Enterprise Linux RHEL
Windows
Ubuntu
Debian

method examples:

Kickstart
Preseed
autoinstall
autounattend

Create ISO

Creating the ISO images will be completely independent of the controller used to build the machine. Any actions that require knowledge of the controller being used are to be placed in the Controller APIs Project.

Parameters

This Project will need a device to build the ISO image. This device can be the Attune Server or another device. This device will be named:

Automation Worker {type}.

The new operating system to be created will be named:

New OS {type}.

type examples:

Node
User: {account such as ‘root’ or ‘non privileged’}
Base Directory
Boot Loader is BIOS

Test and Cleanup

The Project will include a Blueprint for testing the installation and a Blueprint to Cleanup the Build Files post installation.

Building the Machine¶

Each controller will have its own self contained Attune Project with Blueprints to perform various actions on the controller.

Where possible, Blueprints in the Controller APIs Project will be operating system agnostic. In some cases the differences between linux and windows make this impossible.

Project Naming

The Projects to perform processes on machine controllers and virtual hosts are named the following way:

{controller} APIs.

controller examples:

iDrac
PiKVM
VMWare ESXi

Parameters

This Project may need a device to run scripts and send commands to the controller. This device can be the Attune Server or another device. This device will be named:

Automation Worker {type}.

The controller or host machine will be named:

Controller {type}.

The machine to be built or rebuilt will be named:

Build Machine {type}.

type examples:

Node
ESXi Host
vCenter Node
User: {account such as ‘root’ or ‘non privileged’}
CPU Count
Boot ISO Directory

Putting it all Together (Glue Projects)¶

The objective of the glue project is to streamline and simplify the creation of Plans to perform the end-to-end workflow building or re-building a machine.

Project Naming

The Projects to perform the end-to-end workflow installing an operating system on a machine are named the following way:

Automate {os_name} Installation with {method} on {controller}

Parameters

When linking Blueprints into the glue Project, pre-define Parameters and combine the duplicate Parameters.

Wrapping Up: Streamlining OS Installation¶

This is a detailed framework for automating the installation of various operating systems using Attune Projects. It thoroughly outlines the processes for creating ISO images, building machines with different controllers, and integrating these components into cohesive glue projects. Emphasising structured naming conventions, clear parameterisation, and a focus on scalability and system-agnostic design, this approach streamlines the often complex task of operating system installations. By leveraging this framework, users can achieve more efficient, reliable, and automated installations across a diverse range of hardware and virtual environments.

“How-to” guides¶

Here you’ll find short answers to “How do I…?” types of questions. These how-to guides don’t cover topics in depth. However, these guides will help you quickly accomplish common tasks.

How To Clone a GIT Project¶

Objective¶

This procedure provides instructions to clone a project into an instance of Attune.

Procedure¶

Clone a GIT Repository into Attune¶

Start the Clone process in Attune.

Open the Design Workspace
Open the Project options dropdown
Select Clone

Paste the GIT repository URL into Attune.

Paste the URL
Select Clone

Note

If the Download Large Files option is enabled, Attune will attempt to download files that have a URL to their source.

Complete¶

This procedure is now complete. Now that this project is in your Attune instance you can begin creating Jobs.

How To Create a Job¶

Objective¶

This procedure provides instructions to create adn run a Job in Attune.

Procedure¶

Create a Job¶

Navigate to the Plan workspace and create a Job from a Blueprint in the Project you cloned.

Open the Plan Workspace
Navigate to Jobs
Enter your Job Name
Select the Blueprint to use
Select Create

Create the Values required to fill the Parameters for the Job.

Navigate to Values
Select the Value Type
Enter the Value Name
Select Create

Note

After selecting the Type of Value you’ll be provided fields to complete.

Configure the Parameters for the Job you created.

Select the Job
Navigate to Inputs
Populate the Values
Select Save

Run a Job¶

Run your Job.

Open the Run Workspace
Select the Job
Select Run

Complete¶

This procedure is now complete, you’ve successfully run a Job in Attune.

How To Setup WinRM, CIFS Manually¶

Objective¶

This procedure will setup a Windows desktop or server to allow connections and Automation from Attune. This is done via enabling Windows File Sharing (CIFS) and Windows Remote Management (WinRM).

Procedure¶

To enable WinRM, run the command in PowerShell.

# Enable WinRM with HTTPS, via PowerShell
# This is for windows deployment step
Enable-PSRemoting -SkipNetworkProfileCheck -Force
Remove-Item -Path WSMan:\Localhost\listener\listener* -Recurse;
New-Item -Path WSMan:\LocalHost\Listener `
      -Transport HTTPS `
      -Address * `
      -CertificateThumbPrint `
            (New-SelfSignedCertificate `
            -CertstoreLocation Cert:\LocalMachine\My `
            -DnsName $env:computername `
            -NotAfter (get-date).AddYears(6)).Thumbprint
      -Force
Restart-Service -Force WinRM
New-NetFirewallRule -DisplayName 'WinRM HTTPS' `
                  -Name 'WinRM_HTTPS' `
                  -Profile Any `
                  -LocalPort 5986 `
                  -Protocol TCP

To enable file and print sharing, run the command in Powershell.

# Enable File and Print sharing, via PowerShell
# This is for windows deployment step
Get-NetFirewallRule -DisplayGroup 'File and Printer Sharing' `
    | Set-NetFirewallRule -Profile 'Private, Domain' -Enabled true

Complete¶

This procedure is now complete. Your file and printing sharing is enabled.

How To Setup WinRM Via AD¶

Setting up WinRM via Active Directory:

Objective¶

This procedure provides instructions to automatically enable WinRM with HTTPS via Active Directory group policies.

Attune uses WinRM to execute commands on windows desktops and servers. WinRM, combined with improvements in PowerShell Cmdlets is Microsofts emerging solution for scriptable administration of windows servers.

Note

If you don’t have a domain and the target computers joined to the domain, then this procedure isn’t for you.

Note

This setup is straight forward with defaults, your corporate environment may require alterations to the procedure.

Setup :

Windows 2012 R2 Server, with Active Directory Domain Services configured.
Target servers are joined to the domain.

Procedure¶

The following procedure all performed via a Remote Desktop session to the domain server.

Adding Certificate Server Role¶

Open the Server Manager
Select “Add roles and features”

Click through the “Before You Begin” screen

On the “Installation Type screen” :

Select “Role-based or feature-based installation
Click “Next”

On the “Server Selection” screen :

Select the server to install the Certificate service on
Click “Next”

On the “Server Roles” screen:

Select “Active Directory Certificate Service”
On the popup, click “Add Features”
Click Next.

On the “Features” screen:

Click “Next”

On the “AD CS” screen:

Click “Next”

On the “Role Services” screen:

Click “Next”

On the “Confirmation” screen:

Check the “Restart the destination server automatically if required”
Click “Yes” on the confirmation dialog.
Click “Install”

The installation will proceed, break time.

On the “Results” screen:

Click “Close”

Repeat the procedure for the other domain controllers in the domain.

Configuring Certificate Server Role¶

Open the Server Manager
Select “Notification” dropdown
Click “Configure Active Directory Certificate …”

On the “Credentials” screen:

Ensure you have entered a valid domain credential
Click “Next”

On the “Role Services” screen:

Check “Certificate Authority”
Click “Next”

On the “Setup Type” screen:

Ensure “Enterprise CA” is selected
Click “Next”

On the “CA Type” screen:

Ensure “Root CA” is selected, or “Subordinate CA” if this is the second server your setting up.
Click “Next”

On the “Private Key” screen:

Ensure “Create a new private key” is selected
Click “Next”

If this IS the first server your setting up and the Root CA, skip this step.

If this is the second server you’re setting up, it will be a Subordinate CA and need to request signing from the root CA.

Select the “Certificate Request” on the screen list on the side bar
Click “Send a certificate request to a parent CA”
Click “Select”
Click “Next”

_images/ad_config_certificate_request.png

Click “Confirmation” on the screen list on the side bar
Then click “Configure

Repeat the procedure for the other domain controllers in the domain.

When prompted at the “CA Type”, you will need to select “Subordinate CA” on the subsequent servers.

Configure WinRM Certificate Template¶

Note

Be sure to check the Certificate Services setting updates in the following section on all domain controllers.

Open “Certificate Authority” (Use the start menu search)

Expand the root server
Select “Certificate Templates”
Right click and select “Manage”

In the “Certificate Template Console” app

Find the “Web Server” template in the list
Right click and select “Duplicate Template”

In the “Properties of New Template” app

Select the “General” tab
Enter “WinRM in the “Template display name”

Select the “Subject Name” tab
Select “Build from this Active Directory information”
Select “Common name” for the “Subject name format”
Check “User principle name (UPN)”

Select the “Security” tab
Select “Add”
1. On the “Select Users, Computers…” screen:
2. Select “Object Types
  1. On the “Object Types” screen
  2. select “Computers”
  3. click “Ok”
3. Back on the “Select Users, …” screen, Enter “Domain Computers” in the “Enter the object names to select” box
4. Click “Check Names”
5. Click “Ok”
Back on the “Properties” screen, Select “Domain Computers”
Select “Enrol”
Select “Autoenroll”
Click “Ok”

Back in the “Certificate Authority” app

Right click on “Certificate Templates”
Select “New”
Select “Certificate Template to Issue”

On the “Enable Certificate Templates” popup:

Find and select the created “WinRM” certificate template.
Click “Ok”

_images/new_cert_enable_cert_template.png

Create the Group Policy Object¶

The group policy object will automatically enable WinRM on Windows operating systems joined to the domain.

Open the “Group Policy Management” app

Expand the Forest
Expand the Domains
Expand the Domain
Select the “Group Policy Objects”
Right click and select “New”

On the “New GPO” dialog

Enter “Configure WinRM” in the “Name” field
Click “OK”

In the “Group Policy Objects” list:

Right click on “Configure WinRM”
Select “Edit”

Enabling Autoenroll of Certificate Services¶

In the “Configure WinRM” Group Policy:

Expand “Computer Configuration” → “Policies”
Expand “Windows Settings”
Expand “Security Settings”
Select “Public Key Policies”
On the right hand pane, double click “Certificate Services Client – Auto-Enrollement”

In the “Certificate Services Client – Auto-Enroll…” properties:

Set “Configuration Model” to “Enabled”
Check “Renew expired certificates…”
Check “Update certificates that user certificate templates”
Click “OK”

Configure Enrolment Script¶

Expand the following

Expand “Computer Configuration” → “Policies”
Expand “Windows Settings”
Expand “Scripts”
Double click on “Startup”

On the “Startup Properties”

Click “Show Files”

_images/edit_gpo_enroll_script_properties.png

In windows explorer

Click “View”
Ensure “File name extensions” is checked
Right click on a blank space in the window
Select “New”
Select “Text Document”

_images/edit_gpo_enroll_script_explorer.png

In windows explorer

Rename the file to “enable_winrm_https.bat”
Enter the following as the file contents
```
winrm quickconfig -q -transport:https
```
Save the file and close notepad
Close windows explorer

_images/edit_gpo_enroll_script_notepad.png

Back at the “Startup Properties” screen

Click “Add”

_images/edit_gpo_enroll_script_startup_1.png

On the Add Script Diaglog
1. Click “Browse”
2. Select the “enable_winrm_https.bat”
3. Click Ok
Click “Ok” on the Startup Properties dialog.

Configure Firewall for WinRM¶

Expand the following

Expand “Computer Configuration”
Expand “Policies”
Expand “Windows Settings”
Expand “Security Settings”
Expand “Windows Firewall with Advanced Security”
Expand “Windows Firewall with Advanced Security – ….”
Right click on “Inbound Rules”
Click “New Rule”

On the “New Inbound rule Wizard”

Click “Predefined”
Select “Windows Remote Management”
Click “Next”

_images/edit_gpo_firewall_inbound_rule.png

On the “Predefined Rules” screen

Click “Next”

_images/edit_gpo_firewall_predefined_rule.png

On the “Action” screen

Click “Finish”

Enable WinRM¶

Expand the following

Expand “Computer Configuration”
Expand “Preferences”
Expand “Control Panel Settings”
Expand “Services”
Right click on “Services”
Select “New
Select “Service”

_images/edit_gpo_enable_winrm_service_new.png

On the “Predefined Rules” screen

Change “Startup” to “Automatic (Delayed Start)”
Change “Service name:” to “WinRM”
Click “OK”

Tweak WinRS¶

Expand the following

Expand “Computer Configuration”
Expand “Policies”
Expand “Administrative Template Policy”
Expand “Windows Components”
Expand “Windows Remote Shell

In the Settings pane:

Enable and Set “Specify maximum amount of memory in MB per shell”, to 1024
Enable and Set “Specify maximum number of processes per shell”, to 64
Enable and Set “Specify maximum number of remote shells per user”, to 64

Linking Group Policy¶

The group policy is now complete. Link the group policy to the desired OUs, and reboot the target servers.

Complete¶

This procedure is now complete, You can Create new Windows Server values in Attune and set the WinRM specification to “WinRM 2.0 HTTPS”

Script Snippets¶

Powershell Script Snippets¶

How To Start Attune From Local User Snippet¶

$action = New-ScheduledTaskAction `
    -WorkingDirectory 'C:\Users\{winUser.user}' `
    -Execute `
    'C:\Users\{winUser.user}\AppData\Local\Programs\attune\resources\app.asar.unpacked\py\attune-server'


$task = New-ScheduledTask -Action $action `

Register-ScheduledTask 'attune-server' -InputObject $task `
   -User "{winUser.user}" `
   -Password "{winUser.password}"

Start-ScheduledTask 'attune-server'

Start-Sleep -Seconds 5

# Check that its running
Get-Process -Name "attune-server"

How To Restart a Windows VM Code Snippet¶

To restart a Windows VM:

$WAIT = 10
shutdown /r /t $WAIT /c "Restart from Attune"
Write-Host "Restarting in $WAIT seconds."

How To Shutdown Windows Snippet¶

To shutdown a Windows VM:

$WAIT = 10
shutdown /s /t $WAIT /c "Shutdown from Attune"
Write-Host "Shutting down in $WAIT seconds."

How To Get Fully Qualified Domain Name Windows Snippet¶

To get the FQDN for the current host:

[System.Net.Dns]::GetHostByName(($env:computerName))

How To Windows Commands Exit with the Wrong Code¶

Windows commands often exit with a 0 code, even if the command fails. Catch errors like this using Select-String; the Powershell equivalent of grep.

echo "Attempting to sync Group Policy..."
$out = gpupdate
echo $out

$result = Select-String -InputObject $out -Pattern "error"
if ($result.length -ne 0) {
    exit 1
}

How To Search for Installed oVirt VIRTIO Drivers¶

This command will list the oVirt VIRTIO Drivers installed on a machine:

PS C:\Users\Administrator> driverquery | Select-String -Pattern "VirtIO"

How To Set Timezone Server¶

w32tm /query /status

Write-Host "Setting timezone server as {timezoneServer.fqn}"

w32tm /config /syncfromflags:manual `
    /manualpeerlist:"{timezoneServer.fqn}" `
    /reliable:yes /update

If you get the error when running the above command at line 1: The following error occurred: The service has not been started. (0x80070426) Run these commands:

w32tm /unregister
w32tm /register
net start w32time

Bash Script Snippets¶

How To Iterate Over Files in a Directory¶

ls is not the command that expands globs to filenames, bash does that. In the following snippet, bash expands /dev/{s,v}*1 and expands it to /dev/sda1 which is what the for loop is then passed.

# This only works if there are no spaces in the file names.
for f in /dev/{s,v}*1
do
    echo "$f"
done

How To For Loop Over CSV File Which Contains Spaces¶

Loops over a comma separated value file that contains spaces. This is perfect for Server Groups in Attune as the server group values are stored as as CSV’s.

# The following three lines are identical as $IFS=" "
# if $IFS="," then the line with brackets around it would generate an array
# which isn't suitable for an input for this example.
VAR=("Test 1","Test 2","Test 3","Test 4")
VAR="Test 1","Test 2","Test 3","Test 4"
VAR="Test 1,Test 2,Test 3,Test 4"

# Set the field separator to a comma,
# and echo the variables contents into the stdin of read
# tell read to produce a variable of type array
IFS=',' read -ra items <<< $VAR

# Iterate over the the indexes of the array, not the items
# This works with for, because for will split on spaces and
# the indexes don't have spaces in them, eg 1 2 3 4 5
for index in "${!items[@]}"
do
    # Dereference the index of the array,
    # This way, we get our correct value even if it has spaces in it.
    echo "Testing CSV for loop: ${items[index]}"
done

Output:

Testing CSV for loop: Test 1
Testing CSV for loop: Test 2
Testing CSV for loop: Test 3
Testing CSV for loop: Test 4

Examples¶

The following example will print the name, IP address, and FQDN for each of the servers in the appServers server group.

IFS=',' read -ra ip <<< "{appServers.serverIps}"
IFS=',' read -ra fqn <<< "{appServers.serverFqns}"
IFS=',' read -ra name <<< "{appServers.serverNames}"

for i in "${!ip[@]}"
do
    echo ${name[$i]}
    echo ${ip[$i]}
    echo ${fqn[$i]}
done

Build a List of Items to Loop Over¶

Build a list with comments:

list=""
list+=" git"            # version control
list+=" vim"            # text editor
list+=" hdparm"         # hard drive tools
list+=" nmap"           # network debugging
list+=" fail2ban"       # brute-force protection

for F in ${list}
do
    echo ${F}
    done

Or if you want to keep it simple:

list="
    git
    vim
    hdparm
    nmap
    youtube-dl
    fail2ban
"

for F in ${list}
do
    echo ${F}
done

How To Iterate Over FileNames With Spaces¶

This snippet will iterate over file names containing spaces in a directory.

echo /my/**/dir | while IFS= read -r file
do
    echo "Doing some work with ${file}"
    ls "${file}"
done

This snippet will iterate over files that contain a string found by grep.

SCHEMA="newschema"
function listFiles {
    grep -lRi OLDSCHEMA \
       /dir1 \
       /dir2
}

listFiles | while IFS= read -r file
do
    echo "Replacing OLDSCHEMA with ${SCHEMA^^} in ${file}"
    # ^ upercases the first letter, ^^ upper cases them app
    sed-i "s/CORPDBA/${SCHEMA^^}/g" "${file}"
done

Conditional Bash Step in Attune¶

The following code can be used to create a conditional step in attune, that will only execute if an Attune variable is literally true.

if {attuneCheckVariable}
then
    echo "Check passed, will execute code"
    # code to execute here
else
    echo "Check failed, won't execute code"
fi

How To Perform SSL Handshake and Save Certificate to File¶

The following example will retrieve the SSL certificate from a server and save it to a file named out.cer.

# Define ip and port

openssl s_client -connect ${ip}:${port} 2>/dev/null </dev/null | openssl x509 -out out.cer

How To Append Lines To File If They Do Not Exist¶

FILE=/etc/samba/smb.conf

LINES=$(cat <<EOF
[scan]
Comment = Scans
Path = /var/scan
Browseable = yes
Writeable = Yes
only guest = no
guest ok = no
create mask = 0777
directory mask = 0777
Public = no
EOF
)

grep -q "${LINES}" ${FILE} && echo "Nothing to do" || \
    echo "${LINES}" | tee -a ${FILE}

How To Grep the Standard Error¶

The following example:

Executes perl Makefile.PL and saves the standard error of this command to a variable.
Echoes the standard error so that it appears normal in the Attune output.
Searches the standard error for a specific message and fails the step with an exit code of 34 if found.

The standard output is printed as normal.

{ stderr="$( { perl Makefile.PL; } 2>&1 1>&3 3>&- )"; } 3>&1
IFS=$'\n' echo "${stderr}" 1>&2
grep -q "Warning: prerequisite" <<< ${stderr} && exit 34

Filter and Save Output to File¶

The following example will write the complete output of a command to a file and print a filtered subset of this output to STDOUT.

<command> | tee -a output_file.txt | grep <filter>

Exit Codes in Functions¶

Don’t use exit in bash functions, they should instead use return so that the calling script has the option of what to do on failure.

If set -o errexit is set then the script will still exit with failure, but if the calling script doesn’t want that to happen then they can add myFunc || true to stop it happening.

function bad {
  echo "# bye"
  return 1
}
function good {
  echo "# hi"
  return 0
}

Output:

bad; echo "# $?"
# bye
# 1

good; echo "# $?"
# hi
# 0

How To Piping into Functions¶

Bash can pipe data into functions.

There is one stdin for the whole script, and the function can read the data for this.

function pipeMe1 {
    # Just read a line
    read var
    echo "One line read, it's :${var}"

    # More stdin can be left here, `read` more of it or cat the rest.
    # cat may hang if stdin is closed
}

function pipeMe2 {
    # Now read the rest of the stdin
    cat
}

function pipeMe3 {
    # Now read the rest of the stdin
    cat <<EOF
    Here is my heredoc
    $(cat)
    I've wrapped that stdin with more stdin
EOF
}

pipeMe1 <<EOF
line 1
line 2
EOF

pipeMe2 <<EOF
line 1
line 2
EOF

pipeMe3 <<EOF
line 1
line 2
EOF

How To Iterate Over RPM Files List and Install RPM if not Already Installed¶

PACKAGE="sqlite-devel"

cd "/tmp/${PACKAGE}"

i=0
# lists the RPMS in the directory
for RPM in *
do
    # remove the extension of the RPM
    RPM_NAME_ONLY=$(echo "${RPM}" |
        sed -e 's/\([^.]*\).*/\1/'
        -e 's/\(.*\)-.*/\1/'
    )

    if rpm -qa | grep "${RPM_NAME_ONLY}";
    then
        echo "${RPM_NAME_ONLY} is already installed."
    else
        echo "Installing ${RPM} offline."

        yum localinstall --assumeyes --cacheonly \
            --disablerepo=* "${RPM}"
    fi

    ((i+=1))
done

Explanation of sed REGEX¶

Reference is at https://www.unix.com/shell-programming-and-scripting/150883-remove-version-numbers-package-lists.html

Using sqlite-devel-3.7.17-8.el7_7.1.x86_64.rpm as an example this is what the first stage sed does:

echo "sqlite-devel-3.7.17-8.el7_7.1.x86_64.rpm" | sed -e 's/\([^.]*\).*/\1/'

Gives this output:

sqlite-devel-3

In $[^.]*$.*:

The [^.]* matches everything that is not a . zero or more times.
The $[^.]*$ matches everything that is not a . zero or more times and assigns the result to variable 1.
The ([^.]*\). matches everything up to but the first ..
The last part .* strips away the characters after the first ..
Finally the \1 substitutes the the match we got in variable 1.

The second stage sed:

echo "sqlite-devel-3.7.17-8.el7_7.1.x86_64.rpm" | \
  sed -e 's/\([^.]*\).*/\1/' \
  -e 's/\(.*\)-.*/\1/'

Gives this output:

sqlite-devel

In (.*\)-.*:

(.*\)- matches everything before the first - and stores the result into variable 1.
-.* strips away everything after the first -.
Finally the \1 substitutes the the match we got in variable 1.

How To Check Whether SELinux is Enabled¶

if sestatus | grep -i "SELinux status:" | grep -q "enabled"
then
    echo "SElinux is enabled"
else
    echo "SElinux is disabled"
fi

How To Download RPM For Offline Use¶

Here is an example usage of dnf to download cabextract and all it’s dependencies.

dnf download --resolve --alldeps cabextract

SQL (Oracle) Code Snippets¶

How To Get Readable Results in sqlplus¶

Use SQL Developer wherever possible. It is much better than sqlplus and has excellent tools for browsing the database and debugging.

If you don’t have access to SQL Developer, you can format the sqlplus output as follows.

set linesize 400
set pagesize 1000

-- Run a separate command for each column to be displayed, as follows.
-- a20 means the column is 20 characters wide. Use this format for varchar2 fields.
-- For numbers, each digit is represented by a 9

column OBJECT_NAME format a20
column OBJECT_TYPE format a20
column STATUS format a20
column PRICE format 999.99

How To Loop over a Node List¶

Attune node lists (formerly known as server groups) store data in comma-separated values (CSV) format. This example loops over the replicationServers node list and updates the HOST_DETAILS table based on the CSV text values replicationServerHostIds and replicationServerTypeList.

DELETE FROM HOST_DETAILS;

set serveroutput on
DECLARE
  hosts VARCHAR2(200) := '{replicationServers.serverHostnames}';
  host_ids VARCHAR2(100) := '{replicationServerHostIds}';
  host_types VARCHAR2(100) := '{replicationServerTypeList}';
BEGIN
  FOR row IN
  (SELECT trim(regexp_substr(hosts, '[^,]+', 1, LEVEL)) host,
          trim(regexp_substr(host_ids, '[^,]+', 1, LEVEL)) host_id,
          trim(regexp_substr(host_types, '[^,]+', 1, LEVEL)) host_type,
          LEVEL priority

   FROM dual
    CONNECT BY LEVEL <= regexp_count(hosts, ',')+1
  )
  LOOP
    dbms_output.put_line('Adding server ' || row.host
                        || ', id=' || row.host_id
                        || ', type=' || row.host_type
                        || ', priority=' || row.priority);
    EXECUTE IMMEDIATE
       'Insert into ENMAC.HOST_DETAILS ('
           || 'HOST_NAME,HOST_PRIORITY,HOST_ID,HOST_LAST_TRANSACTION,HOST_STATUS,'
           || 'HOST_TYPE,HOST_NETWORK,HOST_LAST_ERROR,HOST_GROUP,HOST_SEND_TXNS,HOST_RECV_TXNS,HOST_THIS_SERVER,'
           || 'HOST_LAST_REQUEST_ID,HOST_TRANSACTION_TIME,LAST_SEND_TRANSACTION_SERIAL,HOST_HALT,'
           || 'HOST_ROLL_TRANSACTION_ID'
           || ')'
           || ' VALUES (''' || row.host || ''',' || row.priority || ',''' || row.host_id || ''''
           || ',0,1, '|| row.host_type ||' , ''Default'',0,null,''Y'',''Y'',null,null,null,null,null,null)';
   END LOOP;
 END;

How To Check the Grants on a User¶

Run this query in SQL Developer. You’ll be prompted for the user when you run the query. Alternatively run the query in sqlplus but substitute a string in place of :the_user variable.

SELECT GRANTEE, PRIVILEGE
    FROM sys.dba_sys_privs
    WHERE grantee = :the_user
UNION
SELECT GRANTEE, PRIVILEGE
    FROM dba_role_privs rp JOIN role_sys_privs rsp ON (rp.granted_role = rsp.role)
    WHERE rp.grantee = :the_user;

How To Create Bash Script to Perform Oracle Commands as Oracle on Target Server¶

Option 1:

F=$(mktemp)
printf "
alter system set COMPATIBLE='19.3.0' scope=spfile;
shutdown immediate;
startup mount;
alter database open;
" > ${F}

{oracleDbHome}/bin/sqlplus / as sysdba @${F}
rm ${F}

Option 2:

# Ensure ORACLE_HOME is set
# Ensure ORACLE_BIN is set to $ORACLE_HOME/bin
# Ensure ORACLE_BIN is in $PATH

which sqlplus

sqlplus /nolog <<EOF
CONN {oracleUser.user}/{oracleUser.password}@{oracleUser.sid}
SELECT * FROM DUAL
EOF

How To Create Dynamic SQL Script from Bash¶

sqlplus splex/$Splex_PW > $Action_File << EOF
set HEADING OFF
set ECHO OFF
set FEEDBACK OFF
set pages 0
set lines 200
select 'alter trigger '||owner||'.'||trigger_name||' $action; from dba_triggers where trigger_name like '%SPX%';
select 'alter table '||table_owner||'.'||table_name||' modify t_updated_by_spx date default sysdate;' from dba_triggers where trigger_name like '%SPX%' ;
@Action_File
exit
EOF

rm $Action_File

How To Use SQL to Create a File that Bash can Query¶

#Query the host_details for the type of host
sqlplus <user>/<userpassword>@<instance> > $tmpFile << EOF
SET ECHO OFF
SET HEADING OFF
SET PAGES 100
SET FEEDBACK OFF
SELECT host_name, host_type
  FROM host_details
  WHERE host_name '$dbname'
  AND host_type IN (1, 4)
EOF

# Get the host type from the file
hostType=$(grep $dbName $tmpFile | awk '{ print $2}' )

Mako Template Code Snippets¶

How To Escape a Mako Variable¶

To stop Attune from trying to substitute a variable, escape it by enclosing it inside Mako raw text tags. In this example, line 2 will be printed exactly as it is written.

<%text>
user=cyrus argv=/usr/lib/cyrus-imapd/deliver -e -r ${sender} -m ${extension} ${user}
</%text>

How To Render a Node List value IP addresses¶

This code snippet renders the IP addresses of nodes in a node list on a single line separated by spaces.

The makoParameter name is appServers.

1	${appServers.serverIps.replace(",", " ")}

Reference guides¶

Design Workspace¶

Your Automated and Orchestrated IT processes are developed and modified in individual Projects. The Design Workspace contains your Projects.

Projects¶

Projects are self contained and sharable. Your Projects contain your:

Parameters,
Files,
Steps &
Blueprints.

You can have many Projects and Projects can contain many Parameters, Files, Steps and Blueprints.

Projects are version controlled with GIT integration. You can clone, push and pull Projects with repositories such as GitHub

Parameters¶

Parameters are used in Blueprints and substituted with Values when a job is run. Values are mapped against Parameters in the Plan. This provides maximum Blueprint re-usabiliity.

All Parameters have the same basic attributes regardless of their type.

A project as a minimum requires a Node type and Credential type Parameters to create a Step in a Blueprint. Parameters can be created in the Step.

To learn how to reference Parameters in a Script read: Referencing Parameters in Scripts

Files¶

Your Files can be stored centrally in Attune. Files are divided into two categories:

Version Controlled,
Large Files.

Version Controlled Files

Version Controlled Files are maintained in the GIT repository. These are typically small text files.

Dynamically create your Configuration Files when your Job is run. Attune has a template engine that allows you to deploy files which contain markup using Mako, an embedded Python language. The template engine processes the files in a configuration archive and renders the final outputs.

More information about Mako templates, and the syntax used for the configuration archives files can be found at http://www.makotemplates.org

Large Files

Large Files are not stored in the GIT repository. These can be large zipped directories, installation file, ISO’s, etc.

Steps & Blueprints¶

Blueprints orchestrate the sequence and paralleling of Steps. Steps automate individual scripted actions. Blueprints from other Projects can be linked into a Blueprint.

Plan Workspace¶

Your Jobs are planned to run Blueprints with substituted Values controlled via the Self-Service Portal, Jobs Workspace or Scheduler. The Jobs are created in the Plan Workspace.

The Plan Workspace contains your:

Values,
Plans &
Schedules.

Values¶

Values are substituted into Parameters when a Jobs is run. Values have different attributes based on their type.

To learn the Values type attributes read: Referencing Parameters in Scripts

Plans¶

Plans allow you to assign Values to the Parameters that appear in a Blueprint. You can create many Plans for a single Blueprints with different Values assigned.

Schedules¶

Schedules can be configured to run many Plans either sequentially or in parallel. The Attune service must be running for the Scheduler to run.

Run Workspace¶

Control your Jobs, debug your Steps and review your Historical Logs in the Run Workspace.

The Run Workspace contains your:

Jobs &
Historical Logs.

Jobs¶

Jobs allow you to start, pause or abort individual Jobs. Individual Steps can be inspected and modified. Jobs can be run from any Step in the procedure allowing you to skip sections or repeat a Step.

If a Step is modified it will be updated in the Blueprint. If the Blueprint structure of Steps is modified the Job will need to be recreated to populate the new, deleted or reorganised Steps.

Recreating the Job will archive the current log for each Step.

Historical Logs¶

Historical Logs are captured after each Scheduled Job, Self-Server Portal run job and recreated Job.

The Historical Logs can be viewed in Attune or exported in either PDF or HTML formats.

Referencing Parameters in Scripts¶

Blueprints are composed of Steps, and each Step has a unique name and a number of other attributes, including a Script, where the actual commands for executing the Step are written. In these commands, curly braces { } are used to delimit Values which are referenced by Parameters.

In order to be used in a Script the Parameters names are stripped of any separating spaces between words and converted to camelcase - with only the first letter of the second, and any subsequent words, capitalised.

So if a Parameter is named - This is my Name, it would be converted to: thisIsMyName.

Values are referenced in scripts as: {placeHolderName.placeValueAttribute}.

So for a Parameter with the name This is my Name of type Server, we can refer to the IP address in a script as: {thisIsMyName.ip}.

The expressions contained in the curly braces are evaluated prior to Job being Run, and the curly brace expressions are replaced by actual Values . In the example above {thisIsMyName.ip} would be substituted with the IP attribute of the Value that was assigned to the Parameter - THIS IS my name in the Plan.

This substitution of Values is performed by Attune, so using the curly Brace {} notation to reference attribute Values works with all Script regardless of the type of Script.

Value Attributes¶

This section details the Value attributes for each Parameter type.

OS Credential¶

Attributes of OS Credential Parameter type can be referenced as follows:

Value Attribute	Attribute Name	Script Reference
Name	name	`{myPlaceHolder.name}`
User	user	`{myPlaceHolder.user}`
Password	password	`{myPlaceHolder.password}`
Comment	comment	`{myPlaceHolder.comment}`

SQL Credential¶

Attributes of SQL credential Parameter type can be referenced as follows:

Value Attribute	Attribute Name	Script Reference
Name	name	`{myPlaceHolder.name}`
User	user	`{myPlaceHolder.user}`
SID	sid	`{myPlaceHolder.sid}`
Password	password	`{myPlaceHolder.password}`
As Sysdba	asSysDba	`{myPlaceHolder.asSysDba}`
Comment	comment	`{myPlaceHolder.comment}`

Node¶

Attributes of Node Parameter type are referenced as follows:

Value Attribute	Attribute Name	Script Reference
Name	name	`{myPlaceHolder.name}`
IP Address	ip	`{myPlaceHolder.ip}`
Hostname	hostname	`{myPlaceHolder.hostname}`
Domain Name	domain	`{myPlaceHolder.domain}`
Comment	comment	`{myPlaceHolder.comment}`

Node List¶

Node List is a comma separated list of node Parameters (CSV).

Attributes of Node List Parameter type are referenced as follows:

Value Attribute	Attribute Name	Script Reference
Name	name	`{myPlaceHolder.name}`
Server	serverNames	`{myPlaceHolder.serverNames}` as CSV
Server	serverIps	`{myPlaceHolder.serverIps}` as CSV
Server	serverHostnames	`{myPlaceHolder.serverHostnames}` as CSV
Server	serverTypes	`{myPlaceHolder.serverTypes}` as CSV The types are: 1 = Linux 2 = Windows
Server	serverDomains	`{myPlaceHolder.serverDomains}` as CSV
Server	serverFqns	`{myPlaceHolder.serverFqns}` as CSV
Comment	comment	`{myPlaceHolder.comment}`

IPv4 Subnet¶

Attributes of IPv4 Subnet Parameter type are referenced as follows:

Value Attribute	Attribute Name	Script Reference
Name	name	`{myPlaceHolder.name}`
Subnet	subnet	`{myPlaceHolder.subnet}`
Netmask	netmask	`{myPlaceHolder.netmask}`
Gateway IP	gateway	`{myPlaceHolder.gateway}`
DNS IP 1	dns1	`{myPlaceHolder.dns1}`
DNS IP 2	dns2	`{myPlaceHolder.dns2}`
Comment	comment	`{myPlaceHolder.comment}`

Text¶

Attributes of Text Parameter type are referenced as follows:

Value Attribute

Attribute Name

Script Reference

Name

name

{myPlaceHolder.name}

Value

value

{myPlaceHolder}

Please note the text value is referenced without the attribute.

Comment

comment

{myPlaceHolder.comment}

Glossary¶

Blueprints A Blueprint is the orchestration of Steps.

Jobs Jobs are created in the Plan Portal, pairing Values with the Parameters that are configured in the Blueprint. Running a job will perform the tasks configured in the Blueprint using the Values configured in the Parameters.

Parameters Steps contains Parameters for credentials, node details, text, and more.

Steps A Step contains the connection details and action(s) to be performed.

Values Values are substituted into a Job Parameters when a Job is run.

Release Notes¶

Release notes - Attune v23.7.x¶

v23.7.3¶

Bug

AT-1332 Push Compiled Files no longer fails when Binary Files in the Files Archive

AT-1402 Steps in step screen lists in macOS App display correctly

v23.7.2¶

Bug

AT-1412 Windows App successfully clones projects

v23.7.1¶

Bug

AT-1411 Windows App no longer fails to start with NoneType has no attribute externalUuid4

Release notes - Attune v23.0.x¶

v23.0.4¶

Bug

AT-1383 Optimised Project Website Page Headings Structure

AT-1386 Push Compiled Files Screen Shows Correct Files in Archive

AT-1390 Made Project Website Structure SEO-friendly and Readable

AT-1394 Windows archive clobber/overwrites existing files

AT-1399 Upgrading to plan tree successful if Attune has no plans

AT-1405 Date times in Attune run screen logs are correct timezone

AT-1406 Renaming step updates step list in “link step” drop down

Task

AT-1398 Added responsive navigation bar and footer

AT-1407 Upgraded to “@synerty/vortexjs@3.3.11” for websocket improvements

v23.0.3¶

Bug

AT-1386 Push Compiled Files Screen Now Shows Correct Files in Archive

v23.0.2¶

Bug

AT-1377 Edit Step Name and Step Comment causes Project error

AT-1378 Adding a text parameter that doesn’t exist to a text script throws an exception

AT-1379 Changing a parameter dropdown throws exception on run

AT-1380 Committing project fails with No attribute sid

AT-1382 Project Website Setup Meta Tags: Formatting and Arrangements

AT-1384 Remove project from parameter now also removes duplicates

v23.0.1¶

Improvement

AT-566 Handling Step Failures

Bug

AT-1374 Job Run Steps don’t show warning icon in tree

v23.0.0¶

Bug

AT-1268 LDAP fails to find groups for users with ‘and’ in their name

AT-1269 Rename parameter does not cascade to deploy compiled file mako step

AT-1270 Copy-Step fails if the step exists in the destination

Improvement

AT-1255 Step-details replaced tabs with scrollable sections

AT-1256 Replaced all Add buttons in filter boxes with Add links at bottom of list

AT-1257 Moved action buttons at top of step tree into tree

AT-1265 Add Create Step Under Menu Option

AT-1266 Added UUID4 field for all storage items

AT-1277 Rearranged Project so git remote is with git commit

AT-1300 Uploaded EL7 releases based on branch name

AT-1310 Removed second level navigation bar

AT-1311 Decreased vertical gap between step details forms

AT-1347 Captured Attune startup exception and log them to attune log

Task

AT-731 Improve user interface to remember selected items when moving between tabs

AT-865 Enable jobs to run with Project Link steps in them

AT-1217 Implemented new plant tree UI for scrolling panels

AT-1242 Created Step De-duplicate Feature

AT-1258 Added support for mapping to any project + parameter key tree node mapping

AT-1291 Implemented Plan and Node Tree Delete

AT-1294 Updated to @synerty/vortexjs@3.3.6 vortexpy==3.4.6

AT-1338 Added logging for __hasErrors for steps

Release notes - Attune v5.1.x¶

v5.1.7¶

Bug

AT-1268 LDAP fails to find groups for users with “and” in their name.

AT-1269 Rename parameter does not cascade to deploy compiled file mako step

AT-1270 Copy-Step fails if the step exists in the destination

v5.1.6¶

Bug

AT-1226 Remove Jobs list horizontal scroll

AT-1227 Create Push Files Step, Archive dropdown too small

AT-1228 Create “Execute Linux Script” step dropdown too small

AT-1232 Schedules fail to generate HTML for emails

AT-1233 Copy Step and Move Step doesn’t work properly

AT-1234 Schedules think they are failed after first job runs successfully

v5.1.4¶

Bug

AT-1141 No project is defaulted to when opening a fresh Attune instance for the first time

AT-1202 Showing archive list fails on larger Attune instances

AT-1204 Attune does not deploy unticked files in Push Compiled Files Step

AT-1205 Attune Parameters are no longer editable if exist in Blueprint but not parameter list

Tasks

AT-1190 Revert Project Export button http call changes

v5.1.3¶

Bug

AT-1187 Loading Files Dropdown in Steps Component performance issue

v5.1.2¶

Bug

AT-1184 Committed changes are lost on Attune restart

v5.1.1¶

Bug

AT-1108 Migration scripts do not set the PostgreSQL sequences correctly

AT-1148 Double click on create and export actions

AT-1149 Required Values are unknown before the job is created

AT-1150 Job created without Blueprint being selected

Release notes - Attune v4.3.x¶

Attune v4.3.14¶

Bug

AT-643 Attune fails to connect CIFS when SMB2 signature is required

AT-715 Attune with HTTPS enabled doesn’t enable the SSL Websocket, and nothing in the browser works.

AT-823 Replace Twisted sendmail with smtplib

AT-824 Attune scheduler does not detect Schedule failures correctly

AT-838 Logging in using LDAP user produces a list indices must be integers or slices, not str

Attune v4.3.13¶

Bug

AT-715 Attune with HTTPS enabled doesn’t enable the SSL Websocket, and nothing in the browser works.

Attune v4.3.12¶

Bug

AT-549 Show as Text not working for Blueprints with Windows steps

Attune v4.3.11¶

Bug

AT-544 TypeError in ScheduleManager

AT-545 Markdown to HTML conversion no displaying tables