forked from tcnksm/ghr
/
ghr.go
161 lines (131 loc) · 3.87 KB
/
ghr.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
package main
import (
"context"
"fmt"
"io"
"path/filepath"
"time"
"github.com/google/go-github/github"
"github.com/pkg/errors"
"golang.org/x/sync/errgroup"
)
type GHR struct {
GitHub GitHub
outStream io.Writer
}
func (g *GHR) CreateRelease(ctx context.Context, req *github.RepositoryRelease, recreate bool) (*github.RepositoryRelease, error) {
// When draft release creation is requested,
// create it witout any check (it can).
if *req.Draft {
fmt.Fprintln(g.outStream, "==> Create a draft release")
return g.GitHub.CreateRelease(ctx, req)
}
// Check release is exist or not.
// If release is not found, then create a new release.
release, err := g.GitHub.GetRelease(ctx, *req.TagName)
if err != nil {
if err != RelaseNotFound {
return nil, errors.Wrap(err, "failed to get release")
}
Debugf("Release (with tag %s) is not found: create a new one",
*req.TagName)
if recreate {
fmt.Fprintf(g.outStream,
"WARNING: '-recreate' is specified but release (%s) is not found",
*req.TagName)
}
fmt.Fprintln(g.outStream, "==> Create a new release")
return g.GitHub.CreateRelease(ctx, req)
}
// recreae is not true. Then use that exiting release.
if !recreate {
Debugf("Release (with tag %s) exists: use exsiting one",
*req.TagName)
fmt.Fprintf(g.outStream, "WARNING: found release (%s). Use existing one.",
*req.TagName)
return release, nil
}
// When recreate is requested, delete exsiting release
// and create a new release.
fmt.Fprintln(g.outStream, "==> Recreate a release")
if err := g.DeleteRelease(ctx, *release.ID, *req.TagName); err != nil {
return nil, err
}
return g.GitHub.CreateRelease(ctx, req)
}
func (g *GHR) DeleteRelease(ctx context.Context, ID int, tag string) error {
err := g.GitHub.DeleteRelease(ctx, ID)
if err != nil {
return err
}
err = g.GitHub.DeleteTag(ctx, tag)
if err != nil {
return err
}
return nil
}
func (g *GHR) UploadAssets(ctx context.Context, releaseID int, localAssets []string, parallel int) error {
start := time.Now()
defer func() {
Debugf("UploadAssets: time: %d ms", int(time.Since(start).Seconds()*1000))
}()
eg, ctx := errgroup.WithContext(ctx)
semaphore := make(chan struct{}, parallel)
for _, localAsset := range localAssets {
localAsset := localAsset
eg.Go(func() error {
semaphore <- struct{}{}
defer func() {
<-semaphore
}()
fmt.Fprintf(g.outStream, "--> Uploading: %15s\n", filepath.Base(localAsset))
_, err := g.GitHub.UploadAsset(ctx, releaseID, localAsset)
if err != nil {
return errors.Wrapf(err,
"failed to upload asset: %s", localAsset)
}
return nil
})
}
if err := eg.Wait(); err != nil {
return errors.Wrap(err, "one of goroutines is failed")
}
return nil
}
func (g *GHR) DeleteAssets(ctx context.Context, releaseID int, localAssets []string, parallel int) error {
start := time.Now()
defer func() {
Debugf("DeleteAssets: time: %d ms", int(time.Since(start).Seconds()*1000))
}()
eg, ctx := errgroup.WithContext(ctx)
assets, err := g.GitHub.ListAssets(ctx, releaseID)
if err != nil {
return errors.Wrap(err, "failed to list assets")
}
semaphore := make(chan struct{}, parallel)
for _, localAsset := range localAssets {
for _, asset := range assets {
// https://golang.org/doc/faq#closures_and_goroutines
localAsset, asset := localAsset, asset
// Uploaded asset name is same as basename of local file
if *asset.Name == filepath.Base(localAsset) {
eg.Go(func() error {
semaphore <- struct{}{}
defer func() {
<-semaphore
}()
fmt.Fprintf(g.outStream, "--> Deleting: %15s\n", *asset.Name)
if err := g.GitHub.DeleteAsset(ctx, *asset.ID); err != nil {
return errors.Wrapf(err,
"failed to delete asset: %s", *asset.Name)
}
return nil
})
}
}
}
if err := eg.Wait(); err != nil {
return errors.Wrap(err, "one of goroutines is failed")
}
return nil
}