Finish and test opennebula_template resource implementation

Author: larribas

.gitignore

@@ -24,4 +24,5 @@ _testmain.go
 *.prof
 
 tmp/
-.env
+.env
+test.go

main.go

@@ -9,4 +9,4 @@ func main() {
 	plugin.Serve(&plugin.ServeOpts{
 		ProviderFunc: opennebula.Provider,
 	})
-}
+}

opennebula/client.go

@@ -0,0 +1,70 @@
+package opennebula
+
+import (
+	"fmt"
+	"github.com/kolo/xmlrpc"
+	"log"
+	"strconv"
+)
+
+type Client struct {
+	Rcp      xmlrpc.Client
+	session  string
+	Username string
+	Password string
+}
+
+func NewClient(endpoint, username, password string) (*Client, error) {
+	client, err := xmlrpc.NewClient(endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{
+		Rcp:      *client,
+		session:  fmt.Sprintf("%s:%s", username, password),
+		Username: username,
+		Password: password,
+	}, nil
+}
+
+func (c *Client) Call(command string, args ...interface{}) (string, error) {
+	var result []interface{}
+
+	args = append([]interface{}{c.session}, args...)
+
+	if err := c.Rcp.Call(command, args, &result); err != nil {
+		return "", err
+	}
+
+	res, err := c.IsSuccess(result)
+	if err != nil {
+		return "", err
+	}
+
+	return res, nil
+}
+
+func (c *Client) IsSuccess(result []interface{}) (res string, err error) {
+	if !result[0].(bool) {
+		err = fmt.Errorf("%s", result[1].(string))
+		return
+	}
+
+	if w, ok := result[1].(int64); ok {
+		res = strconv.FormatInt(w, 10)
+	} else if w, ok := result[1].(string); ok {
+		res = w
+	}
+
+	return
+}
+
+func intId(id string) int {
+	i, err := strconv.Atoi(id)
+	if err != nil {
+		log.Fatalf("Unexpected ID %s received from OpenNebula. Expected an integer", id)
+	}
+
+	return i
+}

opennebula/config.go

@@ -7,7 +7,7 @@ import (
 
 type Config struct {
 	Endpoint string
-	User string
+	User     string
 	Password string
 }
 
@@ -22,4 +22,4 @@ func (c *Config) Client() (*api.Rpc, error) {
 	log.Printf("[INFO] OpenNebula Client configured for URL: %s", c.Endpoint)
 
 	return api.NewClient(config)
-}
+}

opennebula/permissions.go

@@ -0,0 +1,44 @@
+package opennebula
+
+import (
+	"strconv"
+	"strings"
+)
+
+type Permissions struct {
+	Owner_U int `xml:"OWNER_U"`
+	Owner_M int `xml:"OWNER_M"`
+	Owner_A int `xml:"OWNER_A"`
+	Group_U int `xml:"GROUP_U"`
+	Group_M int `xml:"GROUP_M"`
+	Group_A int `xml:"GROUP_A"`
+	Other_U int `xml:"OTHER_U"`
+	Other_M int `xml:"OTHER_M"`
+	Other_A int `xml:"OTHER_A"`
+}
+
+func permissionString(p *Permissions) string {
+	owner := p.Owner_U<<2 | p.Owner_M<<1 | p.Owner_A
+	group := p.Group_U<<2 | p.Group_M<<1 | p.Group_A
+	other := p.Other_U<<2 | p.Other_M<<1 | p.Other_A
+	return strconv.Itoa(owner*100 + group*10 + other)
+}
+
+func permission(p string) *Permissions {
+	perms := strings.Split(p, "")
+	owner, _ := strconv.Atoi(perms[0])
+	group, _ := strconv.Atoi(perms[1])
+	other, _ := strconv.Atoi(perms[2])
+
+	return &Permissions{
+		Owner_U: owner & 4 >> 2,
+		Owner_M: owner & 2 >> 1,
+		Owner_A: owner & 1,
+		Group_U: group & 4 >> 2,
+		Group_M: group & 2 >> 1,
+		Group_A: group & 1,
+		Other_U: other & 4 >> 2,
+		Other_M: other & 2 >> 1,
+		Other_A: other & 1,
+	}
+}

opennebula/provider.go

@@ -12,16 +12,19 @@ func Provider() terraform.ResourceProvider {
 				Type:        schema.TypeString,
 				Required:    true,
 				Description: "The URL to your public or private OpenNebula",
+				DefaultFunc: schema.EnvDefaultFunc("OPENNEBULA_ENDPOINT", nil),
 			},
-			"user": {
+			"username": {
 				Type:        schema.TypeString,
 				Required:    true,
 				Description: "The ID of the user to identify as",
+				DefaultFunc: schema.EnvDefaultFunc("OPENNEBULA_USERNAME", nil),
 			},
 			"password": {
 				Type:        schema.TypeString,
 				Required:    true,
 				Description: "The password for the user",
+				DefaultFunc: schema.EnvDefaultFunc("OPENNEBULA_PASSWORD", nil),
 			},
 		},
 
@@ -34,10 +37,9 @@ func Provider() terraform.ResourceProvider {
 }
 
 func providerConfigure(d *schema.ResourceData) (interface{}, error) {
-	config := Config{
-		Endpoint: d.Get("endpoint").(string),
-		User: d.Get("user").(string),
-		Password: d.Get("password").(string),
-	}
-	return config.Client()
+	return NewClient(
+		d.Get("endpoint").(string),
+		d.Get("username").(string),
+		d.Get("password").(string),
+	)
 }

opennebula/provider_test.go

@@ -1,9 +1,10 @@
 package opennebula
 
 import (
-	"testing"
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/terraform"
+	"os"
+	"testing"
 )
 
 func TestProvider(t *testing.T) {
@@ -14,4 +15,26 @@ func TestProvider(t *testing.T) {
 
 func TestProvider_impl(t *testing.T) {
 	var _ terraform.ResourceProvider = Provider()
-}
+}
+
+var testAccProviders map[string]terraform.ResourceProvider
+var testAccProvider *schema.Provider
+
+func init() {
+	testAccProvider = Provider().(*schema.Provider)
+	testAccProviders = map[string]terraform.ResourceProvider{
+		"opennebula": testAccProvider,
+	}
+}
+
+func testAccPreCheck(t *testing.T) {
+	testEnvIsSet("OPENNEBULA_ENDPOINT", t)
+	testEnvIsSet("OPENNEBULA_USERNAME", t)
+	testEnvIsSet("OPENNEBULA_PASSWORD", t)
+}
+
+func testEnvIsSet(k string, t *testing.T) {
+	if v := os.Getenv(k); v == "" {
+		t.Fatalf("%s must be set for acceptance tests", k)
+	}
+}