Enhancement: Added resource for snapshot and revert snapshot

vsphere/provider.go

@@ -68,6 +68,8 @@ func Provider() terraform.ResourceProvider {
 			"vsphere_folder":          resourceVSphereFolder(),
 			"vsphere_virtual_disk":    resourceVSphereVirtualDisk(),
 			"vsphere_virtual_machine": resourceVSphereVirtualMachine(),
+			"vsphere_snapshot":        resourceVSphereSnapshot(),
+			"vsphere_snapshot_revert": resourceVSphereRevertSnapshot(),
 		},
 
 		ConfigureFunc: providerConfigure,

vsphere/resource_vsphere_revert_snapshot.go

@@ -0,0 +1,77 @@
+package vsphere
+
+import (
+	"fmt"
+	"github.com/hashicorp/terraform/helper/schema"
+	"golang.org/x/net/context"
+	"log"
+)
+
+func resourceVSphereRevertSnapshot() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceVSphereSnapshotRevert,
+		Delete: resourceVSphereSnapshotDummyDelete,
+		Read:   resourceVSphereSnapshotDummyRead,
+
+		Schema: map[string]*schema.Schema{
+			"datacenter": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"vm_name": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				DefaultFunc: schema.EnvDefaultFunc("VSPHERE_VM_NAME", nil),
+			},
+			"folder": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				DefaultFunc: schema.EnvDefaultFunc("VSPHERE_VM_FOLDER", nil),
+			},
+			"snapshot_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"suppress_power_on": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func resourceVSphereSnapshotRevert(d *schema.ResourceData, meta interface{}) error {
+	vm, err := findVM(d, meta)
+	if err != nil {
+		return fmt.Errorf("Error while getting the VirtualMachine :%s", err)
+	}
+	task, err := vm.RevertToSnapshot(context.TODO(), d.Get("snapshot_name").(string), d.Get("suppress_power_on").(bool))
+	if err != nil {
+		log.Printf("[ERROR] Error While Creating the Task for Revert Snapshot: %v", err)
+		return fmt.Errorf("Error While Creating the Task for Revert Snapshot: %s", err)
+	}
+	log.Printf("[INFO] Task created for Revert Snapshot: %v", task)
+
+	err = task.Wait(context.TODO())
+	if err != nil {
+		log.Printf("[ERROR] Error While waiting for the Task of Revert Snapshot: %v", err)
+		return fmt.Errorf("Error While waiting for the Task of Revert Snapshot: %s", err)
+	}
+	log.Printf("[INFO] Revert Snapshot completed %v", d.Get("snapshot_name").(string))
+	d.SetId(d.Get("snapshot_name").(string))
+	return nil
+
+}
+
+func resourceVSphereSnapshotDummyRead(d *schema.ResourceData, meta interface{}) error {
+	return nil
+}
+
+func resourceVSphereSnapshotDummyDelete(d *schema.ResourceData, meta interface{}) error {
+	return nil
+}

vsphere/resource_vsphere_revert_snapshot_test.go

@@ -0,0 +1,101 @@
+package vsphere
+
+import (
+	"fmt"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+	"github.com/vmware/govmomi"
+	"github.com/vmware/govmomi/find"
+	"github.com/vmware/govmomi/vim25/mo"
+	"golang.org/x/net/context"
+	"os"
+	"testing"
+)
+
+func testBasicPreCheckSnapshotRevert(t *testing.T) {
+
+	testAccPreCheck(t)
+
+	if v := os.Getenv("VSPHERE_VM_NAME"); v == "" {
+		t.Fatal("env variable VSPHERE_VM_NAME must be set for acceptance tests")
+	}
+
+	if v := os.Getenv("VSPHERE_VM_FOLDER"); v == "" {
+		t.Fatal("env variable VSPHERE_VM_FOLDER must be set for acceptance tests")
+	}
+}
+
+func TestAccVmSnanpshotRevert_Basic(t *testing.T) {
+	snapshot_name := "SnapshotForTestingTerraform"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckVmSnapshotRevertDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccCheckVmSnapshotRevertConfig_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckVmCurrentSnapshot("vsphere_snapshot_revert.Test_terraform_cases", snapshot_name),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckVmSnapshotRevertDestroy(s *terraform.State) error {
+
+	return nil
+}
+
+func testAccCheckVmCurrentSnapshot(n, snapshot_name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No Vm Snapshot ID is set")
+		}
+		client := testAccProvider.Meta().(*govmomi.Client)
+
+		dc, err := getDatacenter(client, "")
+		if err != nil {
+			return fmt.Errorf("error %s", err)
+		}
+		finder := find.NewFinder(client.Client, true)
+		finder = finder.SetDatacenter(dc)
+		vm, err := finder.VirtualMachine(context.TODO(), vmPath(os.Getenv("VSPHERE_VM_FOLDER"), os.Getenv("VSPHERE_VM_NAME")))
+		if err != nil {
+			return fmt.Errorf("error %s", err)
+		}
+
+		var vm_object mo.VirtualMachine
+
+		err = vm.Properties(context.TODO(), vm.Reference(), []string{"snapshot"}, &vm_object)
+
+		if err != nil {
+			return nil
+		}
+		current_snap := vm_object.Snapshot.CurrentSnapshot
+		snapshot, err := vm.FindSnapshot(context.TODO(), snapshot_name)
+
+		if err != nil {
+			return fmt.Errorf("Error while getting the snapshot %v", snapshot)
+		}
+		if fmt.Sprintf("<%s>", snapshot) == fmt.Sprintf("<%s>", current_snap) {
+			return nil
+		}
+
+		return fmt.Errorf("Test Case failed for revert snapshot. Current snapshot does not match to reverted snapshot")
+	}
+}
+
+const testAccCheckVmSnapshotRevertConfig_basic = `
+resource "vsphere_snapshot_revert" "Test_terraform_cases"{
+
+	snapshot_name = "SnapshotForTestingTerraform"
+	suppress_power_on = "true"
+}`

vsphere/resource_vsphere_snapshot.go

@@ -0,0 +1,205 @@
+package vsphere
+
+import (
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/vmware/govmomi"
+	"github.com/vmware/govmomi/find"
+	"github.com/vmware/govmomi/object"
+	"golang.org/x/net/context"
+)
+
+func resourceVSphereSnapshot() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceVSphereSnapshotCreate,
+		Read:   resourceVSphereSnapshotRead,
+		Delete: resourceVSphereSnapshotDelete,
+
+		Schema: map[string]*schema.Schema{
+			"datacenter": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+			"vm_name": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				DefaultFunc: schema.EnvDefaultFunc("VSPHERE_VM_NAME", nil),
+			},
+			"folder": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				DefaultFunc: schema.EnvDefaultFunc("VSPHERE_VM_FOLDER", nil),
+			},
+			"snapshot_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"description": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"memory": {
+				Type:     schema.TypeBool,
+				Required: true,
+				ForceNew: true,
+			},
+			"quiesce": {
+				Type:     schema.TypeBool,
+				Required: true,
+				ForceNew: true,
+			},
+			"remove_children": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+			"consolidate": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func resourceVSphereSnapshotCreate(d *schema.ResourceData, meta interface{}) error {
+	vm, err := findVM(d, meta)
+	if err != nil {
+		return fmt.Errorf("Error while getting the VirtualMachine :%s", err)
+	}
+	task, err := vm.CreateSnapshot(context.TODO(), d.Get("snapshot_name").(string), d.Get("description").(string), d.Get("memory").(bool), d.Get("quiesce").(bool))
+	if err != nil {
+		log.Printf("[ERROR] Error While Creating the Task for Create Snapshot: %v", err)
+		return fmt.Errorf(" Error While Creating the Task for Create Snapshot: %s", err)
+	}
+	log.Printf("[INFO] Task created for Create Snapshot: %v", task)
+	err = task.Wait(context.TODO())
+	if err != nil {
+		log.Printf("[ERROR] Error While waiting for the Task for Create Snapshot: %v", err)
+		return fmt.Errorf(" Error While waiting for the Task for Create Snapshot: %s", err)
+	}
+	log.Printf("[INFO] Create Snapshot completed %v", d.Get("snapshot_name").(string))
+	d.SetId(d.Get("snapshot_name").(string))
+	d.Set("snapshot_name", d.Get("snapshot_name").(string))
+	d.Set("vm_name", d.Get("vm_name").(string))
+	d.Set("folder", d.Get("folder").(string))
+	d.Set("description", d.Get("description").(string))
+	d.Set("memory", d.Get("memory").(bool))
+	d.Set("quiesce", d.Get("quiesce").(bool))
+
+	if v, ok := d.GetOk("consolidate"); ok {
+		d.Set("consolidate", v.(bool))
+
+	}
+	if v, ok := d.GetOk("remove_children"); ok {
+		d.Set("remove_children", v.(bool))
+	}
+
+	return nil
+}
+
+func resourceVSphereSnapshotDelete(d *schema.ResourceData, meta interface{}) error {
+	vm, err := findVM(d, meta)
+	if err != nil {
+		return fmt.Errorf("Error while getting the VirtualMachine :%s", err)
+	}
+	resourceVSphereSnapshotRead(d, meta)
+	if d.Id() == "" {
+		log.Printf("[ERROR] Error While finding the Snapshot: %v", err)
+		return nil
+	}
+	log.Printf("[INFO] Deleting snapshot with name: %v", d.Get("snapshot_name").(string))
+	var consolidate_ptr *bool
+	var remove_children bool
+
+	if v, ok := d.GetOk("consolidate"); ok {
+		consolidate := v.(bool)
+		consolidate_ptr = &consolidate
+	} else {
+
+		consolidate := true
+		consolidate_ptr = &consolidate
+	}
+	if v, ok := d.GetOk("remove_children"); ok {
+		remove_children = v.(bool)
+	} else {
+
+		remove_children = false
+	}
+
+	task, err := vm.RemoveSnapshot(context.TODO(), d.Get("snapshot_name").(string), remove_children, consolidate_ptr)
+
+	if err != nil {
+		log.Printf("[ERROR] Error While Creating the Task for Delete Snapshot: %v", err)
+		return fmt.Errorf("Error While Creating the Task for Delete Snapshot: %s", err)
+	}
+	log.Printf("[INFO] Task created for Delete Snapshot: %v", task)
+
+	err = task.Wait(context.TODO())
+	if err != nil {
+		log.Printf("[ERROR] Error While waiting for the Task of Delete Snapshot: %v", err)
+		return fmt.Errorf("Error While waiting for the Task of Delete Snapshot: %s", err)
+	}
+	log.Printf("[INFO] Delete Snapshot completed %v", d.Get("snapshot_name").(string))
+
+	return nil
+}
+
+func resourceVSphereSnapshotRead(d *schema.ResourceData, meta interface{}) error {
+	vm, err := findVM(d, meta)
+	if err != nil {
+		return fmt.Errorf("Error while getting the VirtualMachine :%s", err)
+	}
+	snapshotName := d.Get("snapshot_name").(string)
+	snapshot, err := vm.FindSnapshot(context.TODO(), snapshotName)
+
+	if err != nil {
+		if strings.Contains(err.Error(), "No snapshots for this VM") || strings.Contains(err.Error(), "snapshot \""+snapshotName+"\" not found") {
+			log.Printf("[ERROR] Error While finding the Snapshot: %v", err)
+			d.SetId("")
+			return nil
+		}
+		log.Printf("[ERROR] Error While finding the Snapshot: %v", err)
+		return fmt.Errorf("Error while finding the Snapshot :%s", err)
+	}
+	log.Printf("[INFO] Snapshot found: %v", snapshot)
+	return nil
+}
+
+func findVM(d *schema.ResourceData, meta interface{}) (*object.VirtualMachine, error) {
+	client := meta.(*govmomi.Client)
+	var dc *object.Datacenter
+	var err error
+	if v, ok := d.GetOk("datacenter"); ok {
+		dc, err = getDatacenter(client, v.(string))
+	} else {
+		dc, err = getDatacenter(client, "")
+	}
+	if err != nil {
+		log.Printf("[ERROR] Error While getting the DC: %v", err)
+		return nil, fmt.Errorf("Error While getting the DC: %s", err)
+	}
+	log.Printf("[INFO] DataCenter is: %v", dc)
+	log.Println("[INFO] Getting Finder:")
+	finder := find.NewFinder(client.Client, true)
+	log.Printf("[INFO] Finder is: %v", finder)
+	log.Println("[INFO] Setting DataCenter:")
+	finder = finder.SetDatacenter(dc)
+	log.Printf("[INFO] DataCenter is Set: %v", finder)
+	log.Println("[INFO] Getting VM Object: ")
+	vm, err := finder.VirtualMachine(context.TODO(), vmPath(d.Get("folder").(string), d.Get("vm_name").(string)))
+	if err != nil {
+		log.Printf("[ERROR] Error While getting the Virtual machine object: %v", err)
+		return nil, err
+	}
+	log.Printf("[INFO] Virtual Machine FOUND: %v", vm)
+	return vm, nil
+}