279 lines
8.7 KiB
Go
279 lines
8.7 KiB
Go
/*
|
|
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 function
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/pkg/errors"
|
|
k8serrors "k8s.io/apimachinery/pkg/api/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"
|
|
_package "github.com/fission/fission/pkg/fission-cli/cmd/package"
|
|
"github.com/fission/fission/pkg/fission-cli/console"
|
|
flagkey "github.com/fission/fission/pkg/fission-cli/flag/key"
|
|
"github.com/fission/fission/pkg/fission-cli/util"
|
|
"github.com/fission/fission/pkg/types"
|
|
)
|
|
|
|
type UpdateSubCommand struct {
|
|
client *client.Client
|
|
function *fv1.Function
|
|
}
|
|
|
|
func Update(input cli.Input) error {
|
|
c, err := util.GetServer(input)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
opts := UpdateSubCommand{
|
|
client: c,
|
|
}
|
|
return opts.do(input)
|
|
}
|
|
|
|
func (opts *UpdateSubCommand) do(input cli.Input) error {
|
|
err := opts.complete(input)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return opts.run(input)
|
|
}
|
|
|
|
func (opts *UpdateSubCommand) complete(input cli.Input) error {
|
|
fnName := input.String(flagkey.FnName)
|
|
fnNamespace := input.String(flagkey.NamespaceFunction)
|
|
|
|
function, err := opts.client.FunctionGet(&metav1.ObjectMeta{
|
|
Name: input.String(flagkey.FnName),
|
|
Namespace: input.String(flagkey.NamespaceFunction),
|
|
})
|
|
if err != nil {
|
|
return errors.Wrap(err, fmt.Sprintf("read function '%v'", fnName))
|
|
}
|
|
|
|
envName := input.String(flagkey.FnEnvironmentName)
|
|
envNamespace := input.String(flagkey.NamespaceEnvironment)
|
|
// 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(envName) > 0 && envName == function.Spec.Environment.Name {
|
|
envName = ""
|
|
}
|
|
|
|
if envNamespace == function.Spec.Environment.Namespace {
|
|
envNamespace = ""
|
|
}
|
|
|
|
var deployArchiveFiles []string
|
|
codeFlag := false
|
|
code := input.String(flagkey.PkgCode)
|
|
if len(code) == 0 {
|
|
deployArchiveFiles = input.StringSlice(flagkey.PkgDeployArchive)
|
|
} else {
|
|
deployArchiveFiles = append(deployArchiveFiles, input.String(flagkey.PkgCode))
|
|
codeFlag = true
|
|
}
|
|
|
|
srcArchiveFiles := input.StringSlice(flagkey.PkgSrcArchive)
|
|
pkgName := input.String(flagkey.FnPackageName)
|
|
entrypoint := input.String(flagkey.FnEntrypoint)
|
|
buildcmd := input.String(flagkey.PkgBuildCmd)
|
|
force := input.Bool(flagkey.PkgForce)
|
|
|
|
secretNames := input.StringSlice(flagkey.FnSecret)
|
|
cfgMapNames := input.StringSlice(flagkey.FnCfgMap)
|
|
|
|
specializationTimeout := input.Int(flagkey.FnSpecializationTimeout)
|
|
|
|
if len(srcArchiveFiles) > 0 && len(deployArchiveFiles) > 0 {
|
|
return errors.Errorf("need either of --%v or --%v and not both arguments", flagkey.PkgSrcArchive, flagkey.PkgDeployArchive)
|
|
}
|
|
|
|
var secrets []fv1.SecretReference
|
|
var configMaps []fv1.ConfigMapReference
|
|
|
|
if len(secretNames) > 0 {
|
|
|
|
// check that the referenced secret is in the same ns as the function, if not give a warning.
|
|
for _, secretName := range secretNames {
|
|
_, err := opts.client.SecretGet(&metav1.ObjectMeta{
|
|
Namespace: fnNamespace,
|
|
Name: secretName,
|
|
})
|
|
if k8serrors.IsNotFound(err) {
|
|
console.Warn(fmt.Sprintf("secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace))
|
|
}
|
|
}
|
|
|
|
for _, secretName := range secretNames {
|
|
newSecret := fv1.SecretReference{
|
|
Name: secretName,
|
|
Namespace: fnNamespace,
|
|
}
|
|
secrets = append(secrets, newSecret)
|
|
}
|
|
|
|
function.Spec.Secrets = secrets
|
|
}
|
|
|
|
if len(cfgMapNames) > 0 {
|
|
|
|
// check that the referenced cfgmap is in the same ns as the function, if not give a warning.
|
|
for _, cfgMapName := range cfgMapNames {
|
|
_, err := opts.client.ConfigMapGet(&metav1.ObjectMeta{
|
|
Namespace: fnNamespace,
|
|
Name: cfgMapName,
|
|
})
|
|
if k8serrors.IsNotFound(err) {
|
|
console.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as the function", cfgMapName, fnNamespace))
|
|
}
|
|
}
|
|
|
|
for _, cfgMapName := range cfgMapNames {
|
|
newCfgMap := fv1.ConfigMapReference{
|
|
Name: cfgMapName,
|
|
Namespace: fnNamespace,
|
|
}
|
|
configMaps = append(configMaps, newCfgMap)
|
|
}
|
|
function.Spec.ConfigMaps = configMaps
|
|
}
|
|
|
|
if len(envName) > 0 {
|
|
function.Spec.Environment.Name = envName
|
|
}
|
|
|
|
if len(envNamespace) > 0 {
|
|
function.Spec.Environment.Namespace = envNamespace
|
|
}
|
|
|
|
if len(entrypoint) > 0 {
|
|
function.Spec.Package.FunctionName = entrypoint
|
|
}
|
|
|
|
if input.IsSet(flagkey.FnExecutionTimeout) {
|
|
fnTimeout := input.Int(flagkey.FnExecutionTimeout)
|
|
if fnTimeout <= 0 {
|
|
return errors.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
|
|
}
|
|
function.Spec.FunctionTimeout = fnTimeout
|
|
}
|
|
|
|
if len(pkgName) == 0 {
|
|
pkgName = function.Spec.Package.PackageRef.Name
|
|
}
|
|
|
|
strategy, err := getInvokeStrategy(input, &function.Spec.InvokeStrategy)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
function.Spec.InvokeStrategy = *strategy
|
|
|
|
if input.IsSet(flagkey.FnSpecializationTimeout) {
|
|
if strategy.ExecutionStrategy.ExecutorType != types.ExecutorTypeNewdeploy {
|
|
return errors.Errorf("--%v flag is only applicable for newdeploy type of executor", flagkey.FnSpecializationTimeout)
|
|
}
|
|
|
|
if specializationTimeout < fv1.DefaultSpecializationTimeOut {
|
|
return errors.Errorf("--%v must be greater than or equal to 120 seconds", flagkey.FnSpecializationTimeout)
|
|
} else {
|
|
function.Spec.InvokeStrategy.ExecutionStrategy.SpecializationTimeout = specializationTimeout
|
|
}
|
|
}
|
|
|
|
resReqs, err := util.GetResourceReqs(input, &function.Spec.Resources)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
function.Spec.Resources = *resReqs
|
|
|
|
pkg, err := opts.client.PackageGet(&metav1.ObjectMeta{
|
|
Namespace: fnNamespace,
|
|
Name: pkgName,
|
|
})
|
|
if err != nil {
|
|
return errors.Wrap(err, fmt.Sprintf("read package '%v.%v'. Pkg should be present in the same ns as the function", pkgName, fnNamespace))
|
|
}
|
|
|
|
pkgMetadata := &pkg.Metadata
|
|
|
|
if len(deployArchiveFiles) != 0 || len(srcArchiveFiles) != 0 || len(buildcmd) != 0 || len(envName) != 0 || len(envNamespace) != 0 {
|
|
fnList, err := _package.GetFunctionsByPackage(opts.client, pkg.Metadata.Name, pkg.Metadata.Namespace)
|
|
if err != nil {
|
|
return errors.Wrap(err, "error getting function list")
|
|
}
|
|
|
|
if !force && len(fnList) > 1 {
|
|
return errors.New("package is used by multiple functions, use --force to force update")
|
|
}
|
|
|
|
pkgMetadata, err = _package.UpdatePackage(opts.client, pkg, envName, envNamespace, srcArchiveFiles, deployArchiveFiles, buildcmd, false, codeFlag)
|
|
if err != nil {
|
|
return errors.Wrap(err, fmt.Sprintf("error updating package '%v'", pkgName))
|
|
}
|
|
|
|
fmt.Printf("package '%v' updated\n", pkgMetadata.GetName())
|
|
|
|
// update resource version of package reference of functions that shared the same package
|
|
for _, fn := range fnList {
|
|
// ignore the update for current function here, it will be updated later.
|
|
if fn.Metadata.Name != fnName {
|
|
fn.Spec.Package.PackageRef.ResourceVersion = pkgMetadata.ResourceVersion
|
|
_, err := opts.client.FunctionUpdate(&fn)
|
|
if err != nil {
|
|
return errors.Wrap(err, "error updating function")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO : One corner case where user just updates the pkg reference with fnUpdate, but internally this new pkg reference
|
|
// references a diff env than the spec
|
|
|
|
// update function spec with new package metadata
|
|
function.Spec.Package.PackageRef = fv1.PackageRef{
|
|
Namespace: pkgMetadata.Namespace,
|
|
Name: pkgMetadata.Name,
|
|
ResourceVersion: pkgMetadata.ResourceVersion,
|
|
}
|
|
|
|
if function.Spec.Environment.Name != pkg.Spec.Environment.Name {
|
|
console.Warn("Function's environment is different than package's environment, package's environment will be used for updating function")
|
|
function.Spec.Environment.Name = pkg.Spec.Environment.Name
|
|
function.Spec.Environment.Namespace = pkg.Spec.Environment.Namespace
|
|
}
|
|
|
|
opts.function = function
|
|
|
|
return nil
|
|
}
|
|
|
|
func (opts *UpdateSubCommand) run(input cli.Input) error {
|
|
_, err := opts.client.FunctionUpdate(opts.function)
|
|
if err != nil {
|
|
return errors.Wrap(err, "error updating function")
|
|
}
|
|
|
|
fmt.Printf("function '%v' updated\n", opts.function.Metadata.Name)
|
|
return nil
|
|
}
|