forked from GoogleCloudPlatform/golang-samples
/
cleanaeversions.go
171 lines (151 loc) · 4.19 KB
/
cleanaeversions.go
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
// Copyright 2017 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Command cleaneversions deletes App Engine versions for a given project, service and/or version ID filter.
//
// Usage of cleanaeversions:
// -async
// Don't wait for successful deletion.
// -filter regexp
// Filter regexp for version IDs. If empty, attemps to clean all versions.
// -n Dry run.
// -project Project ID
// Project ID to clean.
// -service Service/module ID
// Service/module ID to clean. If omitted, cleans all services.
package main
import (
"flag"
"fmt"
"log"
"math/rand"
"os"
"regexp"
"strings"
"sync"
"sync/atomic"
"time"
"golang.org/x/net/context"
"golang.org/x/oauth2/google"
appengine "google.golang.org/api/appengine/v1"
)
var (
proj = flag.String("project", "", "`Project ID` to clean.")
service = flag.String("service", "", "`Service/module ID` to clean. If omitted, cleans all services.")
filter = flag.String("filter", "", "Filter `regexp` for version IDs. If empty, attemps to clean all versions.")
async = flag.Bool("async", false, "Don't wait for successful deletion.")
dryRun = flag.Bool("n", false, "Dry run.")
)
var gae *appengine.APIService
type pendingDelete struct {
service string
version string
op *appengine.Operation
}
func main() {
flag.Parse()
if *proj == "" {
fmt.Fprintln(os.Stderr, "-project flag is required")
flag.Usage()
os.Exit(2)
}
filterRE, err := regexp.Compile(*filter)
if err != nil {
fmt.Fprintf(os.Stderr, "Filter is not a valid regexp: %v\n", err)
os.Exit(2)
}
_ = filterRE
ctx := context.Background()
hc, err := google.DefaultClient(ctx, appengine.CloudPlatformScope)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not create DefaultClient: %v\n", err)
os.Exit(1)
}
gae, err = appengine.New(hc)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not create App Engine service: %v\n", err)
os.Exit(1)
}
var services []string
if *service != "" {
services = append(services, *service)
} else {
if err := gae.Apps.Services.List(*proj).Pages(ctx, func(lsr *appengine.ListServicesResponse) error {
for _, s := range lsr.Services {
services = append(services, s.Id)
}
return nil
}); err != nil {
fmt.Fprintf(os.Stderr, "Could not list App Engine services: %v\n", err)
os.Exit(1)
}
}
var pending []pendingDelete
for _, service := range services {
if err := gae.Apps.Services.Versions.List(*proj, service).Pages(ctx, func(lvr *appengine.ListVersionsResponse) error {
for _, v := range lvr.Versions {
if !filterRE.MatchString(v.Id) {
continue
}
log.Printf("Deleting %s/%s", service, v.Id)
if *dryRun {
continue
}
op, err := gae.Apps.Services.Versions.Delete(*proj, service, v.Id).Do()
if err != nil {
log.Printf("Could not delete version %s/%s: %v\n", service, v.Id, err)
} else {
pending = append(pending, pendingDelete{service: service, version: v.Id, op: op})
}
}
return nil
}); err != nil {
fmt.Fprintf(os.Stderr, "Could not list versions for %q: %v\n", service, err)
os.Exit(1)
}
}
if *async {
log.Printf("Not waiting for operations to complete. Exiting.")
os.Exit(0)
}
log.Printf("Waiting for operations to complete.")
var failed int64
var wg sync.WaitGroup
wg.Add(len(pending))
for _, pd := range pending {
pd := pd
go func() {
if err := waitForCompletion(pd); err != nil {
log.Printf("FAILED %v/%v/%v: %v", *proj, pd.service, pd.version, err)
atomic.AddInt64(&failed, 1)
} else {
log.Printf("Deleted %v/%v/%v", *proj, pd.service, pd.version)
}
wg.Done()
}()
}
wg.Wait()
if failed != 0 {
log.Printf("FAILED (%d)", failed)
os.Exit(1)
}
}
func waitForCompletion(pd pendingDelete) error {
parts := strings.Split(pd.op.Name, "/")
id := parts[len(parts)-1]
for {
op, err := gae.Apps.Operations.Get(*proj, id).Do()
if err != nil {
return err
}
if !op.Done {
// 5 to 10 second sleep.
time.Sleep(time.Duration(5+rand.Float64()*5) * time.Second)
continue
}
if op.Error == nil {
return nil
}
return fmt.Errorf("%s (code %d)", op.Error.Message, op.Error.Code)
}
}