github-release/github-release.go at master · comdotlinux/github-release · GitHub

History

402 lines (339 loc) · 14.2 KB

Raw

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

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

package main

import (

"bytes"

"encoding/json"

"flag"

"fmt"

log "github.com/sirupsen/logrus"

"io/ioutil"

"net/http"

"os"

"strings"

"time"

)

type release struct {

TagName string `json:"tag_name"`

TargetBranch string `json:"target_commitish"`

ReleaseName string `json:"name"`

Body string `json:"body"`

PreRelease bool `json:"prerelease"`

}

type userInputs struct {

tag string

releaseName string

previousTag string

preRelease bool

projects []string

user string

source string

fallbackBranch string

timeout int

supportBranchName string

}

/* {

"ref": "refs/tags/4.29.1",

"node_id": "",

"url": "https://api.github.com/repos/comdotlinux/java-design-patterns/git/refs/tags/4.29.1",

"object": {

"sha": "1b323c26943a32bc83832cc78d7ceb36e4f504e8",

"type": "commit",

"url": "https://api.github.com/repos/comdotlinux/java-design-patterns/git/commits/1b323c26943a32bc83832cc78d7ceb36e4f504e8"

}

} */

type referenceResponse struct {

Ref string `json:"ref"`

NodeID string `json:"node_id"`

URL string `json:"url"`

Object objectInReference `json:"object"`

}

type objectInReference struct {

Sha string `json:"sha"`

TypeInfo string `json:"type"`

URL string `json:"url"`

}

https://api.github.com/repos/<AUTHOR>/<REPO>/git/refs

{

"ref": "refs/heads/<NEW-BRANCH-NAME>",

"sha": "<HASH-TO-BRANCH-FROM>"

}

type createBranchBody struct {

Ref string `json:"ref"`

Sha string `json:"sha"`

}

const environmentTokenKey = "OAUTH_TOKEN"

const dockerNamesURL = "https://frightanic.com/goodies_content/docker-names.php"

const apiBaseURL = "https://api.github.com/repos"

const githubURL = "https://github.com/%s/%s/compare/%s...%s"

func main() {

if token, present := os.LookupEnv(environmentTokenKey); !present || token == "" {

log.Fatalf("Please set a environment variable named %s created on github.", environmentTokenKey)

}

var userInput userInputs

flag.StringVar(&userInput.user, "user", "idnowgmbh", "The User / Owner of the repository")

flag.StringVar(&userInput.source, "source", "master", "The source branch/tag to create the new tag")

flag.StringVar(&userInput.fallbackBranch, "fallback-branch", "master", "The fallback branch to create the TAG on if the source branch does not exist in the repository.")

flag.IntVar(&userInput.timeout, "timeout", 5, "The Timeout for Github API Calls")

flag.StringVar(&userInput.supportBranchName, "support-branch-name", "", "The name of the support branch to create if source branch is a tag")

flag.StringVar(&userInput.tag, "tag", "", "The tag to create.")

flag.StringVar(&userInput.releaseName, "release-name", "", "The name of the Release")

flag.StringVar(&userInput.previousTag, "previous-tag", "", "The previous tag to use in the message")

flag.BoolVar(&userInput.preRelease, "pre-release", true, "If this is a pre-release, use -pre-release=false to change")

flag.Usage = usage

flag.Parse()

userInput.projects = flag.Args()

inputValidaton(userInput)

userInput.releaseName = getReleaseName(userInput)

client := &http.Client{

Timeout: time.Duration(time.Second * time.Duration(userInput.timeout)),

}

var compareURLs []string

for index, project := range userInput.projects {

log.Infof("--")

log.Infof("%2d : Starting Release %s for %s with Tag Version %s on branch %s with fallback branch %s and possible support branch %s", index+1, userInput.releaseName, project, userInput.tag, userInput.source, userInput.fallbackBranch, userInput.supportBranchName)

projectAPIBaseURL := fmt.Sprintf("%s/%s/%s", apiBaseURL, userInput.user, project)

targetBranch, err := checkBranch(client, userInput, project, projectAPIBaseURL)

if err != nil {

log.Fatalf("Could not get the Target Branch %v", err)

}

log.Infof("Selected Branch %s to create tag %s", targetBranch, userInput.tag)

compareURL := createRelease(client, userInput, targetBranch, project, projectAPIBaseURL)

compareURLs = append(compareURLs, compareURL+"\n")

log.Infof("--\n")

}

printComparisonUrls(compareURLs)

}

func usage() {

executableName := os.Args[0]

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "\n%s is an opinionated implementation of some Github APIs that can be used to create release tags for multiple projects\n", executableName)

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "\nUsage: %s -user comdotlinux -source master -tag v0.0.2 -previous-tag v0.0.1 java-design-patterns TasteOfJavaEE7", executableName)

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "\nUsage: %s -user comdotlinux -source support/v0.0.x -tag v0.0.3 -fallback-branch master -previous-tag v0.0.1 -release-name Duke -pre-release=false java-design-patterns TasteOfJavaEE7", executableName)

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "\nUsage: %s -user comdotlinux -source v0.0.1 -tag v0.0.2-RC.1 -support-branch-name support/v0.0.x -previous-tag v0.0.1 java-design-patterns TasteOfJavaEE7", executableName)

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "\nWhen -source is a TAG -support-branch-name is mandatory. \n")

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "An environment variable with the name %s is mandatory for all actions!\nSee https://developer.github.com/v3/#oauth2-token-sent-in-a-header to get one.\n\n", environmentTokenKey)

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "Below are the possible parameters:\n")

flag.PrintDefaults()

os.Exit(3)

}

func checkBranch(client *http.Client, userInput userInputs, project string, projectAPIBaseURL string) (string, error) {

url := fmt.Sprintf("%s/branches/%s", projectAPIBaseURL, userInput.source)

res, err := doGet(client, url)

if err != nil {

log.Fatalf("Received error %v", err)

}

if statusSuccess(res.StatusCode) {

log.Infof("Branch %s looks good, will be selected. Response : %v", userInput.source, http.StatusText(res.StatusCode))

return userInput.source, nil

}

if res.StatusCode == http.StatusNotFound {

log.Infof("Checking if source %s is a TAG", userInput.source)

url = fmt.Sprintf("%s/releases/tags/%s", projectAPIBaseURL, userInput.source)

res, err := doGet(client, url)

if err != nil {

log.Fatalf("Could not Check release tags : %v", err)

}

if statusSuccess(res.StatusCode) {

log.Printf("%s is a Tag", userInput.source)

if userInput.supportBranchName == "" {

log.Fatalf("If Source is a tag, name of support branch to create from this is necessary!")

}

log.Infof("Since %s is a Tag, Creating support branch %s", userInput.source, userInput.supportBranchName)

url = fmt.Sprintf("%s/git/refs/tags/%s", projectAPIBaseURL, userInput.source)

res, err := doGet(client, url)

if err != nil {

log.Fatalf("Could not get Tag %s commit userInput. : %v", userInput.source, err)

}

if statusSuccess(res.StatusCode) {

log.Println("Reading response body to get commit hash")

defer res.Body.Close()

tagInfoResponseBody, errorReadingBody := ioutil.ReadAll(res.Body)

if errorReadingBody != nil {

log.Fatalf("Could not read Response body, cannot proceed : %v", errorReadingBody)

}

log.Println("Read Response body, trying to unmarshal the Json")

var tagReference referenceResponse

if err := json.Unmarshal(tagInfoResponseBody, &tagReference); err != nil {

log.Fatalf("Could not read response for tag info to get sha commit %v", err)

}

log.Printf("Response body read into referenceResponse, sha hash : %s", tagReference.Object.Sha)

createBranch := createBranchBody{

Ref: fmt.Sprintf("refs/heads/%s", userInput.supportBranchName),

Sha: tagReference.Object.Sha,

}

log.Printf("Created Request Object to create branch : %v", createBranch)

bodyBytes, err := json.Marshal(createBranch)

if err != nil {

log.Fatalf("Could not create body for creating branch. %v", err)

}

log.Println("structconverted to Json Bytes")

url = fmt.Sprintf("%s/git/refs", projectAPIBaseURL)

log.Printf("Calling URL %s to create Branch %s", url, createBranch.Ref)

req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(bodyBytes))

if err != nil {

log.Fatalf("Could not create Request for creating branch. %v", err)

}

addAuthAndAcceptHeader(req)

req.Header.Add(http.CanonicalHeaderKey("Content-Type"), "application/json")

res, err := client.Do(req)

if err != nil {

log.Fatalf("Error in creating the branch : %v", err)

}

log.Printf("POST call to create branch completed with status %s", http.StatusText(res.StatusCode))

if res.StatusCode == http.StatusCreated {

defer res.Body.Close()

createBranchResponseBody, errorReadingBody := ioutil.ReadAll(res.Body)

if errorReadingBody != nil {

log.Fatalf("Could not read Response body, cannot proceed : %v", errorReadingBody)

}

var branchReference referenceResponse

if err := json.Unmarshal(createBranchResponseBody, &branchReference); err != nil {

log.Fatalf("Could not read response for tag info to get sha commit %v", err)

}

log.Infof("Created Branch with Details : %v", branchReference)

branchNameArray := strings.SplitN(branchReference.Ref, "/", 3)

if len(branchNameArray) == 3 {

return branchNameArray[2], nil

}

return branchReference.Ref, nil

}

log.Warnf("POST call to create branch completed with response %v", res)

}

} else {

log.Infof("Use fallback branch since %s is neither a branch nor a Tag", userInput.source)

url := fmt.Sprintf("%s/branches/%s", projectAPIBaseURL, userInput.fallbackBranch)

res, err := doGet(client, url)

if err != nil {

log.Fatalf("Received error %v", err)

}

if statusSuccess(res.StatusCode) {

log.Infof("Branch %s looks good, will be selected. Response : %v", userInput.fallbackBranch, http.StatusText(res.StatusCode))

return userInput.fallbackBranch, nil

}

log.Warnf("The source branch parameter and the fallback cannot be used to create release for %s, so using master", project)

return "master", nil

}

func statusSuccess(statusCode int) bool {

log.Printf("checking status code %d", statusCode)

return statusCode >= http.StatusOK && statusCode <= 299

}

func doGet(client *http.Client, url string) (*http.Response, error) {

log.Infof("Calling URL %s", url)

req, err := http.NewRequest(http.MethodGet, url, nil)

if err != nil {

return nil, err

}

addAuthAndAcceptHeader(req)

res, err := client.Do(req)

if err != nil {

return nil, err

}

log.Debugf("Response for %s : %v", url, res)

return res, nil

}

func addAuthAndAcceptHeader(request *http.Request) {

request.Header.Add(http.CanonicalHeaderKey("Authorization"), fmt.Sprintf("token %s", os.Getenv(environmentTokenKey)))

request.Header.Add(http.CanonicalHeaderKey("Accept"), "application/vnd.github.v3+json")

}

func createRelease(client *http.Client, userInput userInputs, targetBranch string, project string, projectAPIBaseURL string) string {

previousComparePoint := targetBranch

if !isEmpty(userInput.previousTag) {

previousComparePoint = userInput.previousTag

}

releaseCompareBody := fmt.Sprintf(githubURL, userInput.user, project, previousComparePoint, userInput.tag)

releaseRequest := release{

TagName: userInput.tag,

ReleaseName: userInput.releaseName,

PreRelease: userInput.preRelease,

TargetBranch: targetBranch,

Body: releaseCompareBody,

}

log.Infoln("Release request Object.")

b, _ := json.MarshalIndent(releaseRequest, "", " ")

_, _ = os.Stdout.Write(b)

log.Infoln("--")

url := fmt.Sprintf("%s/releases", projectAPIBaseURL)

log.Printf("Calling URL %s to create Release %v", url, releaseRequest)

bodyBytes, err := json.Marshal(releaseRequest)

if err != nil {

log.Fatalf("Could not create body for creating release. %v", err)

}

req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(bodyBytes))

if err != nil {

log.Fatalf("Could not create Body Json Bytes, from release object. %v", err)

}

addAuthAndAcceptHeader(req)

req.Header.Add(http.CanonicalHeaderKey("Content-Type"), "application/json")

res, err := client.Do(req)

if err != nil {

log.Fatalf("Create release Failed, %v", err)

}

if !statusSuccess(res.StatusCode) {

log.Fatalf("Create release Failed with status, %d : %s", res.StatusCode, http.StatusText(res.StatusCode))

}

log.Printf("Release Tag Created")

return releaseCompareBody

}

func getReleaseName(userInput userInputs) string {

releaseName := userInput.releaseName

if isEmpty(userInput.releaseName) {

log.Printf("Since the release name is unavailable, getting a random release name using %s", dockerNamesURL)

releaseName = getRandomReleaseName()

if isEmpty(releaseName) {

releaseName = "Release of " + userInput.tag

log.Printf("Since getting release name was not possible, using %s as release name", releaseName)

}

return releaseName

}

func getRandomReleaseName() string {

client := http.Client{}

resp, err := client.Get(dockerNamesURL)

if err != nil {

log.Printf("Unable to get Docker Container Names for random release name. %v", err)

return ""

}

defer resp.Body.Close()

body, err := ioutil.ReadAll(resp.Body)

if err != nil {

log.Printf("Error reading body for the release name : %v", err)

return ""

}

return strings.TrimRight(fmt.Sprintf("%s", body), "\n")

}

func isEmpty(input string) bool {

return len(input) == 0 || input == ""

}

func inputValidaton(userInput userInputs) {

var errors []string

if isEmpty(userInput.user) {

errors = append(errors, "User / Organization parameter is mandatory")

}

if isEmpty(userInput.source) {

errors = append(errors, "source parameter is mandatory and must either be a branch OR a existing TAG on Github")

}

if isEmpty(userInput.tag) {

errors = append(errors, "tag parameter is mandatory, otherwise what are we releasing?")

}

if len(userInput.projects) == 0 {

errors = append(errors, "At least provide one project, otherwise where do we create the tag?")

}

if len(errors) != 0 {

_, _ = fmt.Fprintln(flag.CommandLine.Output(), "")

for index, err := range errors {

_, _ = fmt.Fprintf(flag.CommandLine.Output(), "%2d : %s\n", index+1, err)

}

_, _ = fmt.Fprintln(flag.CommandLine.Output(), "")

flag.Usage()

}

func printComparisonUrls(compareURLs []string) {

output := "Release Done, Following are the release compare URLs\n"

for i, u := range compareURLs {

output += fmt.Sprintf("%2d : %s\n", i+1, u)

}

output += "--"

fmt.Printf(output)

}

github-release/github-release.go at master · comdotlinux/github-release · GitHub

Expand file tree

Breadcrumbs

github-release.go

Latest commit

History

Breadcrumbs

github-release.go

File metadata and controls