Add krel stage/release entry methods

cmd/krel/cmd/anago/generate_release_version.go

@@ -42,7 +42,7 @@ life.
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		res, err := runGenerateReleaseVersion(generateReleaseVersionOpts, anagoOpts)
+		res, err := runGenerateReleaseVersion(generateReleaseVersionOpts)
 		if err != nil {
 			return err
 		}
@@ -52,6 +52,7 @@ life.
 }
 
 type generateReleaseVersionOptions struct {
+	releaseType  string
 	buildVersion string
 	branch       string
 	parentBranch string
@@ -60,6 +61,20 @@ type generateReleaseVersionOptions struct {
 var generateReleaseVersionOpts = &generateReleaseVersionOptions{}
 
 func init() {
+	generateReleaseVersionCmd.PersistentFlags().StringVar(
+		&generateReleaseVersionOpts.releaseType,
+		"release-type",
+		"",
+		fmt.Sprintf("release type, must be one of: '%s'",
+			strings.Join([]string{
+				release.ReleaseTypeAlpha,
+				release.ReleaseTypeBeta,
+				release.ReleaseTypeRC,
+				release.ReleaseTypeOfficial,
+			}, "', '"),
+		),
+	)
+
 	generateReleaseVersionCmd.PersistentFlags().StringVar(
 		&generateReleaseVersionOpts.buildVersion,
 		"build-version",
@@ -94,9 +109,9 @@ func init() {
 	AnagoCmd.AddCommand(generateReleaseVersionCmd)
 }
 
-func runGenerateReleaseVersion(opts *generateReleaseVersionOptions, anagoOpts *release.Options) (string, error) {
+func runGenerateReleaseVersion(opts *generateReleaseVersionOptions) (string, error) {
 	releaseVersion, err := release.GenerateReleaseVersion(
-		anagoOpts.ReleaseType,
+		opts.releaseType,
 		opts.buildVersion,
 		opts.branch,
 		opts.parentBranch == git.DefaultBranch,

cmd/krel/cmd/anago/generate_release_version_test.go

@@ -27,16 +27,13 @@ import (
 
 func TestRunGenerateReleaseVersion(t *testing.T) {
 	for _, tc := range []struct {
-		anagoOpts *release.Options
 		opts      *generateReleaseVersionOptions
 		shouldErr bool
 		expected  string
 	}{
 		{
-			anagoOpts: &release.Options{
-				ReleaseType: release.ReleaseTypeOfficial,
-			},
 			opts: &generateReleaseVersionOptions{
+				releaseType:  release.ReleaseTypeOfficial,
 				buildVersion: "v1.19.1-rc.0.34+5f5b46a6e8ad56",
 				branch:       "release-1.19",
 			},
@@ -51,10 +48,8 @@ export RELEASE_VERSION_PRIME=v1.19.1
 `,
 		},
 		{
-			anagoOpts: &release.Options{
-				ReleaseType: release.ReleaseTypeRC,
-			},
 			opts: &generateReleaseVersionOptions{
+				releaseType:  release.ReleaseTypeRC,
 				buildVersion: "v1.19.1-rc.0.34+5f5b46a6e8ad56",
 				branch:       "release-1.19",
 			},
@@ -67,20 +62,16 @@ export RELEASE_VERSION_PRIME=v1.19.1-rc.1
 `,
 		},
 		{
-			anagoOpts: &release.Options{
-				ReleaseType: release.ReleaseTypeAlpha,
-			},
 			opts: &generateReleaseVersionOptions{
+				releaseType:  release.ReleaseTypeAlpha,
 				buildVersion: "v1.19.1-rc.0.34+5f5b46a6e8ad56",
 				branch:       git.DefaultBranch,
 			},
 			shouldErr: true,
 		},
 		{
-			anagoOpts: &release.Options{
-				ReleaseType: release.ReleaseTypeAlpha,
-			},
 			opts: &generateReleaseVersionOptions{
+				releaseType:  release.ReleaseTypeAlpha,
 				buildVersion: "v1.20.0-alpha.0.1273+4e9bdd481e2400",
 				branch:       git.DefaultBranch,
 			},
@@ -93,10 +84,8 @@ export RELEASE_VERSION_PRIME=v1.20.0-alpha.1
 `,
 		},
 		{
-			anagoOpts: &release.Options{
-				ReleaseType: release.ReleaseTypeBeta,
-			},
 			opts: &generateReleaseVersionOptions{
+				releaseType:  release.ReleaseTypeBeta,
 				buildVersion: "v1.20.0-alpha.0.1273+4e9bdd481e2400",
 				branch:       git.DefaultBranch,
 			},
@@ -109,10 +98,8 @@ export RELEASE_VERSION_PRIME=v1.20.0-beta.0
 `,
 		},
 		{
-			anagoOpts: &release.Options{
-				ReleaseType: release.ReleaseTypeRC,
-			},
 			opts: &generateReleaseVersionOptions{
+				releaseType:  release.ReleaseTypeRC,
 				buildVersion: "v1.20.0-alpha.0.1273+4e9bdd481e2400",
 				branch:       "release-1.20",
 				parentBranch: git.DefaultBranch,
@@ -128,7 +115,7 @@ export RELEASE_VERSION_PRIME=v1.20.0-rc.0
 `,
 		},
 	} {
-		res, err := runGenerateReleaseVersion(tc.opts, tc.anagoOpts)
+		res, err := runGenerateReleaseVersion(tc.opts)
 		if tc.shouldErr {
 			require.NotNil(t, err)
 		} else {

cmd/krel/cmd/release.go

@@ -21,8 +21,8 @@ import (
 
 	"github.com/spf13/cobra"
 
+	"k8s.io/release/pkg/anago"
 	"k8s.io/release/pkg/github"
-	"k8s.io/release/pkg/release"
 )
 
 // releaseCmd represents the subcommand for `krel release`
@@ -44,8 +44,8 @@ successful 'krel stage'. The following steps are involved in the process:
    available) and build version for this release.
 
 3. Prepare Workspace: Verifies that the working directory is in the desired
-   state. This means that the build directory "%s" is cleaned up and the
-   checked out repository is in a clean state.
+   state. This means that the staged sources will be downloaded from the bucket
+   which should contain a copy of the repository.
 
 4. Push Artifacts: Pushes the generated artifacts to the release bucket and
    Google Container Registry.
@@ -58,23 +58,20 @@ successful 'krel stage'. The following steps are involved in the process:
 
 7. Archive: Copies the release process logs to a bucket and sets private
    permissions on it.
-
-`, github.TokenEnvKey, release.BuildDir),
+`, github.TokenEnvKey),
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return runRelease(releaseOpts, rootOpts)
+		return runRelease(releaseOptions, rootOpts)
 	},
 }
 
-type releaseOptions struct{}
-
-var releaseOpts = &releaseOptions{}
+var releaseOptions = anago.DefaultReleaseOptions()
 
 func init() {
 	rootCmd.AddCommand(releaseCmd)
 }
 
-func runRelease(opts *releaseOptions, rootOpts *rootOptions) error {
-	return nil
+func runRelease(options *anago.ReleaseOptions, _ *rootOptions) error {
+	return anago.NewRelease(options).Run()
 }

cmd/krel/cmd/stage.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/spf13/cobra"
 
+	"k8s.io/release/pkg/anago"
 	"k8s.io/release/pkg/github"
 	"k8s.io/release/pkg/release"
 )
@@ -54,23 +55,20 @@ following steps are involved in the process:
    into the local working repository.
 
 6. Stage: Copies the build artifacts to a Google Cloud Bucket.
-
 `, github.TokenEnvKey, release.BuildDir),
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return runStage(stageOpts, rootOpts)
+		return runStage(stageOptions, rootOpts)
 	},
 }
 
-type stageOptions struct{}
-
-var stageOpts = &stageOptions{}
+var stageOptions = anago.DefaultStageOptions()
 
 func init() {
 	rootCmd.AddCommand(stageCmd)
 }
 
-func runStage(opts *stageOptions, rootOpts *rootOptions) error {
-	return nil
+func runStage(stageOptions *anago.StageOptions, _ *rootOptions) error {
+	return anago.NewStage(stageOptions).Run()
 }

pkg/anago/anago.go

@@ -0,0 +1,162 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package anago
+
+import (
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate
+
+// StageOptions contains the options for running `Stage`.
+type StageOptions struct {
+}
+
+// DefaultStageOptions createa a new default `StageOptions`.
+func DefaultStageOptions() *StageOptions {
+	return &StageOptions{}
+}
+
+// Stage is the structure to be used for staging releases.
+type Stage struct {
+	client  stageClient
+	options *StageOptions
+}
+
+// NewStage creates a new `Stage` instance.
+func NewStage(options *StageOptions) *Stage {
+	return &Stage{
+		client:  NewDefaultStage(),
+		options: options,
+	}
+}
+
+// SetClient can be used to set the internal stage client.
+func (s *Stage) SetClient(client stageClient) {
+	s.client = client
+}
+
+// Run for the `Stage` struct prepares a release and puts the results on a
+// staging bucket.
+func (s *Stage) Run() error {
+	logrus.Info("Running stage")
+
+	logrus.Info("Checking prerequisites")
+	if err := s.client.CheckPrerequisites(); err != nil {
+		return errors.Wrap(err, "check prerequisites")
+	}
+
+	logrus.Info("Setting build candidate")
+	if err := s.client.SetBuildCandidate(); err != nil {
+		return errors.Wrap(err, "set build candidate")
+	}
+
+	logrus.Info("Preparing workspace")
+	if err := s.client.PrepareWorkspace(); err != nil {
+		return errors.Wrap(err, "prepare workspace")
+	}
+
+	logrus.Info("Building release")
+	if err := s.client.Build(); err != nil {
+		return errors.Wrap(err, "build release")
+	}
+
+	logrus.Info("Generating release notes")
+	if err := s.client.GenerateReleaseNotes(); err != nil {
+		return errors.Wrap(err, "generate release notes")
+	}
+
+	logrus.Info("Staging artifacts")
+	if err := s.client.StageArtifacts(); err != nil {
+		return errors.Wrap(err, "stage release artifacts")
+	}
+
+	logrus.Info("Stage done")
+	return nil
+}
+
+// ReleaseOptions contains the options for running `Release`.
+type ReleaseOptions struct {
+}
+
+// DefaultReleaseOptions createa a new default `ReleaseOptions`.
+func DefaultReleaseOptions() *ReleaseOptions {
+	return &ReleaseOptions{}
+}
+
+// Release is the structure to be used for releasing staged releases.
+type Release struct {
+	client  releaseClient
+	options *ReleaseOptions
+}
+
+// NewRelease creates a new `Release` instance.
+func NewRelease(options *ReleaseOptions) *Release {
+	return &Release{
+		client:  NewDefaultRelease(),
+		options: options,
+	}
+}
+
+// SetClient can be used to set the internal stage client.
+func (r *Release) SetClient(client releaseClient) {
+	r.client = client
+}
+
+// Run for for `Release` struct finishes a previously staged release.
+func (r *Release) Run() error {
+	logrus.Info("Running release")
+
+	logrus.Info("Checking prerequisites")
+	if err := r.client.CheckPrerequisites(); err != nil {
+		return errors.Wrap(err, "check prerequisites")
+	}
+
+	logrus.Info("Setting build candidate")
+	if err := r.client.SetBuildCandidate(); err != nil {
+		return errors.Wrap(err, "set build candidate")
+	}
+
+	logrus.Info("Preparing workspace")
+	if err := r.client.PrepareWorkspace(); err != nil {
+		return errors.Wrap(err, "prepare workspace")
+	}
+
+	logrus.Info("Pushing artifacts")
+	if err := r.client.PushArtifacts(); err != nil {
+		return errors.Wrap(err, "push artifacts")
+	}
+
+	logrus.Info("Pushing git Objects")
+	if err := r.client.PushGitObjects(); err != nil {
+		return errors.Wrap(err, "push git objects")
+	}
+
+	logrus.Info("Creating announcement")
+	if err := r.client.CreateAnnouncement(); err != nil {
+		return errors.Wrap(err, "create announcement")
+	}
+
+	logrus.Info("Archiving release")
+	if err := r.client.Archive(); err != nil {
+		return errors.Wrap(err, "archive release")
+	}
+
+	logrus.Info("Release done")
+	return nil
+}