Update k8s dependencies to 1.10 (#687)

This commit is contained in:
Ta-Ching Chen
2018-06-01 15:43:19 +08:00
committed by GitHub
parent 202cc3cb7e
commit 7a7d15b50c
48 changed files with 1974 additions and 1186 deletions
+1 -1
View File
@@ -23,9 +23,9 @@ import (
"text/tabwriter"
"github.com/urfave/cli"
"k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/pkg/api/v1"
"github.com/fission/fission"
"github.com/fission/fission/controller/client"
+1 -1
View File
@@ -30,9 +30,9 @@ import (
"github.com/satori/go.uuid"
"github.com/urfave/cli"
apiv1 "k8s.io/api/core/v1"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
apiv1 "k8s.io/client-go/pkg/api/v1"
"github.com/fission/fission"
"github.com/fission/fission/crd"
-8
View File
@@ -259,13 +259,6 @@ func main() {
{Name: "restore", Usage: "Restore state dumped from a v0.1 install into a v0.2+ install", Flags: []cli.Flag{upgradeFileFlag}, Action: upgradeRestoreState},
}
migrateFileFlag := cli.StringFlag{Name: "file", Usage: "JSON file containing all CRDs"}
migrateSubCommands := []cli.Command{
{Name: "dump", Usage: "Dump all state from a pre-0.4 Fission installation (which used ThirdPartyResources) into a JSON file", Flags: []cli.Flag{migrateFileFlag}, Action: migrateDumpTPR},
{Name: "delete", Usage: "Delete all TPRs", Flags: []cli.Flag{}, Action: migrateDeleteTPR},
{Name: "restore", Usage: "Restore state dumped from a pre-0.4 Fission cluster. Requires Fission 0.4, which uses Kubernetes CustomResources.", Flags: []cli.Flag{migrateFileFlag}, Action: migrateRestoreCRD},
}
// specs
specDirFlag := cli.StringFlag{Name: "specdir", Usage: "Directory to store specs, defaults to ./specs"}
specNameFlag := cli.StringFlag{Name: "name", Usage: "(optional) Name for the app, applied to resources as a Kubernetes annotation"}
@@ -290,7 +283,6 @@ func main() {
{Name: "package", Aliases: []string{"pkg"}, Usage: "Manage packages", Subcommands: pkgSubCommands},
{Name: "spec", Aliases: []string{"specs"}, Usage: "Manage a declarative app specification", Subcommands: specSubCommands},
{Name: "upgrade", Aliases: []string{}, Usage: "Upgrade tool from fission v0.1", Subcommands: upgradeSubCommands},
{Name: "tpr2crd", Aliases: []string{}, Usage: "Migrate tool for TPR to CRD", Subcommands: migrateSubCommands},
}
app.Before = cliHook
-213
View File
@@ -1,213 +0,0 @@
/*
Copyright 2017 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 main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"github.com/urfave/cli"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/fission/fission"
"github.com/fission/fission/controller/client"
"github.com/fission/fission/crd"
)
type (
TPRResource struct {
Packages []crd.Package `json:"packages"`
Functions []crd.Function `json:"functions"`
Environments []crd.Environment `json:"environments"`
HTTPTriggers []crd.HTTPTrigger `json:"httptriggers"`
Mqtriggers []crd.MessageQueueTrigger `json:"mqtriggers"`
TimeTriggers []crd.TimeTrigger `json:"timetriggers"`
Watches []crd.KubernetesWatchTrigger `json:"watches"`
}
)
func migrateDumpTPRResource(client *client.Client, filename string) {
pkgs, err := client.PackageList(metav1.NamespaceAll)
checkErr(err, "dump packages")
fns, err := client.FunctionList(metav1.NamespaceAll)
checkErr(err, "dump functions")
httpTriggers, err := client.HTTPTriggerList(metav1.NamespaceAll)
checkErr(err, "dump http triggers")
envs, err := client.EnvironmentList(metav1.NamespaceAll)
checkErr(err, "dump environments")
watches, err := client.WatchList(metav1.NamespaceAll)
checkErr(err, "dump watches")
timeTriggers, err := client.TimeTriggerList(metav1.NamespaceAll)
checkErr(err, "dump time triggers")
mqTriggers, err := client.MessageQueueTriggerList(fission.MessageQueueTypeNats, metav1.NamespaceAll)
checkErr(err, "dump message queue triggers")
tprResource := TPRResource{
Packages: pkgs,
Functions: fns,
HTTPTriggers: httpTriggers,
Environments: envs,
Watches: watches,
TimeTriggers: timeTriggers,
Mqtriggers: mqTriggers,
}
// serialize tprResource
out, err := json.MarshalIndent(tprResource, "", " ")
checkErr(err, "serialize tpr state")
// dump to file fission-tpr.json
if len(filename) == 0 {
filename = "fission-tpr.json"
}
err = ioutil.WriteFile(filename, out, 0644)
checkErr(err, "write file")
fmt.Printf("Done: Saved %v packages, %v functions, %v HTTP triggers, %v watches, %v message queue triggers, %v time triggers.\n",
len(tprResource.Packages), len(tprResource.Functions), len(tprResource.HTTPTriggers), len(tprResource.Watches), len(tprResource.Mqtriggers),
len(tprResource.TimeTriggers))
}
func migrateDumpTPR(c *cli.Context) error {
filename := c.String("file")
client := getClient(c.GlobalString("server"))
migrateDumpTPRResource(client, filename)
return nil
}
func migrateDeleteTPR(c *cli.Context) error {
server := c.GlobalString("server")
relativeUrl := fmt.Sprintf("%v/%v", server, "v2/deleteTpr")
req, err := http.NewRequest("DELETE", relativeUrl, nil)
checkErr(err, "connect to fission server")
resp, err := http.DefaultClient.Do(req)
checkErr(err, "delete tpr resources")
defer resp.Body.Close()
if resp.StatusCode == http.StatusNotFound {
msg := fmt.Sprintf("Server %v isn't support deleteTpr method. Use --server to point at a 0.4.0+ Fission server.", server)
fatal(msg)
}
return nil
}
// checkAlreadyExistsError helps to check whether the error is AlreadyExists error or not.
func checkAlreadyExistsError(err error, msg string) {
fe, ok := err.(fission.Error)
// ignore AlreadyExists error, since a resource may exist.
if !ok || fe.Code != fission.ErrorNameExists {
checkErr(err, msg)
}
}
func migrateRestoreCRD(c *cli.Context) error {
filename := c.String("file")
if len(filename) == 0 {
filename = "fission-tpr.json"
}
contents, err := ioutil.ReadFile(filename)
checkErr(err, fmt.Sprintf("open file %v", filename))
var tprResource TPRResource
err = json.Unmarshal(contents, &tprResource)
checkErr(err, "parse dumped tpr")
client := getClient(c.GlobalString("server"))
// Though Kubernetes will migrate TPRs to CRDs automatically when TPR definition is
// deleted if the same name CRD exists. We still need to make sure that there is no
// resource gets lost during the migration. Also, since we changed the capitalization
// of some CRDs to CamelCase (e.g. Httptrigger -> HTTPTrigger), we need to recreate
// those resources by ourselves.
// create envs
for _, e := range tprResource.Environments {
e.Metadata.ResourceVersion = ""
_, err = client.EnvironmentCreate(&crd.Environment{
Metadata: e.Metadata,
Spec: e.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create environment %v", e.Metadata.Name))
}
// create httptriggers
for _, t := range tprResource.HTTPTriggers {
t.Metadata.ResourceVersion = ""
_, err = client.HTTPTriggerCreate(&crd.HTTPTrigger{
Metadata: t.Metadata,
Spec: t.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create http trigger %v", t.Metadata.Name))
}
// create mqtriggers
for _, t := range tprResource.Mqtriggers {
t.Metadata.ResourceVersion = ""
_, err = client.MessageQueueTriggerCreate(&crd.MessageQueueTrigger{
Metadata: t.Metadata,
Spec: t.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create http trigger %v", t.Metadata.Name))
}
// create time triggers
for _, t := range tprResource.TimeTriggers {
t.Metadata.ResourceVersion = ""
_, err = client.TimeTriggerCreate(&crd.TimeTrigger{
Metadata: t.Metadata,
Spec: t.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create time trigger %v", t.Metadata.Name))
}
// create watches
for _, t := range tprResource.Watches {
t.Metadata.ResourceVersion = ""
_, err = client.WatchCreate(&crd.KubernetesWatchTrigger{
Metadata: t.Metadata,
Spec: t.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create kubernetes watch trigger %v", t.Metadata.Name))
}
// create packages
for _, p := range tprResource.Packages {
p.Metadata.ResourceVersion = ""
_, err = client.PackageCreate(&crd.Package{
Metadata: p.Metadata,
Spec: p.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create function %v", p.Metadata.Name))
}
// create functions
for _, f := range tprResource.Functions {
f.Metadata.ResourceVersion = ""
_, err = client.FunctionCreate(&crd.Function{
Metadata: f.Metadata,
Spec: f.Spec,
})
checkAlreadyExistsError(err, fmt.Sprintf("create function %v", f.Metadata.Name))
}
return nil
}
+2 -1
View File
@@ -27,6 +27,7 @@ import (
"github.com/fission/fission"
"github.com/fission/fission/crd"
fv1 "github.com/fission/fission/pkg/apis/fission.io/v1"
)
func mqtCreate(c *cli.Context) error {
@@ -202,7 +203,7 @@ func mqtList(c *cli.Context) error {
func checkMQTopicAvailability(mqType fission.MessageQueueType, topics ...string) {
for _, t := range topics {
if len(t) > 0 && !fission.IsTopicValid(mqType, t) {
if len(t) > 0 && !fv1.IsTopicValid(mqType, t) {
fatal(fmt.Sprintf("Invalid topic for %s: %s", mqType, t))
}
}
+6 -4
View File
@@ -3,6 +3,7 @@ package main
import (
"fmt"
"net"
"net/http"
"os"
"strconv"
"strings"
@@ -12,7 +13,7 @@ import (
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/client-go/tools/portforward"
"k8s.io/client-go/tools/remotecommand"
"k8s.io/client-go/transport/spdy"
)
func findFreePort() (string, error) {
@@ -101,7 +102,7 @@ func runPortForward(kubeConfig string, labelSelector string, localPort string, f
readyChannel := make(chan struct{})
// create request URL
req := clientset.CoreV1Client.RESTClient().Post().Resource("pods").
req := clientset.CoreV1().RESTClient().Post().Resource("pods").
Namespace(podNameSpace).Name(podName).SubResource("portforward")
url := req.URL()
@@ -110,11 +111,12 @@ func runPortForward(kubeConfig string, labelSelector string, localPort string, f
ports := []string{portCombo}
// actually start the port-forwarding process here
dialer, err := remotecommand.NewExecutor(config, "POST", url)
transport, upgrader, err := spdy.RoundTripperFor(config)
if err != nil {
msg := fmt.Sprintf("newexecutor errored out :%v", err.Error())
msg := fmt.Sprintf("Failed to connect to Fission service on Kubernetes: %v", err.Error())
fatal(msg)
}
dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", url)
outStream := os.Stdout
if verbosity < 2 {