func (e *IPAddress) find(cloud *gce.GCECloud) (*IPAddress, error) {
r, err := cloud.Compute.Addresses.Get(cloud.Project, cloud.Region, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing IPAddresss: %v", err)
}
actual := &IPAddress{}
actual.Address = &r.Address
actual.Name = &r.Name
return actual, nil
}
func (e *Subnet) Find(c *fi.Context) (*Subnet, error) {
cloud := c.Cloud.(*gce.GCECloud)
s, err := cloud.Compute.Subnetworks.Get(cloud.Project, cloud.Region, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing Subnets: %v", err)
}
actual := &Subnet{}
actual.Name = &s.Name
actual.Network = &Network{Name: &s.Network}
actual.Region = &s.Region
actual.CIDR = &s.IpCidrRange
return actual, nil
}
func (e *PersistentDisk) Find(c *fi.Context) (*PersistentDisk, error) {
cloud := c.Cloud.(*gce.GCECloud)
r, err := cloud.Compute.Disks.Get(cloud.Project, *e.Zone, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing PersistentDisks: %v", err)
}
actual := &PersistentDisk{}
actual.Name = &r.Name
actual.VolumeType = fi.String(lastComponent(r.Type))
actual.Zone = fi.String(lastComponent(r.Zone))
actual.SizeGB = &r.SizeGb
return actual, nil
}
func (e *ManagedInstanceGroup) Find(c *fi.Context) (*ManagedInstanceGroup, error) {
cloud := c.Cloud.(*gce.GCECloud)
r, err := cloud.Compute.InstanceGroupManagers.Get(cloud.Project, *e.Zone, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing ManagedInstanceGroups: %v", err)
}
actual := &ManagedInstanceGroup{}
actual.Name = &r.Name
actual.Zone = fi.String(lastComponent(r.Zone))
actual.BaseInstanceName = &r.BaseInstanceName
actual.TargetSize = &r.TargetSize
actual.InstanceTemplate = &InstanceTemplate{Name: fi.String(lastComponent(r.InstanceTemplate))}
return actual, nil
}
func (e *Network) Find(c *fi.Context) (*Network, error) {
cloud := c.Cloud.(*gce.GCECloud)
r, err := cloud.Compute.Networks.Get(cloud.Project, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing Networks: %v", err)
}
actual := &Network{}
actual.Name = &r.Name
actual.CIDR = &r.IPv4Range
if r.SelfLink != e.URL(cloud.Project) {
glog.Warningf("SelfLink did not match URL: %q vs %q", r.SelfLink, e.URL(cloud.Project))
}
return actual, nil
}
func (e *FirewallRule) Find(c *fi.Context) (*FirewallRule, error) {
cloud := c.Cloud.(*gce.GCECloud)
r, err := cloud.Compute.Firewalls.Get(cloud.Project, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing FirewallRules: %v", err)
}
actual := &FirewallRule{}
actual.Name = &r.Name
actual.Network = &Network{Name: fi.String(lastComponent(r.Network))}
actual.TargetTags = r.TargetTags
actual.SourceRanges = r.SourceRanges
actual.SourceTags = r.SourceTags
for _, a := range r.Allowed {
actual.Allowed = append(actual.Allowed, serializeFirewallAllowed(a))
}
return actual, nil
}
func (e *InstanceTemplate) Find(c *fi.Context) (*InstanceTemplate, error) {
cloud := c.Cloud.(*gce.GCECloud)
r, err := cloud.Compute.InstanceTemplates.Get(cloud.Project, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing InstanceTemplates: %v", err)
}
actual := &InstanceTemplate{}
actual.Name = &r.Name
p := r.Properties
for _, tag := range p.Tags.Items {
actual.Tags = append(actual.Tags, tag)
}
actual.MachineType = fi.String(lastComponent(p.MachineType))
actual.CanIPForward = &p.CanIpForward
bootDiskImage, err := ShortenImageURL(cloud.Project, p.Disks[0].InitializeParams.SourceImage)
if err != nil {
return nil, fmt.Errorf("error parsing source image URL: %v", err)
}
actual.BootDiskImage = fi.String(bootDiskImage)
actual.BootDiskType = &p.Disks[0].InitializeParams.DiskType
actual.BootDiskSizeGB = &p.Disks[0].InitializeParams.DiskSizeGb
if p.Scheduling != nil {
actual.Preemptible = &p.Scheduling.Preemptible
}
if len(p.NetworkInterfaces) != 0 {
ni := p.NetworkInterfaces[0]
actual.Network = &Network{Name: fi.String(lastComponent(ni.Network))}
}
for _, serviceAccount := range p.ServiceAccounts {
for _, scope := range serviceAccount.Scopes {
actual.Scopes = append(actual.Scopes, scopeToShortForm(scope))
}
}
//for i, disk := range p.Disks {
// if i == 0 {
// source := disk.Source
//
// // TODO: Parse source URL instead of assuming same project/zone?
// name := lastComponent(source)
// d, err := cloud.Compute.Disks.Get(cloud.Project, *e.Zone, name).Do()
// if err != nil {
// if gce.IsNotFound(err) {
// return nil, fmt.Errorf("disk not found %q: %v", source, err)
// }
// return nil, fmt.Errorf("error querying for disk %q: %v", source, err)
// } else {
// imageURL, err := gce.ParseGoogleCloudURL(d.SourceImage)
// if err != nil {
// return nil, fmt.Errorf("unable to parse image URL: %q", d.SourceImage)
// }
// actual.Image = fi.String(imageURL.Project + "/" + imageURL.Name)
// }
// }
//}
if p.Metadata != nil {
actual.Metadata = make(map[string]fi.Resource)
for _, meta := range p.Metadata.Items {
actual.Metadata[meta.Key] = fi.NewStringResource(*meta.Value)
}
}
return actual, nil
}
func (e *Instance) Find(c *fi.Context) (*Instance, error) {
cloud := c.Cloud.(*gce.GCECloud)
r, err := cloud.Compute.Instances.Get(cloud.Project, *e.Zone, *e.Name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, nil
}
return nil, fmt.Errorf("error listing Instances: %v", err)
}
actual := &Instance{}
actual.Name = &r.Name
for _, tag := range r.Tags.Items {
actual.Tags = append(actual.Tags, tag)
}
actual.Zone = fi.String(lastComponent(r.Zone))
actual.MachineType = fi.String(lastComponent(r.MachineType))
actual.CanIPForward = &r.CanIpForward
if r.Scheduling != nil {
actual.Preemptible = &r.Scheduling.Preemptible
}
if len(r.NetworkInterfaces) != 0 {
ni := r.NetworkInterfaces[0]
actual.Network = &Network{Name: fi.String(lastComponent(ni.Network))}
if len(ni.AccessConfigs) != 0 {
ac := ni.AccessConfigs[0]
if ac.NatIP != "" {
addr, err := cloud.Compute.Addresses.List(cloud.Project, cloud.Region).Filter("address eq " + ac.NatIP).Do()
if err != nil {
return nil, fmt.Errorf("error querying for address %q: %v", ac.NatIP, err)
} else if len(addr.Items) != 0 {
actual.IPAddress = &IPAddress{Name: &addr.Items[0].Name}
} else {
return nil, fmt.Errorf("address not found %q: %v", ac.NatIP, err)
}
}
}
}
for _, serviceAccount := range r.ServiceAccounts {
for _, scope := range serviceAccount.Scopes {
actual.Scopes = append(actual.Scopes, scopeToShortForm(scope))
}
}
actual.Disks = make(map[string]*PersistentDisk)
for i, disk := range r.Disks {
if i == 0 {
source := disk.Source
// TODO: Parse source URL instead of assuming same project/zone?
name := lastComponent(source)
d, err := cloud.Compute.Disks.Get(cloud.Project, *e.Zone, name).Do()
if err != nil {
if gce.IsNotFound(err) {
return nil, fmt.Errorf("disk not found %q: %v", source, err)
}
return nil, fmt.Errorf("error querying for disk %q: %v", source, err)
}
image, err := ShortenImageURL(cloud.Project, d.SourceImage)
if err != nil {
return nil, fmt.Errorf("error parsing source image URL: %v", err)
}
actual.Image = fi.String(image)
} else {
url, err := gce.ParseGoogleCloudURL(disk.Source)
if err != nil {
return nil, fmt.Errorf("unable to parse disk source URL: %q", disk.Source)
}
actual.Disks[disk.DeviceName] = &PersistentDisk{Name: &url.Name}
}
}
if r.Metadata != nil {
actual.Metadata = make(map[string]fi.Resource)
for _, i := range r.Metadata.Items {
if i.Value == nil {
glog.Warningf("ignoring GCE instance metadata entry with nil-value: %q", i.Key)
continue
}
actual.Metadata[i.Key] = fi.NewStringResource(*i.Value)
}
actual.metadataFingerprint = r.Metadata.Fingerprint
}
return actual, nil
}