Skip to content

Home

Jump to bottom
ppwarwick edited this page Jul 26, 2017 · 28 revisions

go-brocadev-tm - Go Bindings for the Brocade Virtual Traffic Manager (vTM)

Overview

This is the GoLang API wrapper for Brocade Virtual Traffic Manager (vTM). This wrapper uses the REST API interface provided by the vTM, currently version 3.8. There is also command line interface which can be built by running make in the root of this repo.

Handled Resources

Resource Create Read Update Delete
Monitor [1] Y Y Y Y
Pool Y Y Y Y
SSL Server Key Y Y Y Y
Traffic IP Group Y Y Y Y
Virtual Server Y Y Y Y
Rule Y Y Y Y

Notes

[1] : Currently only HTTP monitoring is supported

Usage

Import library

import(
    "github.com/sky-uk/go-brocade-vtm"
)

Get a client object

In order to get a client object authentication credentials needs to be provided. The REST API transport protocol is by default HTTPS and hence SSL encryption is used by default. Certificate handling behaviour can be controlled via the ignoreSSL flag. More information about the client and the Base API may be found here https://github.com/sky-uk/go-rest-api.

Working with Monitors

Importing proper packages

In order to work with monitors, import the monitor package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/monitor"
)

Getting the list of active monitors

    api := monitor.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monitors := api.ResponseObject().(*monitor.MonitorsList)

Retrieving a single monitor

    api := monitor.NewGet( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monitor := api.ResponseObject().(*monitor.Monitor)

Creating a monitor

    newMonitor := monitor.Monitor{
        ...
    }

    api := monitor.NewCreate( name, newMonitor )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monCreated := api.ResponseObject().(*monitor.Monitor)

Updating a monitor

    updateMonitor := monitor.Monitor{
        ...
    }

    api := monitor.NewUpdate( name, updateMonitor )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    monUpdated := api.ResponseObject().(*monitor.Monitor)

Deleting a monitor

    api := monitor.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Monitor %s deleted", name)
    }

Working with Pools

Importing proper packages

In order to work with pools, import the pool package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/pool"
)

Getting the list of pools

    api := monitor.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    pools := api.ResponseObject().(*pool.LBPoolList)

Retrieving a single pool

    api := monitor.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    pool := api.ResponseObject().(*pool.Pool)

Creating a pool

    newPool := pool.Pool{
        ...
    }

    api := pool.NewCreate( name, newPool )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    poolCreated := api..ResponseObject().(*pool.Pool)

Updating a pool

    updatePool := pool.Pool{
        ...
    }

    api := pool.NewUpdate( name, updatePool )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    poolUpdated := api.ResponseObject().(*pool.Pool)

Deleting a pool

    api := pool.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Pool %s deleted", name)
    }

Working with Server keys

Importing proper packages

In order to work with server keys, import the pool package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/sslServerKey"
)

Getting the list of server keys

    api := monitor.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    keys := api.ResponseObject().(*sslServerKey.SSLServerKeysList)

Retrieving a single server key

    api := sslServerKey.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    key := api.ResponseObject().(*sslServerKey.SSLServerKey)

Creating a server key

    newKey := sslServerKey.SSLServerKey{
        ...
    }

    api := sslServerKey.NewCreate( name, newKey )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    keyCreated := api.ResponseObject().(*sslServerKey.SSLServerKey)

Updating a server key

    updateKey := sslServerKey.SSLServerKey{
        ...
    }

    api := sslServerKey.NewUpdate( name, updateKey )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    keyUpdated := api.ResponseObject().(*sslServerKey.SSLServerKey)

Deleting a server key

    api := sslServerKey.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Server key %s deleted", name)
    }

Working with traffic IP groups

Importing proper packages

In order to work with traffic IP groups, import the traffic IP package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/trafficIpGroups"
)

Getting the list of traffic IP groups

    // to get the list of all traffic managers
    api := trafficIpGroups.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    trafficIPGroups := api.ResponseObject().(*trafficIpGroups.TrafficIPGroupList)

Retrieving a single traffic IP group

    api := trafficIpGroups.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    trafficIPGroup := api.ResponseObject().(*trafficIpGroups.TrafficIPGroup)

Creating a traffic IP group

    newTipg := trafficIpGroups.TrafficIPGroup{
        ...
    }

    api := trafficIpGroups.NewCreate( name, newTipg )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    tipgCreated := api.ResponseObject().(*trafficIpGroups.TrafficIPGroup)

Updating a traffic IP group

    updateTipg := trafficIpGroups.TrafficIPGroup{
        ...
    }

    api := trafficIpGroups.NewUpdate( name, updateTipg )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    tipgUpdated := api.ResponseObject().(*trafficIpGroups.TrafficIPGroup)

Deleting a traffic IP group

    api := trafficIpGroups.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Traffic IP group %s deleted", name)
    }

Working with traffic ip group managers

Traffic IP Group Managers are only used by Traffic IP Group to retrieve a list of Traffic Mangers when creating a Traffic IP Group.

Importing proper packages

In order to work with traffic ip group managers, import the traffic ip group package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/traffic_ip_group_managers"
)

Getting the list of traffic ip group managers

    api := trafficIpGroupManager.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    trafficIPGroupManagers := api.ResponseObject().(*trafficIpGroupManager.TrafficManagerChildren)

Working with virtual servers

Importing proper packages

In order to work with virtual servers, import the virtual server package section:

import (
    "github.com/sky-uk/go-brocade-vtm/api/virtualserver"
)

Getting the list of virtual servers

    api := virtualserver.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    virtualServer := api.ResponseObject().(*virtualserver.VirtualServersList)

Retrieving a single virtual server

    api := virtualserver.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    virtualServer := api.ResponseObject().(*virtualserver.VirtualServer)

Creating a virtual server

    newVS := virtualserver.VirtualServer{
        ...
    }

    api := virtualserver.NewCreate( name, newVS )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    vsCreated := api.ResponseObject().(*virtualserver.VirtualServer)

Updating a virtual server

    updateVS := virtualserver.VirtualServer{
        ...
    }

    api := virtualserver.NewUpdate( name, updateVS )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    vsUpdated := api.ResponseObject().(*virtualserver.VirtualServer)

Deleting a virtual server

    api := virtualserver.NewDelete( name )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Virtual server %s deleted", name)
    }

Working with rules

Importing proper packages

 In order to work with rules, import the rule package section:
 
 ```
 import (
     "github.com/sky-uk/go-brocade-vtm/api/rule"
 )
 ```

Getting the list of rules

    api := rule.NewGetAll()
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    rules := api.ResponseObject().(*rule.Rules)

Retrieving a single rule

    api := rule.NewGet(name)
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

    // Returns the traffic script as a string
    trafficScript := api.ResponseObject().(*[]byte)

Creating a rule

    ruleName := "my-rule"
    trafficScript := []byte(`
            if( string.ipmaskmatch( request.getremoteip(), "192.168.123.10" ) ){
                    connection.discard();
            }`)
    
    api := rule.NewCreate( ruleName, trafficScript )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

Updating a rule

    ruleName := "my-rule"
    updatedTrafficScript := []byte(`
                                     if( string.ipmaskmatch( request.getremoteip(), "192.168.123.10" ) ){
                                             connection.discard();
                                     }`)
                                     
    api := rule.NewUpdate( ruleName, updatedTrafficScript )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    }

Deleting a rule

    nameRuleToDelete := "my-rule"

    api := rule.NewDelete( nameRuleToDelete )
    err := client.Do(api)
    if err != nil {
        log.Fatal(err)
    } else {
        log.Printf("Rule %s deleted", nameRuleToDelete)
    }

Using the CLI

Run make in the root of the repository to build the go-brocade-vtm-cli binary. Once built the binary may be found in the root of the repository.

Currently only rules may be managed by the cli.

Authentication

Set the following shell environment variables to allow the cli to make changes to a Brocade vTM. Note that the cli automatically prefixes the value of BROCADEVTM_SERVER with https://.

$ export BROCADEVTM_USERNAME=admin
$ export BROCADEVTM_PASSWORD=myPassword
$ export BROCADEVTM_SERVER=my-brocade-vtm.example.com:9070

Getting help

$ ./go-brocade-vtm-cli -h

Working with rules

Create a rule

To create a rule ensure the traffic script is in the file /path/to/traffic_script.

$ ./go-brocade-vtm-cli rule-create -name my-rule -script /path/to/traffic_script
Showing rules

To list all rules.

$ ./go-brocade-vtm-cli rule-show-all

To show a rule called 'my-rule'.

$ ./go-brocade-vtm-cli rule-show -name my-rule
Updating a rule

To update a rule called 'my-rule' with the traffic script (file) /path/to/updated_traffic_script.

$ ./go-brocade-vtm-cli rule-update -name my-rule -script /path/to/updated_traffic_script
Deleting a rule

To delete a rule

$ ./go-brocade-vtm-cli rule-delete -name my-rule
Clone this wiki locally