allowing for http api to be used for fleet provider

.gitignore

@@ -0,0 +1,3 @@
+bin/*
+terraform-provider-fleet
+

README.md

@@ -12,11 +12,37 @@ A plugin for Terraform enabling it to manipulate
 
 ## Usage
 
+This terraform plugin supports basic connections to the ETCD endpoint,
+the HTTP API endpoint, and over SSH
+
+There is minimal configuration currently supported so the ETCD and API clients
+are attempting to connect directly without SSL
+
+The configuration value 'driver' defaults to 'tunnel' but can be configured with:
+ * etcd
+ * api
+
+EX:
+
+```
+provider "fleet" {
+  driver = "etcd"
+  endpoint = "http://192.168.0.1:4001"
+}
+```
+
+```
+provider "fleet" {
+  driver = "api"
+  endpoint = "http://192.168.0.1:4001"
+}
+```
+
 There is only one resource: `fleet_unit`. Here is the first example from
 [the Fleet introduction][3], transcribed to Terraform:
 
     provider "fleet" {
-        tunnel_address = "IP_OR_HOSTNAME_OF_A_COREOS_HOST"
+        endpoint = "IP_OR_HOSTNAME_OF_A_COREOS_HOST"
     }
 
     resource "fleet_unit" "myapp" {

provider.go

@@ -6,15 +6,31 @@ import (
 	"net/url"
 	"strings"
 	"time"
+	"fmt"
+	"log"
 
 	"github.com/coreos/fleet/client"
 	"github.com/coreos/fleet/pkg"
 	"github.com/coreos/fleet/ssh"
 
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/terraform"
+
+	"github.com/coreos/fleet/version"
+	"github.com/coreos/fleet/registry"
+
+	etcd "github.com/coreos/fleet/Godeps/_workspace/src/github.com/coreos/etcd/client"
 )
 
+const oldVersionWarning = `####################################################################
+WARNING: fleetctl (%s) is older than the latest registered
+version of fleet found in the cluster (%s). You are strongly
+recommended to upgrade fleetctl to prevent incompatibility issues.
+####################################################################
+`
+
+const defaultTimeout = time.Second*10
+
 // retry wraps a function with retry logic. Only errors containing "timed out"
 // will be retried. (authentication errors and other stuff should fail
 // immediately)
@@ -31,14 +47,67 @@ func retry(f func() (interface{}, error), maxRetries int) (interface{}, error) {
 	return result, err
 }
 
-// getAPI returns an API to Fleet.
-func getAPI(hostAddr string, maxRetries int) (client.API, error) {
-	if hostAddr == "" {
-		return nullAPI{}, nil
+func checkVersion(cReg registry.ClusterRegistry) (string, bool) {
+	fv := version.SemVersion
+	lv, err := cReg.LatestDaemonVersion()
+	if err != nil {
+		log.Fatal("error attempting to check latest fleet version in Registry: %v", err)
+	} else if lv != nil && fv.LessThan(*lv) {
+		return fmt.Sprintf(oldVersionWarning, fv.String(), lv.String()), false
 	}
+	return "", true
+}
+
+func getHTTPClient(driverEndpoint string) (client.API, error) {
+	log.Printf("Using API connection for requests")
+
+	endpoint, err := url.Parse(driverEndpoint)
+
+	if err != nil {
+		return nil, err
+	}
+
+	trans := pkg.LoggingHTTPTransport{
+		Transport: http.Transport{},
+	}
+
+	httpClient := http.Client{
+		Transport: &trans,
+	}
+
+	return client.NewHTTPClient(&httpClient, *endpoint)
+}
+
+func getETCDClient(driverEndpoint string, etcdKeyPrefix string) (client.API, error) {
+	log.Printf("Using ETCD connection for requests")
+
+	trans := &http.Transport{}
+
+	eCfg := etcd.Config{
+		Endpoints: strings.Split(driverEndpoint, ","),
+		Transport: trans,
+	}
+
+	eClient, err := etcd.New(eCfg)
+	if err != nil {
+		return nil, err
+	}
+
+	kAPI := etcd.NewKeysAPI(eClient)
+	reg := registry.NewEtcdRegistry(kAPI, etcdKeyPrefix, defaultTimeout)
+
+	if msg, ok := checkVersion(reg); !ok {
+		log.Printf(msg)
+	}
+
+	return &client.RegistryClient{Registry: reg}, nil
+}
+
+func getTunnelClient(driverEndpoint string, maxRetries int) (client.API, error) {
+	log.Printf("Using Fleet Tunnel connection for requests")
 
 	getSSHClient := func() (interface{}, error) {
-		return ssh.NewSSHClient("core", hostAddr, nil, false, time.Second*10)
+		return ssh.NewSSHClient("core", driverEndpoint, nil, false, defaultTimeout)
 	}
 
 	result, err := retry(getSSHClient, maxRetries)
@@ -52,6 +121,15 @@ func getAPI(hostAddr string, maxRetries int) (client.API, error) {
 		return ssh.DialCommand(sshClient, cmd)
 	}
 
+	// This is needed to fake out the client - it isn't used
+	// since we're overloading the dial method on the transport
+	// but the client complains if it isn't set
+	fakeHttpEndpoint, err := url.Parse("http://domain-sock")
+
+	if err != nil {
+		return nil, err
+	}
+
 	trans := pkg.LoggingHTTPTransport{
 		Transport: http.Transport{
 			Dial: dial,
@@ -62,27 +140,54 @@ func getAPI(hostAddr string, maxRetries int) (client.API, error) {
 		Transport: &trans,
 	}
 
-	// since dial() ignores the endpoint, we just need something here that
-	// won't make the HTTP client complain.
-	endpoint, err := url.Parse("http://domain-sock")
+	return client.NewHTTPClient(&httpClient, *fakeHttpEndpoint)
+}
 
-	return client.NewHTTPClient(&httpClient, *endpoint)
+
+// getAPI returns an API to Fleet.
+func getAPI(driver string, driverEndpoint string, maxRetries int, etcdKeyPrefix string) (client.API, error) {
+
+	switch strings.ToLower(driver) {
+	case "api":
+		return getHTTPClient(driverEndpoint)
+	case "etcd":
+		return getETCDClient(driverEndpoint, etcdKeyPrefix)
+	case "tunnel":
+		return getTunnelClient(driverEndpoint, maxRetries)
+	case "null":
+		fallthrough
+	default:
+		return nullAPI{}, nil
+	}
 }
 
 // Provider returns the ResourceProvider implemented by this package. Serve
 // this with the Terraform plugin helper and you are golden.
 func Provider() terraform.ResourceProvider {
 	return &schema.Provider{
 		Schema: map[string]*schema.Schema{
-			"tunnel_address": &schema.Schema{
+			"driver": &schema.Schema{
 				Type:     schema.TypeString,
-				Required: true,
+				Optional: true,
+				Default: "tunnel",
+				Description: "Driver to use to connect to Fleet. Can be tunnel or api.",
+			},
+			"endpoint": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Description: "Endpoint for Fleet.",
 			},
 			"connection_retries": &schema.Schema{
 				Type:     schema.TypeInt,
 				Optional: true,
 				Default:  12,
 			},
+			"etc_key_prefix": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Default: "/_coreos.com/fleet/",
+				Description: "EtcdKeyPrefix to use for fleet",
+			},
 		},
 		ResourcesMap: map[string]*schema.Resource{
 			"fleet_unit": resourceUnit(),
@@ -92,7 +197,9 @@ func Provider() terraform.ResourceProvider {
 }
 
 func providerConfigure(d *schema.ResourceData) (interface{}, error) {
-	addr := d.Get("tunnel_address").(string)
 	retries := d.Get("connection_retries").(int)
-	return getAPI(addr, retries)
+	driver := d.Get("driver").(string)
+	endpoint := d.Get("endpoint").(string)
+	etcKeyPrefix := d.Get("etc_key_prefix").(string)
+	return getAPI(driver, endpoint, retries, etcKeyPrefix)
 }

provider_test.go

@@ -58,7 +58,7 @@ func TestGetAPI(test *testing.T) {
 	// when the address is an empty string, we get a nullAPI
 	var api client.API
 
-	api, err := getAPI("", 1)
+	api, err := getAPI("null", "endpoint", 1, "etcd_prefix")
 
 	if err != nil {
 		test.Fatal(err)