Refactor package CLI command (#1345)

pkg/fission-cli/cmd/package/create.go

@@ -0,0 +1,148 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"fmt"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/dchest/uniuri"
+	uuid "github.com/satori/go.uuid"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	"github.com/fission/fission/pkg/fission-cli/cmd"
+	cmdutils "github.com/fission/fission/pkg/fission-cli/cmd"
+	"github.com/fission/fission/pkg/fission-cli/cmd/spec"
+	"github.com/fission/fission/pkg/fission-cli/log"
+	"github.com/fission/fission/pkg/fission-cli/util"
+)
+
+type CreateSubCommand struct {
+	client *client.Client
+}
+
+func Create(flags cli.Input) error {
+	opts := CreateSubCommand{
+		client: cmd.GetServer(flags),
+	}
+	return opts.do(flags)
+}
+
+func (opts *CreateSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	//return opts.run(flags)
+	return nil
+}
+
+// complete creates a environment objects and populates it with default value and CLI inputs.
+func (opts *CreateSubCommand) complete(flags cli.Input) error {
+	pkgNamespace := flags.String("pkgNamespace")
+	envName := flags.String("env")
+	if len(envName) == 0 {
+		log.Fatal("Need --env argument.")
+	}
+	envNamespace := flags.String("envNamespace")
+	srcArchiveFiles := flags.StringSlice("src")
+	deployArchiveFiles := flags.StringSlice("deploy")
+	buildcmd := flags.String("buildcmd")
+
+	if len(srcArchiveFiles) == 0 && len(deployArchiveFiles) == 0 {
+		log.Fatal("Need --src to specify source archive, or use --deploy to specify deployment archive.")
+	}
+
+	_, err := CreatePackage(flags, opts.client, pkgNamespace, envName, envNamespace, srcArchiveFiles, deployArchiveFiles, buildcmd, "", "", false)
+
+	return err
+}
+
+func CreatePackage(flags cli.Input, client *client.Client, pkgNamespace string, envName string, envNamespace string, srcArchiveFiles []string, deployArchiveFiles []string, buildcmd string, specDir string, specFile string, noZip bool) (*metav1.ObjectMeta, error) {
+	pkgSpec := fv1.PackageSpec{
+		Environment: fv1.EnvironmentReference{
+			Namespace: envNamespace,
+			Name:      envName,
+		},
+	}
+	var pkgStatus fv1.BuildStatus = fv1.BuildStatusSucceeded
+
+	var pkgName string
+	if len(deployArchiveFiles) > 0 {
+		if len(specFile) > 0 { // we should do this in all cases, i think
+			pkgStatus = fv1.BuildStatusNone
+		}
+		deployment, err := CreateArchive(client, deployArchiveFiles, noZip, specDir, specFile)
+		if err != nil {
+			return nil, err
+		}
+		pkgSpec.Deployment = *deployment
+		pkgName = util.KubifyName(fmt.Sprintf("%v-%v", path.Base(deployArchiveFiles[0]), uniuri.NewLen(4)))
+	}
+	if len(srcArchiveFiles) > 0 {
+		source, err := CreateArchive(client, srcArchiveFiles, false, specDir, specFile)
+		if err != nil {
+			return nil, err
+		}
+		pkgSpec.Source = *source
+		pkgStatus = fv1.BuildStatusPending // set package build status to pending
+		pkgName = util.KubifyName(fmt.Sprintf("%v-%v", path.Base(srcArchiveFiles[0]), uniuri.NewLen(4)))
+	}
+
+	if len(buildcmd) > 0 {
+		pkgSpec.BuildCommand = buildcmd
+	}
+
+	if len(pkgName) == 0 {
+		pkgName = strings.ToLower(uuid.NewV4().String())
+	}
+	pkg := &fv1.Package{
+		Metadata: metav1.ObjectMeta{
+			Name:      pkgName,
+			Namespace: pkgNamespace,
+		},
+		Spec: pkgSpec,
+		Status: fv1.PackageStatus{
+			BuildStatus:         pkgStatus,
+			LastUpdateTimestamp: time.Now().UTC(),
+		},
+	}
+
+	if len(specFile) > 0 {
+		// if a package sith the same spec exists, don't create a new spec file
+		fr, err := spec.ReadSpecs(cmdutils.GetSpecDir(flags))
+		util.CheckErr(err, "read specs")
+		if m := fr.SpecExists(pkg, false, true); m != nil {
+			fmt.Printf("Re-using previously created package %v\n", m.Name)
+			return m, nil
+		}
+
+		err = spec.SpecSave(*pkg, specFile)
+		util.CheckErr(err, "save package spec")
+		return &pkg.Metadata, nil
+	} else {
+		pkgMetadata, err := client.PackageCreate(pkg)
+		util.CheckErr(err, "create package")
+		fmt.Printf("Package '%v' created\n", pkgMetadata.GetName())
+		return pkgMetadata, nil
+	}
+}

pkg/fission-cli/cmd/package/delete.go

@@ -0,0 +1,130 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"fmt"
+
+	"github.com/pkg/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	cmdutils "github.com/fission/fission/pkg/fission-cli/cmd"
+)
+
+type DeleteSubCommand struct {
+	client        *client.Client
+	name          string
+	namespace     string
+	deleteOrphans bool
+	force         bool
+}
+
+func Delete(flags cli.Input) error {
+	opts := DeleteSubCommand{
+		client: cmdutils.GetServer(flags),
+	}
+	return opts.do(flags)
+}
+
+func (opts *DeleteSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	return opts.run(flags)
+}
+
+func (opts *DeleteSubCommand) complete(flags cli.Input) error {
+	opts.name = flags.String("name")
+	opts.namespace = flags.String("pkgNamespace")
+	opts.deleteOrphans = flags.Bool("orphan")
+	opts.force = flags.Bool("f")
+
+	if len(opts.name) == 0 && !opts.deleteOrphans {
+		return errors.New("need --name argument or --orphan flag")
+	}
+	if len(opts.name) != 0 && opts.deleteOrphans {
+		return errors.New("need either --name argument or --orphan flag")
+	}
+
+	return nil
+}
+
+func (opts *DeleteSubCommand) run(flags cli.Input) error {
+	if len(opts.name) != 0 {
+		_, err := opts.client.PackageGet(&metav1.ObjectMeta{
+			Namespace: opts.namespace,
+			Name:      opts.name,
+		})
+		if err != nil {
+			return errors.Wrap(err, "find package")
+		}
+
+		fnList, err := GetFunctionsByPackage(opts.client, opts.name, opts.namespace)
+		if err != nil {
+			return err
+		}
+
+		if !opts.force && len(fnList) > 0 {
+			return errors.New("Package is used by at least one function, use -f to force delete")
+		}
+		err = deletePackage(opts.client, opts.name, opts.namespace)
+		if err != nil {
+			return err
+		}
+		fmt.Printf("Package '%v' deleted\n", opts.name)
+	} else {
+		err := deleteOrphanPkgs(opts.client, opts.namespace)
+		if err != nil {
+			return errors.Wrap(err, "deleting orphan packages")
+		}
+		fmt.Println("Orphan packages deleted")
+	}
+
+	return nil
+}
+
+func deleteOrphanPkgs(client *client.Client, pkgNamespace string) error {
+	pkgList, err := client.PackageList(pkgNamespace)
+	if err != nil {
+		return err
+	}
+
+	// range through all packages and find out the ones not referenced by any function
+	for _, pkg := range pkgList {
+		fnList, err := GetFunctionsByPackage(client, pkg.Metadata.Name, pkgNamespace)
+		if err != nil {
+			return errors.Wrap(err, fmt.Sprintf("get functions sharing package %s", pkg.Metadata.Name))
+		}
+		if len(fnList) == 0 {
+			err = deletePackage(client, pkg.Metadata.Name, pkgNamespace)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func deletePackage(client *client.Client, pkgName string, pkgNamespace string) error {
+	return client.PackageDelete(&metav1.ObjectMeta{
+		Namespace: pkgNamespace,
+		Name:      pkgName,
+	})
+}

pkg/fission-cli/cmd/package/get.go

@@ -0,0 +1,110 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	cmdutils "github.com/fission/fission/pkg/fission-cli/cmd"
+	pkgutil "github.com/fission/fission/pkg/fission-cli/cmd/package/util"
+)
+
+const (
+	deployArchive = iota
+	sourceArchive
+)
+
+type GetSubCommand struct {
+	client      *client.Client
+	name        string
+	namespace   string
+	output      string
+	archiveType int
+}
+
+func GetSrc(flags cli.Input) error {
+	opts := GetSubCommand{
+		client:      cmdutils.GetServer(flags),
+		archiveType: sourceArchive,
+	}
+	return opts.do(flags)
+}
+
+func GetDeploy(flags cli.Input) error {
+	opts := GetSubCommand{
+		client:      cmdutils.GetServer(flags),
+		archiveType: deployArchive,
+	}
+	return opts.do(flags)
+}
+
+func (opts *GetSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	return opts.run(flags)
+}
+
+func (opts *GetSubCommand) complete(flags cli.Input) error {
+	opts.name = flags.String("name")
+	if len(opts.name) == 0 {
+		return errors.New("need name of package, use --name")
+	}
+	opts.namespace = flags.String("pkgNamespace")
+	opts.output = flags.String("output")
+	return nil
+}
+
+func (opts *GetSubCommand) run(flags cli.Input) error {
+	pkg, err := opts.client.PackageGet(&metav1.ObjectMeta{
+		Namespace: opts.namespace,
+		Name:      opts.name,
+	})
+	if err != nil {
+		return err
+	}
+
+	var reader io.Reader
+	archive := pkg.Spec.Source
+	if opts.archiveType == deployArchive {
+		archive = pkg.Spec.Deployment
+	}
+
+	if pkg.Spec.Deployment.Type == fv1.ArchiveTypeLiteral {
+		reader = bytes.NewReader(archive.Literal)
+	} else if pkg.Spec.Deployment.Type == fv1.ArchiveTypeUrl {
+		readCloser := pkgutil.DownloadStoragesvcURL(opts.client, archive.URL)
+		defer readCloser.Close()
+		reader = readCloser
+	}
+
+	if len(opts.output) > 0 {
+		return pkgutil.WriteArchiveToFile(opts.output, reader)
+	} else {
+		_, err := io.Copy(os.Stdout, reader)
+		return err
+	}
+}

pkg/fission-cli/cmd/package/info.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	cmdutils "github.com/fission/fission/pkg/fission-cli/cmd"
+	"github.com/fission/fission/pkg/fission-cli/log"
+	"github.com/fission/fission/pkg/fission-cli/util"
+)
+
+type InfoSubCommand struct {
+	client    *client.Client
+	name      string
+	namespace string
+}
+
+func Info(flags cli.Input) error {
+	opts := InfoSubCommand{
+		client: cmdutils.GetServer(flags),
+	}
+	return opts.do(flags)
+}
+
+func (opts *InfoSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	return opts.run(flags)
+}
+
+func (opts *InfoSubCommand) complete(flags cli.Input) error {
+	opts.name = flags.String("name")
+	if len(opts.name) == 0 {
+		log.Fatal("Need name of package, use --name")
+	}
+	opts.namespace = flags.String("pkgNamespace")
+	return nil
+}
+
+func (opts *InfoSubCommand) run(flags cli.Input) error {
+	pkg, err := opts.client.PackageGet(&metav1.ObjectMeta{
+		Namespace: opts.namespace,
+		Name:      opts.name,
+	})
+	if err != nil {
+		util.CheckErr(err, fmt.Sprintf("find package %s", opts.name))
+	}
+
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
+	fmt.Fprintf(w, "%v\t%v\n", "Name:", pkg.Metadata.Name)
+	fmt.Fprintf(w, "%v\t%v\n", "Environment:", pkg.Spec.Environment.Name)
+	fmt.Fprintf(w, "%v\t%v\n", "Status:", pkg.Status.BuildStatus)
+	fmt.Fprintf(w, "%v\n%v", "Build Logs:", pkg.Status.BuildLog)
+	w.Flush()
+
+	return nil
+}

pkg/fission-cli/cmd/package/list.go

@@ -0,0 +1,98 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"text/tabwriter"
+
+	"github.com/pkg/errors"
+
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	cmdutils "github.com/fission/fission/pkg/fission-cli/cmd"
+)
+
+type ListSubCommand struct {
+	client       *client.Client
+	listOrphans  bool
+	status       string
+	pkgNamespace string
+}
+
+func List(flags cli.Input) error {
+	opts := ListSubCommand{
+		client: cmdutils.GetServer(flags),
+	}
+	return opts.do(flags)
+}
+
+func (opts *ListSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	return opts.run(flags)
+}
+
+func (opts *ListSubCommand) complete(flags cli.Input) error {
+	// option for the user to list all orphan packages (not referenced by any function)
+	opts.listOrphans = flags.Bool("orphan")
+	opts.status = flags.String("status")
+	opts.pkgNamespace = flags.String("pkgNamespace")
+	return nil
+}
+
+func (opts *ListSubCommand) run(flags cli.Input) error {
+	pkgList, err := opts.client.PackageList(opts.pkgNamespace)
+	if err != nil {
+		return err
+	}
+
+	// sort the package list by lastUpdatedTimestamp
+	sort.Slice(pkgList, func(i, j int) bool {
+		return pkgList[i].Status.LastUpdateTimestamp.After(pkgList[j].Status.LastUpdateTimestamp)
+	})
+
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
+	fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", "NAME", "BUILD_STATUS", "ENV", "LASTUPDATEDAT")
+
+	for _, pkg := range pkgList {
+		show := true
+		if opts.listOrphans {
+			fnList, err := GetFunctionsByPackage(opts.client, pkg.Metadata.Name, pkg.Metadata.Namespace)
+			if err != nil {
+				return errors.Wrap(err, fmt.Sprintf("get functions sharing package %s", pkg.Metadata.Name))
+			}
+			if len(fnList) > 0 {
+				show = false
+			}
+		}
+		if len(opts.status) > 0 && opts.status != string(pkg.Status.BuildStatus) {
+			show = false
+		}
+		if show {
+			fmt.Fprintf(w, "%v\t%v\t%v\n", pkg.Metadata.Name, pkg.Status.BuildStatus, pkg.Spec.Environment.Name)
+		}
+	}
+
+	w.Flush()
+
+	return nil
+}

pkg/fission-cli/cmd/package/package.go

@@ -0,0 +1,176 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/dchest/uniuri"
+	"github.com/hashicorp/go-multierror"
+	"github.com/mholt/archiver"
+	"github.com/pkg/errors"
+
+	fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
+	"github.com/fission/fission/pkg/controller/client"
+	pkgutil "github.com/fission/fission/pkg/fission-cli/cmd/package/util"
+	"github.com/fission/fission/pkg/fission-cli/cmd/spec"
+	spectypes "github.com/fission/fission/pkg/fission-cli/cmd/spec/types"
+	"github.com/fission/fission/pkg/fission-cli/util"
+	"github.com/fission/fission/pkg/utils"
+)
+
+// CreateArchive returns a fv1.Archive made from an archive .  If specFile, then
+// create an archive upload spec in the specs directory; otherwise
+// upload the archive using client.  noZip avoids zipping the
+// includeFiles, but is ignored if there's more than one includeFile.
+func CreateArchive(client *client.Client, includeFiles []string, noZip bool, specDir string, specFile string) (*fv1.Archive, error) {
+
+	errs := &multierror.Error{}
+
+	// check files existence
+	for _, path := range includeFiles {
+		// ignore http files
+		if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {
+			continue
+		}
+
+		// Get files from inputs as number of files decide next steps
+		files, err := utils.FindAllGlobs([]string{path})
+		if err != nil {
+			util.CheckErr(err, "finding all globs")
+		}
+
+		if len(files) == 0 {
+			errs = multierror.Append(errs, errors.New(fmt.Sprintf("Error finding any files with path \"%v\"", path)))
+		}
+	}
+
+	if errs.ErrorOrNil() != nil {
+		return nil, errs.ErrorOrNil()
+	}
+
+	if len(specFile) > 0 {
+		// create an ArchiveUploadSpec and reference it from the archive
+		aus := &spectypes.ArchiveUploadSpec{
+			Name:         archiveName("", includeFiles),
+			IncludeGlobs: includeFiles,
+		}
+
+		// check if this AUS exists in the specs; if so, don't create a new one
+		fr, err := spec.ReadSpecs(specDir)
+		util.CheckErr(err, "read specs")
+		if m := fr.SpecExists(aus, false, true); m != nil {
+			fmt.Printf("Re-using previously created archive %v\n", m.Name)
+			aus.Name = m.Name
+		} else {
+			// save the uploadspec
+			err := spec.SpecSave(*aus, specFile)
+			util.CheckErr(err, fmt.Sprintf("write spec file %v", specFile))
+		}
+
+		// create the archive object
+		ar := &fv1.Archive{
+			Type: fv1.ArchiveTypeUrl,
+			URL:  fmt.Sprintf("%v%v", spec.ARCHIVE_URL_PREFIX, aus.Name),
+		}
+		return ar, nil
+	}
+
+	archivePath := makeArchiveFileIfNeeded("", includeFiles, noZip)
+
+	ctx := context.Background()
+	return pkgutil.UploadArchive(ctx, client, archivePath)
+}
+
+// Create an archive from the given list of input files, unless that
+// list has only one item and that item is either a zip file or a URL.
+//
+// If the inputs have only one file and noZip is true, the file is
+// returned as-is with no zipping.  (This is used for compatibility
+// with v1 envs.)  noZip is IGNORED if there is more than one input
+// file.
+func makeArchiveFileIfNeeded(archiveNameHint string, archiveInput []string, noZip bool) string {
+
+	// Unique name for the archive
+	archiveName := archiveName(archiveNameHint, archiveInput)
+
+	// Get files from inputs as number of files decide next steps
+	files, err := utils.FindAllGlobs(archiveInput)
+	if err != nil {
+		util.CheckErr(err, "finding all globs")
+	}
+
+	// We have one file; if it's a zip file or a URL, no need to archive it
+	if len(files) == 1 {
+		// make sure it exists
+		if _, err := os.Stat(files[0]); err != nil {
+			util.CheckErr(err, fmt.Sprintf("open input file %v", files[0]))
+		}
+
+		// if it's an existing zip file OR we're not supposed to zip it, don't do anything
+		if archiver.Zip.Match(files[0]) || noZip {
+			return files[0]
+		}
+
+		// if it's an HTTP URL, just use the URL.
+		if strings.HasPrefix(files[0], "http://") || strings.HasPrefix(files[0], "https://") {
+			return files[0]
+		}
+	}
+
+	// For anything else, create a new archive
+	tmpDir, err := utils.GetTempDir()
+	if err != nil {
+		util.CheckErr(err, "create temporary archive directory")
+	}
+
+	archivePath, err := utils.MakeArchive(filepath.Join(tmpDir, archiveName), archiveInput...)
+	if err != nil {
+		util.CheckErr(err, "create archive file")
+	}
+
+	return archivePath
+}
+
+// Name an archive
+func archiveName(givenNameHint string, includedFiles []string) string {
+	if len(givenNameHint) > 0 {
+		return fmt.Sprintf("%v-%v", givenNameHint, uniuri.NewLen(4))
+	}
+	if len(includedFiles) == 0 {
+		return uniuri.NewLen(8)
+	}
+	return fmt.Sprintf("%v-%v", util.KubifyName(includedFiles[0]), uniuri.NewLen(4))
+}
+
+func GetFunctionsByPackage(client *client.Client, pkgName, pkgNamespace string) ([]fv1.Function, error) {
+	fnList, err := client.FunctionList(pkgNamespace)
+	if err != nil {
+		return nil, err
+	}
+	fns := []fv1.Function{}
+	for _, fn := range fnList {
+		if fn.Spec.Package.PackageRef.Name == pkgName {
+			fns = append(fns, fn)
+		}
+	}
+	return fns, nil
+}

pkg/fission-cli/cmd/package/rebuild.go

@@ -0,0 +1,83 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"fmt"
+
+	"github.com/pkg/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	cmdutils "github.com/fission/fission/pkg/fission-cli/cmd"
+)
+
+type RebuildSubCommand struct {
+	client    *client.Client
+	name      string
+	namespace string
+}
+
+func Rebuild(flags cli.Input) error {
+	opts := RebuildSubCommand{
+		client: cmdutils.GetServer(flags),
+	}
+	return opts.do(flags)
+}
+
+func (opts *RebuildSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	return opts.run(flags)
+}
+
+func (opts *RebuildSubCommand) complete(flags cli.Input) error {
+	opts.name = flags.String("name")
+	if len(opts.name) == 0 {
+		return errors.New("Need name of package, use --name")
+	}
+	opts.namespace = flags.String("pkgNamespace")
+	return nil
+}
+
+func (opts *RebuildSubCommand) run(flags cli.Input) error {
+	pkg, err := opts.client.PackageGet(&metav1.ObjectMeta{
+		Name:      opts.name,
+		Namespace: opts.namespace,
+	})
+	if err != nil {
+		return errors.Wrap(err, "find package")
+	}
+
+	if pkg.Status.BuildStatus != fv1.BuildStatusFailed {
+		return errors.New(fmt.Sprintf("Package %v is not in %v state.",
+			pkg.Metadata.Name, fv1.BuildStatusFailed))
+	}
+
+	_, err = updatePackageStatus(opts.client, pkg, fv1.BuildStatusPending)
+	if err != nil {
+		return errors.Wrap(err, "update package status")
+	}
+
+	fmt.Printf("Retrying build for pkg %v. Use \"fission pkg info --name %v\" to view status.\n", pkg.Metadata.Name, pkg.Metadata.Name)
+
+	return nil
+}

pkg/fission-cli/cmd/package/update.go

@@ -0,0 +1,200 @@
+/*
+Copyright 2019 The Fission 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 _package
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/pkg/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
+	"github.com/fission/fission/pkg/fission-cli/cmd"
+)
+
+type UpdateSubCommand struct {
+	client             *client.Client
+	pkgName            string
+	pkgNamespace       string
+	force              bool
+	envName            string
+	envNamespace       string
+	srcArchiveFiles    []string
+	deployArchiveFiles []string
+	buildcmd           string
+}
+
+func Update(flags cli.Input) error {
+	opts := UpdateSubCommand{
+		client: cmd.GetServer(flags),
+	}
+	return opts.do(flags)
+}
+
+func (opts *UpdateSubCommand) do(flags cli.Input) error {
+	err := opts.complete(flags)
+	if err != nil {
+		return err
+	}
+	return opts.run(flags)
+}
+
+func (opts *UpdateSubCommand) complete(flags cli.Input) error {
+	opts.pkgName = flags.String("name")
+	if len(opts.pkgName) == 0 {
+		return errors.New("Need --name argument.")
+	}
+	opts.pkgNamespace = flags.String("pkgNamespace")
+	opts.force = flags.Bool("f")
+	opts.envName = flags.String("env")
+	opts.envNamespace = flags.String("envNamespace")
+	opts.srcArchiveFiles = flags.StringSlice("src")
+	opts.deployArchiveFiles = flags.StringSlice("deploy")
+	opts.buildcmd = flags.String("buildcmd")
+
+	if len(opts.srcArchiveFiles) > 0 && len(opts.deployArchiveFiles) > 0 {
+		return errors.New("Need either of --src or --deploy and not both arguments.")
+	}
+
+	if len(opts.srcArchiveFiles) == 0 && len(opts.deployArchiveFiles) == 0 &&
+		len(opts.envName) == 0 && len(opts.buildcmd) == 0 {
+		return errors.New("Need --env or --src or --deploy or --buildcmd argument.")
+	}
+	return nil
+}
+
+func (opts *UpdateSubCommand) run(flags cli.Input) error {
+	pkg, err := opts.client.PackageGet(&metav1.ObjectMeta{
+		Namespace: opts.pkgNamespace,
+		Name:      opts.pkgName,
+	})
+	if err != nil {
+		return errors.Wrap(err, "get package")
+	}
+
+	// if the new env specified is the same as the old one, no need to update package
+	// same is true for all update parameters, but, for now, we dont check all of them - because, its ok to
+	// re-write the object with same old values, we just end up getting a new resource version for the object.
+	if len(opts.envName) > 0 && opts.envName == pkg.Spec.Environment.Name {
+		opts.envName = ""
+	}
+
+	if opts.envNamespace == pkg.Spec.Environment.Namespace {
+		opts.envNamespace = ""
+	}
+
+	fnList, err := GetFunctionsByPackage(opts.client, pkg.Metadata.Name, pkg.Metadata.Namespace)
+	if err != nil {
+		return errors.Wrap(err, "get function list")
+	}
+
+	if !opts.force && len(fnList) > 1 {
+		return errors.New("Package is used by multiple functions, use --force to force update")
+	}
+
+	newPkgMeta, err := UpdatePackage(opts.client, pkg,
+		opts.envName, opts.envNamespace, opts.srcArchiveFiles,
+		opts.deployArchiveFiles, opts.buildcmd, false, false)
+	if err != nil {
+		return errors.Wrap(err, "update package")
+	}
+
+	// update resource version of package reference of functions that shared the same package
+	for _, fn := range fnList {
+		fn.Spec.Package.PackageRef.ResourceVersion = newPkgMeta.ResourceVersion
+		_, err := opts.client.FunctionUpdate(&fn)
+		if err != nil {
+			return errors.Wrap(err, "update function")
+		}
+	}
+
+	fmt.Printf("Package '%v' updated\n", newPkgMeta.GetName())
+	return nil
+}
+
+func UpdatePackage(client *client.Client, pkg *fv1.Package, envName, envNamespace string,
+	srcArchiveFiles []string, deployArchiveFiles []string, buildcmd string, forceRebuild bool, noZip bool) (*metav1.ObjectMeta, error) {
+
+	needToBuild := false
+
+	if len(envName) > 0 {
+		pkg.Spec.Environment.Name = envName
+		needToBuild = true
+	}
+
+	if len(envNamespace) > 0 {
+		pkg.Spec.Environment.Namespace = envNamespace
+		needToBuild = true
+	}
+
+	if len(buildcmd) > 0 {
+		pkg.Spec.BuildCommand = buildcmd
+		needToBuild = true
+	}
+
+	if len(srcArchiveFiles) > 0 {
+		srcArchiveMetadata, err := CreateArchive(client, srcArchiveFiles, false, "", "")
+		if err != nil {
+			return nil, err
+		}
+		pkg.Spec.Source = *srcArchiveMetadata
+		needToBuild = true
+	}
+
+	if len(deployArchiveFiles) > 0 {
+		deployArchiveMetadata, err := CreateArchive(client, deployArchiveFiles, noZip, "", "")
+		if err != nil {
+			return nil, err
+		}
+		pkg.Spec.Deployment = *deployArchiveMetadata
+		// Users may update the env, envNS and deploy archive at the same time,
+		// but without the source archive. In this case, we should set needToBuild to false
+		needToBuild = false
+	}
+
+	// Set package as pending status when needToBuild is true
+	if needToBuild || forceRebuild {
+		// change into pending state to trigger package build
+		pkg.Status = fv1.PackageStatus{
+			BuildStatus:         fv1.BuildStatusPending,
+			LastUpdateTimestamp: time.Now().UTC(),
+		}
+	}
+
+	newPkgMeta, err := client.PackageUpdate(pkg)
+	if err != nil {
+		return nil, errors.Wrap(err, "update package")
+	}
+
+	return newPkgMeta, err
+}
+
+func updatePackageStatus(client *client.Client, pkg *fv1.Package, status fv1.BuildStatus) (*metav1.ObjectMeta, error) {
+	switch status {
+	case fv1.BuildStatusNone, fv1.BuildStatusPending, fv1.BuildStatusRunning, fv1.BuildStatusSucceeded, fv1.CanaryConfigStatusAborted:
+		pkg.Status = fv1.PackageStatus{
+			BuildStatus:         status,
+			LastUpdateTimestamp: time.Now().UTC(),
+		}
+		pkg, err := client.PackageUpdate(pkg)
+		return pkg, err
+	}
+	return nil, errors.New("unknown package status")
+}

pkg/fission-cli/cmd/package/util/util.go

@@ -0,0 +1,166 @@
+/*
+Copyright 2019 The Fission 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 util
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	uuid "github.com/satori/go.uuid"
+
+	fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
+	"github.com/fission/fission/pkg/controller/client"
+	"github.com/fission/fission/pkg/fission-cli/util"
+	storageSvcClient "github.com/fission/fission/pkg/storagesvc/client"
+	"github.com/fission/fission/pkg/types"
+	"github.com/fission/fission/pkg/utils"
+)
+
+func UploadArchive(ctx context.Context, client *client.Client, fileName string) (*fv1.Archive, error) {
+	var archive fv1.Archive
+
+	// If filename is a URL, download it first
+	if strings.HasPrefix(fileName, "http://") || strings.HasPrefix(fileName, "https://") {
+		fileName = DownloadToTempFile(fileName)
+	}
+
+	size, err := utils.FileSize(fileName)
+	if err != nil {
+		return nil, err
+	}
+
+	if size < types.ArchiveLiteralSizeLimit {
+		archive.Type = fv1.ArchiveTypeLiteral
+		archive.Literal = GetContents(fileName)
+	} else {
+		u := strings.TrimSuffix(client.Url, "/") + "/proxy/storage"
+		ssClient := storageSvcClient.MakeClient(u)
+
+		// TODO add a progress bar
+		id, err := ssClient.Upload(ctx, fileName, nil)
+		util.CheckErr(err, fmt.Sprintf("upload file %v", fileName))
+
+		storageSvc, err := client.GetSvcURL("application=fission-storage")
+		storageSvcURL := "http://" + storageSvc
+		util.CheckErr(err, "get fission storage service name")
+
+		// We make a new client with actual URL of Storage service so that the URL is not
+		// pointing to 127.0.0.1 i.e. proxy. DON'T reuse previous ssClient
+		pkgClient := storageSvcClient.MakeClient(storageSvcURL)
+		archiveURL := pkgClient.GetUrl(id)
+
+		archive.Type = fv1.ArchiveTypeUrl
+		archive.URL = archiveURL
+
+		csum, err := utils.FileChecksum(fileName)
+		util.CheckErr(err, fmt.Sprintf("calculate checksum for file %v", fileName))
+
+		archive.Checksum = *csum
+	}
+	return &archive, nil
+}
+
+func GetContents(filePath string) []byte {
+	var code []byte
+	var err error
+
+	code, err = ioutil.ReadFile(filePath)
+	util.CheckErr(err, fmt.Sprintf("read %v", filePath))
+	return code
+}
+
+// DownloadToTempFile fetches archive file from arbitrary url
+// and write it to temp file for further usage
+func DownloadToTempFile(fileUrl string) string {
+	reader, err := DownloadURL(fileUrl)
+	util.CheckErr(err, fmt.Sprintf("download from url: %v", fileUrl))
+	defer reader.Close()
+
+	tmpDir, err := utils.GetTempDir()
+	util.CheckErr(err, "create temp directory")
+
+	tmpFilename := uuid.NewV4().String()
+	destination := filepath.Join(tmpDir, tmpFilename)
+	err = os.Mkdir(tmpDir, 0744)
+	util.CheckErr(err, "create temp directory")
+
+	err = WriteArchiveToFile(destination, reader)
+	util.CheckErr(err, "write archive to file")
+
+	return destination
+}
+
+// DownloadURL downloads file from given url
+func DownloadURL(fileUrl string) (io.ReadCloser, error) {
+	resp, err := http.Get(fileUrl)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("%v - HTTP response returned non 200 status", resp.StatusCode)
+	}
+	return resp.Body, nil
+}
+
+func WriteArchiveToFile(fileName string, reader io.Reader) error {
+	tmpDir, err := utils.GetTempDir()
+	if err != nil {
+		return err
+	}
+
+	path := filepath.Join(tmpDir, fileName+".tmp")
+	w, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(w, reader)
+	if err != nil {
+		return err
+	}
+	err = os.Chmod(path, 0644)
+	if err != nil {
+		return err
+	}
+
+	err = os.Rename(path, fileName)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// DownloadStoragesvcURL downloads and return archive content with given storage service url
+func DownloadStoragesvcURL(client *client.Client, fileUrl string) io.ReadCloser {
+	u, err := url.ParseRequestURI(fileUrl)
+	if err != nil {
+		return nil
+	}
+
+	// replace in-cluster storage service host with controller server url
+	fileDownloadUrl := strings.TrimSuffix(client.Url, "/") + "/proxy/storage/" + u.RequestURI()
+	reader, err := DownloadURL(fileDownloadUrl)
+
+	util.CheckErr(err, fmt.Sprintf("download from storage service url: %v", fileUrl))
+	return reader
+}