func (e *InstanceTemplate) mapToGCE(project string) (*compute.InstanceTemplate, error) {
// TODO: This is similar to Instance...
var scheduling *compute.Scheduling
if fi.BoolValue(e.Preemptible) {
scheduling = &compute.Scheduling{
AutomaticRestart: false,
OnHostMaintenance: "TERMINATE",
Preemptible: true,
}
} else {
scheduling = &compute.Scheduling{
AutomaticRestart: true,
// TODO: Migrate or terminate?
OnHostMaintenance: "MIGRATE",
Preemptible: false,
}
}
glog.Infof("We should be using NVME for GCE")
var disks []*compute.AttachedDisk
disks = append(disks, &compute.AttachedDisk{
InitializeParams: &compute.AttachedDiskInitializeParams{
SourceImage: BuildImageURL(project, *e.BootDiskImage),
DiskSizeGb: *e.BootDiskSizeGB,
DiskType: *e.BootDiskType,
},
Boot: true,
DeviceName: "persistent-disks-0",
Index: 0,
AutoDelete: true,
Mode: "READ_WRITE",
Type: "PERSISTENT",
})
var tags *compute.Tags
if e.Tags != nil {
tags = &compute.Tags{
Items: e.Tags,
}
}
var networkInterfaces []*compute.NetworkInterface
ni := &compute.NetworkInterface{
AccessConfigs: []*compute.AccessConfig{{
//NatIP: *e.IPAddress.Address,
Type: "ONE_TO_ONE_NAT",
}},
Network: e.Network.URL(project),
}
if e.Subnet != nil {
ni.Subnetwork = *e.Subnet.Name
}
networkInterfaces = append(networkInterfaces, ni)
var serviceAccounts []*compute.ServiceAccount
if e.Scopes != nil {
var scopes []string
for _, s := range e.Scopes {
s = expandScopeAlias(s)
scopes = append(scopes, s)
}
serviceAccounts = append(serviceAccounts, &compute.ServiceAccount{
Email: "default",
Scopes: scopes,
})
}
var metadataItems []*compute.MetadataItems
for key, r := range e.Metadata {
v, err := fi.ResourceAsString(r)
if err != nil {
return nil, fmt.Errorf("error rendering InstanceTemplate metadata %q: %v", key, err)
}
metadataItems = append(metadataItems, &compute.MetadataItems{
Key: key,
Value: fi.String(v),
})
}
i := &compute.InstanceTemplate{
Name: *e.Name,
Properties: &compute.InstanceProperties{
CanIpForward: *e.CanIPForward,
Disks: disks,
MachineType: *e.MachineType,
Metadata: &compute.Metadata{
Items: metadataItems,
},
NetworkInterfaces: networkInterfaces,
Scheduling: scheduling,
ServiceAccounts: serviceAccounts,
Tags: tags,
},
}
return i, nil
}
func (e *Instance) mapToGCE(project string, ipAddressResolver func(*IPAddress) (*string, error)) (*compute.Instance, error) {
zone := *e.Zone
var scheduling *compute.Scheduling
if fi.BoolValue(e.Preemptible) {
scheduling = &compute.Scheduling{
OnHostMaintenance: "TERMINATE",
Preemptible: true,
}
} else {
scheduling = &compute.Scheduling{
AutomaticRestart: true,
// TODO: Migrate or terminate?
OnHostMaintenance: "MIGRATE",
Preemptible: false,
}
}
var disks []*compute.AttachedDisk
disks = append(disks, &compute.AttachedDisk{
InitializeParams: &compute.AttachedDiskInitializeParams{
SourceImage: BuildImageURL(project, *e.Image),
},
Boot: true,
DeviceName: "persistent-disks-0",
Index: 0,
AutoDelete: true,
Mode: "READ_WRITE",
Type: "PERSISTENT",
})
for name, disk := range e.Disks {
disks = append(disks, &compute.AttachedDisk{
Source: disk.URL(project),
AutoDelete: false,
Mode: "READ_WRITE",
DeviceName: name,
})
}
var tags *compute.Tags
if e.Tags != nil {
tags = &compute.Tags{
Items: e.Tags,
}
}
var networkInterfaces []*compute.NetworkInterface
if e.IPAddress != nil {
addr, err := ipAddressResolver(e.IPAddress)
if err != nil {
return nil, fmt.Errorf("unable to resolve IP for instance: %v", err)
}
if addr == nil {
return nil, fmt.Errorf("instance IP address has not yet been created")
}
networkInterface := &compute.NetworkInterface{
AccessConfigs: []*compute.AccessConfig{{
NatIP: *addr,
Type: "ONE_TO_ONE_NAT",
}},
Network: e.Network.URL(project),
}
if e.Subnet != nil {
networkInterface.Subnetwork = *e.Subnet.Name
}
networkInterfaces = append(networkInterfaces, networkInterface)
}
var serviceAccounts []*compute.ServiceAccount
if e.Scopes != nil {
var scopes []string
for _, s := range e.Scopes {
s = expandScopeAlias(s)
scopes = append(scopes, s)
}
serviceAccounts = append(serviceAccounts, &compute.ServiceAccount{
Email: "default",
Scopes: scopes,
})
}
var metadataItems []*compute.MetadataItems
for key, r := range e.Metadata {
v, err := fi.ResourceAsString(r)
if err != nil {
return nil, fmt.Errorf("error rendering Instance metadata %q: %v", key, err)
}
metadataItems = append(metadataItems, &compute.MetadataItems{
Key: key,
Value: fi.String(v),
})
}
i := &compute.Instance{
CanIpForward: *e.CanIPForward,
Disks: disks,
MachineType: BuildMachineTypeURL(project, zone, *e.MachineType),
Metadata: &compute.Metadata{
Items: metadataItems,
},
Name: *e.Name,
NetworkInterfaces: networkInterfaces,
Scheduling: scheduling,
ServiceAccounts: serviceAccounts,
Tags: tags,
}
return i, nil
}