1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
package libvirt
import (
"fmt"
"log"
"strconv"
"encoding/xml"
//"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/helper/schema"
libvirt "gopkg.in/alexzorin/libvirt-go.v2"
)
type defDomain struct {
XMLName xml.Name `xml:"domain"`
Name string `xml:"name"`
Type string `xml:"type,attr"`
Os defOs `xml:"os"`
Memory defMemory `xml:"memory"`
}
type defOs struct {
Type defOsType `xml:"type"`
}
type defOsType struct {
Arch string `xml:"arch,attr"`
Machine string `xml:"machine,attr"`
Name string `xml:"chardata"`
}
type defMemory struct {
Unit string `xml:"unit,attr"`
Amount uint `xml:"chardata"`
}
func resourceLibvirtDomain() *schema.Resource {
return &schema.Resource{
Create: resourceLibvirtDomainCreate,
Read: resourceLibvirtDomainRead,
Update: resourceLibvirtDomainUpdate,
Delete: resourceLibvirtDomainDelete,
Schema: map[string]*schema.Schema{
"name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
}
}
func resourceLibvirtDomainCreate(d *schema.ResourceData, meta interface{}) error {
virConn := meta.(*Client).libvirt
if virConn == nil {
return fmt.Errorf("The libvirt connection was nil.")
}
domainDef := defDomain{
Name: d.Get("name").(string),
Type: "kvm",
Os: defOs{
defOsType{
Arch: "x86_64",
Machine: "pc-i440fx-2.4",
Name: "hvm",
},
},
Memory: defMemory{
Unit: "KiB",
Amount: 524288,
},
}
log.Printf("[INFO] Creating virtual machine")
data, err := xml.Marshal(domainDef)
if err != nil {
return fmt.Errorf("Error serializing libvirt domain: %s", err)
}
domain, err := virConn.DomainCreateXML(string(data), libvirt.VIR_DOMAIN_NONE)
if err != nil {
return fmt.Errorf("Error crearing libvirt domain: %s", err)
}
id, err := domain.GetID()
if err != nil {
return fmt.Errorf("Error retrieving libvirt domain id: %s", err)
}
d.SetId(fmt.Sprintf("%d", id))
log.Printf("[INFO] Virtual Machine ID: %s", d.Id())
return resourceLibvirtDomainRead(d, meta)
}
func resourceLibvirtDomainRead(d *schema.ResourceData, meta interface{}) error {
virConn := meta.(*Client).libvirt
if virConn == nil {
return fmt.Errorf("The libvirt connection was nil.")
}
id, err := strconv.Atoi(d.Id())
if err != nil {
return fmt.Errorf("Not a valid ID, must be an integer: %s", err)
}
domain, err := virConn.LookupDomainById(uint32(id))
if err != nil {
return fmt.Errorf("Error retrieving libvirt domain: %s", err)
}
name, err := domain.GetName()
if err != nil {
return fmt.Errorf("Error retrieving libvirt domain name: %s", err)
}
d.Set("name", name)
return nil
}
func resourceLibvirtDomainUpdate(d *schema.ResourceData, meta interface{}) error {
return fmt.Errorf("Couldn't update libvirt domain")
}
func resourceLibvirtDomainDelete(d *schema.ResourceData, meta interface{}) error {
virConn := meta.(*Client).libvirt
if virConn == nil {
return fmt.Errorf("The libvirt connection was nil.")
}
id, err := strconv.Atoi(d.Id())
if err != nil {
return fmt.Errorf("Not a valid ID, must be an integer: %s", err)
}
domain, err := virConn.LookupDomainById(uint32(id))
if err != nil {
return fmt.Errorf("Error retrieving libvirt domain: %s", err)
}
err = domain.Destroy()
if err != nil {
return fmt.Errorf("Couldn't destroy libvirt domain: %s", err)
}
return nil
}
|