Delete gcp cloud routers.

- Issue #82

acceptance/gcp.go

@@ -20,6 +20,7 @@ type GCPAcceptance struct {
 	KeyPath   string
 	ProjectId string
 	Zone      string
+	Region    string
 	Logger    *app.Logger
 }
 
@@ -43,6 +44,7 @@ func NewGCPAcceptance() GCPAcceptance {
 		KeyPath:   path,
 		ProjectId: p.ProjectId,
 		Zone:      "us-east1-b",
+		Region:    "us-east1",
 		Logger:    app.NewLogger(os.Stdin, os.Stdout, true),
 	}
 }
@@ -55,11 +57,41 @@ func (g GCPAcceptance) InsertDisk(name string) {
 	Expect(err).NotTo(HaveOccurred())
 
 	list, err := service.Disks.List(g.ProjectId, g.Zone).Filter(fmt.Sprintf("name eq %s", name)).Do()
+	Expect(err).NotTo(HaveOccurred())
 	if len(list.Items) > 0 {
 		return
 	}
 
 	operation, err := service.Disks.Insert(g.ProjectId, g.Zone, &gcpcompute.Disk{Name: name}).Do()
+	Expect(err).NotTo(HaveOccurred())
+	waiter := compute.NewOperationWaiter(operation, service, g.ProjectId, g.Logger)
+
+	err = waiter.Wait()
+	Expect(err).NotTo(HaveOccurred())
+}
+
+func (g GCPAcceptance) InsertCloudRouter(name string) {
+	config, err := google.JWTConfigFromJSON([]byte(g.Key), gcpcompute.ComputeScope)
+	Expect(err).NotTo(HaveOccurred())
+
+	service, err := gcpcompute.New(config.Client(context.Background()))
+	Expect(err).NotTo(HaveOccurred())
+
+	list, err := service.Routers.List(g.ProjectId, g.Region).Filter(fmt.Sprintf("name eq %s", name)).Do()
+	Expect(err).NotTo(HaveOccurred())
+	if len(list.Items) > 0 {
+		return
+	}
+
+	network, err := service.Networks.Get(g.ProjectId, "default").Do()
+	Expect(err).NotTo(HaveOccurred())
+
+	router := &gcpcompute.Router{
+		Name:    name,
+		Network: network.SelfLink,
+	}
+	operation, err := service.Routers.Insert(g.ProjectId, g.Region, router).Do()
+	Expect(err).NotTo(HaveOccurred())
 
 	waiter := compute.NewOperationWaiter(operation, service, g.ProjectId, g.Logger)
 

acceptance/gcp_test.go

@@ -72,6 +72,7 @@ var _ = Describe("GCP", func() {
 		BeforeEach(func() {
 			filter = "leftovers-acceptance"
 			acc.InsertDisk(filter)
+			acc.InsertCloudRouter(filter)
 		})
 
 		It("deletes resources with the filter", func() {
@@ -80,6 +81,9 @@ var _ = Describe("GCP", func() {
 
 			Expect(stdout.String()).To(ContainSubstring("[Disk: leftovers-acceptance] Deleting..."))
 			Expect(stdout.String()).To(ContainSubstring("[Disk: leftovers-acceptance] Deleted!"))
+
+			Expect(stdout.String()).To(ContainSubstring("[Router: leftovers-acceptance] Deleting..."))
+			Expect(stdout.String()).To(ContainSubstring("[Router: leftovers-acceptance] Deleted!"))
 		})
 	})
 

gcp/compute/client.go

@@ -29,6 +29,7 @@ type client struct {
 	forwardingRules       *gcpcompute.ForwardingRulesService
 	globalForwardingRules *gcpcompute.GlobalForwardingRulesService
 	routes                *gcpcompute.RoutesService
+	routers               *gcpcompute.RoutersService
 	subnetworks           *gcpcompute.SubnetworksService
 	sslCertificates       *gcpcompute.SslCertificatesService
 	networks              *gcpcompute.NetworksService
@@ -63,6 +64,7 @@ func NewClient(project string, service *gcpcompute.Service, logger logger) clien
 		forwardingRules:       service.ForwardingRules,
 		globalForwardingRules: service.GlobalForwardingRules,
 		routes:                service.Routes,
+		routers:               service.Routers,
 		sslCertificates:       service.SslCertificates,
 		subnetworks:           service.Subnetworks,
 		networks:              service.Networks,
@@ -511,6 +513,33 @@ func (c client) DeleteRoute(route string) error {
 	return c.wait(c.routes.Delete(c.project, route))
 }
 
+func (c client) ListRouters(region string) ([]*gcpcompute.Router, error) {
+	var token string
+	list := []*gcpcompute.Router{}
+
+	for {
+		resp, err := c.routers.List(c.project, region).PageToken(token).Do()
+		if err != nil {
+			return nil, err
+		}
+
+		list = append(list, resp.Items...)
+
+		token = resp.NextPageToken
+		if token == "" {
+			break
+		}
+
+		time.Sleep(time.Second)
+	}
+
+	return list, nil
+}
+
+func (c client) DeleteRouter(region, router string) error {
+	return c.wait(c.routers.Delete(c.project, region, router))
+}
+
 func (c client) ListNetworks() ([]*gcpcompute.Network, error) {
 	var token string
 	list := []*gcpcompute.Network{}

gcp/compute/fakes/routers_client.go

@@ -0,0 +1,42 @@
+package fakes
+
+import gcpcompute "google.golang.org/api/compute/v1"
+
+type RoutersClient struct {
+	ListRoutersCall struct {
+		CallCount int
+		Receives  struct {
+			Region string
+		}
+		Returns struct {
+			Output []*gcpcompute.Router
+			Error  error
+		}
+	}
+
+	DeleteRouterCall struct {
+		CallCount int
+		Receives  struct {
+			Router string
+			Region string
+		}
+		Returns struct {
+			Error error
+		}
+	}
+}
+
+func (n *RoutersClient) ListRouters(region string) ([]*gcpcompute.Router, error) {
+	n.ListRoutersCall.CallCount++
+	n.ListRoutersCall.Receives.Region = region
+
+	return n.ListRoutersCall.Returns.Output, n.ListRoutersCall.Returns.Error
+}
+
+func (n *RoutersClient) DeleteRouter(region, router string) error {
+	n.DeleteRouterCall.CallCount++
+	n.DeleteRouterCall.Receives.Region = region
+	n.DeleteRouterCall.Receives.Router = router
+
+	return n.DeleteRouterCall.Returns.Error
+}

gcp/compute/router.go

@@ -0,0 +1,35 @@
+package compute
+
+import "fmt"
+
+type Router struct {
+	client routersClient
+	name   string
+	region string
+}
+
+func NewRouter(client routersClient, name, region string) Router {
+	return Router{
+		client: client,
+		name:   name,
+		region: region,
+	}
+}
+
+func (r Router) Delete() error {
+	err := r.client.DeleteRouter(r.region, r.name)
+
+	if err != nil {
+		return fmt.Errorf("Delete: %s", err)
+	}
+
+	return nil
+}
+
+func (r Router) Type() string {
+	return "Router"
+}
+
+func (r Router) Name() string {
+	return r.name
+}

gcp/compute/router_test.go

@@ -0,0 +1,63 @@
+package compute_test
+
+import (
+	"errors"
+
+	"github.com/genevieve/leftovers/gcp/compute"
+	"github.com/genevieve/leftovers/gcp/compute/fakes"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Router", func() {
+	var (
+		client *fakes.RoutersClient
+		name   string
+		region string
+
+		router compute.Router
+	)
+
+	BeforeEach(func() {
+		client = &fakes.RoutersClient{}
+		name = "banana"
+		region = "region-1"
+
+		router = compute.NewRouter(client, name, region)
+	})
+
+	Describe("Delete", func() {
+		It("deletes the router", func() {
+			err := router.Delete()
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(client.DeleteRouterCall.CallCount).To(Equal(1))
+			Expect(client.DeleteRouterCall.Receives.Region).To(Equal(region))
+			Expect(client.DeleteRouterCall.Receives.Router).To(Equal(name))
+		})
+
+		Context("when the client fails to delete", func() {
+			BeforeEach(func() {
+				client.DeleteRouterCall.Returns.Error = errors.New("the-error")
+			})
+
+			It("returns the error", func() {
+				err := router.Delete()
+				Expect(err).To(MatchError("Delete: the-error"))
+			})
+		})
+	})
+
+	Describe("Name", func() {
+		It("returns the name", func() {
+			Expect(router.Name()).To(Equal(name))
+		})
+	})
+
+	Describe("Type", func() {
+		It("returns the type", func() {
+			Expect(router.Type()).To(Equal("Router"))
+		})
+	})
+})

gcp/compute/routers.go

@@ -0,0 +1,62 @@
+package compute
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/genevieve/leftovers/common"
+	gcpcompute "google.golang.org/api/compute/v1"
+)
+
+type routersClient interface {
+	ListRouters(region string) ([]*gcpcompute.Router, error)
+	DeleteRouter(region, router string) error
+}
+
+type Routers struct {
+	routersClient routersClient
+	logger        logger
+	regions       map[string]string
+}
+
+func NewRouters(routersClient routersClient, logger logger, regions map[string]string) Routers {
+	return Routers{
+		routersClient: routersClient,
+		logger:        logger,
+		regions:       regions,
+	}
+}
+
+func (r Routers) List(filter string) ([]common.Deletable, error) {
+	routers := []*gcpcompute.Router{}
+	for _, region := range r.regions {
+		l, err := r.routersClient.ListRouters(region)
+		if err != nil {
+			return []common.Deletable{}, fmt.Errorf("List Routers for region %s: %s", region, err)
+		}
+
+		routers = append(routers, l...)
+	}
+
+	var resources []common.Deletable
+	for _, router := range routers {
+		resource := NewRouter(r.routersClient, router.Name, r.regions[router.Region])
+
+		if !strings.Contains(resource.Name(), filter) {
+			continue
+		}
+
+		proceed := r.logger.PromptWithDetails(resource.Type(), resource.Name())
+		if !proceed {
+			continue
+		}
+
+		resources = append(resources, resource)
+	}
+
+	return resources, nil
+}
+
+func (r Routers) Type() string {
+	return "cloud-router"
+}