gautocloud

Gautocloud provides a simple abstraction that golang based applications can use to discover information about the cloud environment on which they are running, to connect to services automatically with ease of use in mind. It provides out-of-the-box support for discovering common services on Heroku, Cloud Foundry and kubernetes cloud platforms, and it supports custom automatic connectors. For more details see the gautocloud project

disclaimer

I&S Cloud Operations is not responsible and does not support usage of this repository. This is a Philips Open Source project and any support is provided through this Github project only. Please do not raise SNOW tickets related to any usage of the software hosted here.

gautocloud connectors for HSDP services

This repository contains gautocloud connectors for select HSDP Cloud foundry services. At this time the following connectors are supported:

• Twilio Raw
• Twilio Client
• DynamoDB Client
• Redshift
• Redis Sentinel
• Vault Client
• S3 Client
• S3 Minio Client
• PostgreSQL Client
• Iron Raw
• Iron Client
• Cartel Raw
• Cartel Client
• Kafka Raw
• Kafka Dialer

usage

Import the packages in your app, this will register all the supported connectors and you can proceed to detect the services you need:

import (
    "github.com/cloudfoundry-community/gautocloud"
    "github.com/philips-software/gautocloud-connectors/hsdp"
)

Twilio Raw

This returns the credentials so you can use them as you see fit

svc, err := gautocloud.GetFirst("hsdp:twilio-raw")
if err == nil {
    account, ok := svc.(hsdp.TwilioSubAccount)
    if ok {
        fmt.Printf("Loaded Twilio subaccount with SID: %s\n", account.SID)
    }
}

Twilio Go client

This returns a configured Twilio Go client based on github.com/kevinburke/twilio-go

import (
    "github.com/kevinburke/twilio-go"
    "github.com/cloudfoundry-community/gautocloud"
    _ "github.com/philips-software/gautocloud-connectors/hsdp"
)

svc, err := gautocloud.GetFirst("hsdp:twilio-client")
if err == nil {
    client, ok := svc.(*twilio.Client)
    if ok {
        // Iterate over calls
        iterator := client.Calls.GetPageIterator(url.Values{})
        for {
            page, err := iterator.Next(context.TODO())
            if err == twilio.NoMoreResults {
                break
            }
            fmt.Println("start", page.Start)
        }
    }
}

DynamoDB client

A configured DynamDBClient based on the AWS SDK

import (
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/cloudfoundry-community/gautocloud"
    _ "github.com/philips-software/gautocloud-connectors/hsdp"
)

db, err := gautocloud.GetFirst("hsdp:dynamodb-client")
client, ok := db.(*hsdp.DynamoDBClient)
if ok {
        fmt.Printf("Loaded DynamoDB client, table: %s\n", client.TableName)
        req := &dynamodb.DescribeTableInput{
                TableName: aws.String(client.TableName),
        }
        // Fetches and display details of the DynamoDB table
        result, err := client.DescribeTable(req)
        if err != nil {
                fmt.Printf("%s", err)
        }
        table := result.Table
        fmt.Printf("done: %v\n", table)
}

Redshift

This returns a configured (wrapped) PostgreSQLDB connection ready for use.

import (
    "github.com/cloudfoundry-community/gautocloud"
    "github.com/cloudfoundry-community/gautocloud/connectors/databases/dbtype"
    _ "github.com/philips-software/gautocloud-connectors/hsdp"
)

	var rs *dbtype.PostgresqlDB

	err := gautocloud.InjectFromId("hsdp:redshift", &rs)

	if err != nil {
		fmt.Printf("failed to find attached database: %v\n", err)
		return
	}

	rows, err := rs.Query("SELECT now()")

	if err != nil {
		fmt.Printf("query error: %v\n", err)
		return
    }
    
	for rows.Next() {
		var col string
		rows.Scan(&col)
		fmt.Printf("%v\n", col)
	}

Redis Sentinel

Returns a redis.ClusterClient ready for use

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/cloudfoundry-community/gautocloud"
	"github.com/go-redis/redis/v8"
	_ "github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
	var client *redis.ClusterClient

	err := gautocloud.InjectFromId("hsdp:redis-db", &client)

	if err != nil {
		fmt.Printf("Cannot find bound hsdp-redis-db instance\n")
		os.Exit(1)
	}
	
	// Write a key
	client.Set(context.Background(), "hello", "world", 24*time.Hour)

	// List it
	res := client.Keys(context.Background(), "*")
	fmt.Printf("Keys: %+v\n", res)
}

Vault client

Returns a VaultClient instance which is composed of the official Hashicorp Go Vault client and a VaultCredentials struct containing all the fields found in the service broker

import (
	"github.com/cloudfoundry-community/gautocloud"
	"github.com/philips-software/gautocloud-connectors/hsdp"
)

	var vaultClient *hsdp.VaultClient

	err := gautocloud.Inject(&vaultClient)

	if err != nil {
		fmt.Printf("%v\n", err)
		return
	}

	secret, err := vaultClient.WriteSpaceSecret("mysecret",
	 	map[string]interface{}{
			"foo": "bar",
			"alice": "bob",
			"bob": "trudy",
		})
		

S3 client

Returns an S3Client instance which is composed of an AWS S3 Credentials Session and S3Credentials struct containing all the fields found in the service broker credentials

package main

import (
	"github.com/cloudfoundry-community/gautocloud"
	"github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
	var svc *hsdp.S3Client

	err := gautocloud.Inject(&svc)

	if err != nil {
		fmt.Printf("%v\n", err)
		return
	}

	req, _ := svc.GetObjectRequest(&s3.GetObjectInput{
		Bucket: aws.String(svc.Bucket),
		Key:    aws.String("/public/somefile.zip"),
	})
	str, err := req.Presign(15 * time.Minute)

	fmt.Println("The URL is:", str, " err:", err)
}

S3 Minio client

Returns an S3MinioClient instance which uses the Minio S3 Go client. This client is generally more friendly in use and also works on Minio servers (e.g. HSoP). Preferred over the S3 Client.

package main

import (
	"github.com/cloudfoundry-community/gautocloud"
	"github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
	var svc *hsdp.S3MinioClient

	err := gautocloud.Inject(&svc)

	if err != nil {
		fmt.Printf("%v\n", err)
		return
	}

        // Upload a zip file
	objectName := "golden-oldies.zip"
	filePath := "/tmp/golden-oldies.zip"
	contentType := "application/zip"

	// Upload the zip file with FPutObject
	n, err := minioClient.FPutObject(ctx, bucketName, objectName, filePath, minio.PutObjectOptions{ContentType: contentType})
	if err != nil {
		fmt.Printf("%v\n", err)
                return
	}
        fmt.Printf("Success: %v\n", n)  
}

PostgreSQL client

Returns an initialized wrapped *sql.DB connection to our PostgreSQL database

package main

import (
    "fmt"
    "github.com/cloudfoundry-community/gautocloud"
    "github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
	var svc *hsdp.PostgreSQLClient

	err := gautocloud.Inject(&svc)

	rows, err := svc.DB.Query("SELECT now()")
	if err != nil {
		fmt.Printf("%v\n", err)
		return
	}
	for rows.Next() {
		var col string
		rows.Scan(&col)
		fmt.Printf("%v\n", col)
   }
}

Iron client

Returns an initalized wrapped *iron.Client from go-hsdp-api/iron.

package main

import (
        "fmt"

        "github.com/cloudfoundry-community/gautocloud"
        "github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
        var client *hsdp.IronClient
        err := gautocloud.Inject(&client)
        if err != nil {
                fmt.Printf("error finding IRON client: %v\n", err)
                return
        }
        fmt.Printf("Plan: %v\n", client.ClusterInfo[0].ClusterName)
        tasks, _, err := client.Tasks.GetTasks()
        if err != nil {
            fmt.Printf("error getting tasks: %v\n", err)
            return
        }
        for _, task := range *tasks {
            fmt.Printf("%v\n", task)
        }
}

Cartel client

Returns an initalized wrapped *cartel.Client go-hsdp-api/iron.

package main

import (
	"fmt"

	"github.com/cloudfoundry-community/gautocloud"
	"github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
	var client *hsdp.CartelClient
	err := gautocloud.Inject(&client)
	if err != nil {
		fmt.Printf("error finding Cartel client: %v\n", err)
		return
	}
	instances, _, err := client.GetAllInstances()
	if err != nil {
		fmt.Printf("error finding intances: %v\n", err)
		return
	}
	for _, instance := range *instances {
		fmt.Printf("%s\n", instance.InstanceID)
	}
}

Kafka raw

Returns Kafka credentials for use with a Kafka Go client. Example using the Segment IO Kafka Go client:

package main

import (
	"context"
	"fmt"

	"github.com/cloudfoundry-community/gautocloud"
	"github.com/philips-software/gautocloud-connectors/hsdp"
	"github.com/segmentio/kafka-go"
)

func main() {
	var creds hsdp.KafkaCredentials
	err := gautocloud.Inject(&creds)
	if err != nil {
		fmt.Printf("error finding Kafka service: %v\n", err)
		return
	}

	// make a new reader that consumes from topic-A, partition 0, at offset 42
	r := kafka.NewReader(kafka.ReaderConfig{
		Brokers:   creds.Hostnames,
		Topic:     "topic-A",
		Partition: 0,
		MinBytes:  10e3, // 10KB
		MaxBytes:  10e6, // 10MB
	})
	r.SetOffset(0)

	for {
		m, err := r.ReadMessage(context.Background())
		if err != nil {
			break
		}
		fmt.Printf("message at offset %d: %s = %s\n", m.Offset, string(m.Key), string(m.Value))
	}
	r.Close()
}

Kafka Dialer

Returns Kafka dialer for use with a Kafka Go client. Example using the Segment IO Kafka Go client:

package main

import (
	"fmt"

	"github.com/cloudfoundry-community/gautocloud"
	"github.com/philips-software/gautocloud-connectors/hsdp"
)

func main() {
	var dialer hsdp.KafkaDialer
	err := gautocloud.Inject(&dialer)
	if err != nil {
		fmt.Printf("error finding Kafka service: %v\n", err)
		return
	}
	conn, err := dialer.Dial("tcp", dialer.URI)
	if err != nil {
		fmt.Printf("failed to dial leader: %v\n", err)
		return
	}
	defer conn.Close()

	// Use conn...
}

Contact / Getting help

• andy.lo-a-foe@philips.com

Application using gautocloud

• s3dl
• rsdl

License

License is MIT