func NewCmdVolume(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "volume",
Short: "Creates a persisent volume for fabric8 apps needing persistent disk",
Long: `Creates a persisent volume so that the PersistentVolumeClaims in fabric8 apps can be satisfied when creating fabric8 apps`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, err := f.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
printResult("Get default namespace", Failure, err)
} else {
util.Info("Creating a persistent volume for your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
r, err := createPersistentVolume(cmd, ns, c, f)
printResult("Create PersistentVolume", r, err)
}
},
}
cmd.PersistentFlags().StringP(hostPathFlag, "", "", "Defines the host folder on which to define a persisent volume for single node setups")
cmd.PersistentFlags().StringP(nameFlag, "", "fabric8", "The name of the PersistentVolume to create")
return cmd
}
func logPackageVersion(packageName string, version string) {
util.Info("Deploying package: ")
util.Success(packageName)
util.Info(" version: ")
util.Success(version)
util.Info("\n\n")
}
func NewCmdPull(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "pull [templateNames]",
Short: "Pulls the docker images for the given templates",
Long: `Performs a docker pull on all the docker images referenced in the given templates to preload the local docker registry with images`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) < 1 {
util.Error("No template names specified!")
cmd.Usage()
} else {
_, cfg := client.NewClient(f)
oc, _ := client.NewOpenShiftClient(cfg)
ns, _, err := f.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
} else {
for _, template := range args {
util.Info("Downloading docker images for template ")
util.Success(template)
util.Info("\n\n")
r, err := downloadTemplateDockerImages(cmd, ns, oc, f, template)
printResult("Download Docker images", r, err)
}
}
}
},
}
return cmd
}
func NewCmdIngress(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "ingress",
Short: "Creates any missing Ingress resources for services",
Long: `Creates any missing Ingress resources for Services which are of type LoadBalancer`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, err := f.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
printResult("Get default namespace", Failure, err)
} else {
domain := cmd.Flags().Lookup(domainFlag).Value.String()
util.Info("Setting up ingress on your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s at domain %s\n\n", ns, domain)
err := createIngressForDomain(ns, domain, c, f)
printError("Create Ingress", err)
}
},
}
cmd.PersistentFlags().StringP(domainFlag, "", defaultDomain(), "The domain to put the created routes inside")
return cmd
}
// NewCmdCleanUp delete all fabric8 apps, environments and configurations
func NewCmdCleanUp(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "cleanup",
Short: "Hard delete all fabric8 apps, environments and configurations",
Long: `Hard delete all fabric8 apps, environments and configurations`,
Run: func(cmd *cobra.Command, args []string) {
currentContext, err := util.GetCurrentContext()
if err != nil {
util.Fatalf("%s", err)
}
fmt.Fprintf(os.Stdout, `WARNING this is destructive and will remove ALL fabric8 apps, environments and configuration from cluster %s. Continue? [y/N] `, currentContext)
var confirm string
fmt.Scanln(&confirm)
if confirm == "y" {
util.Info("Removing...\n")
cleanUp(f)
return
}
util.Info("Cancelled")
},
}
return cmd
}
func NewCmdRoutes(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "routes",
Short: "Creates any missing Routes for services",
Long: `Creates any missing Route resources for Services which need to be exposed remotely`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
oc, _ := client.NewOpenShiftClient(cfg)
ns, _, err := f.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
printResult("Get default namespace", Failure, err)
} else {
util.Info("Creating a persistent volume for your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
domain := cmd.Flags().Lookup(domainFlag).Value.String()
err := createRoutesForDomain(ns, domain, c, oc, f)
printError("Create Routes", err)
}
},
}
cmd.PersistentFlags().StringP(domainFlag, "", defaultDomain(), "The domain to put the created routes inside")
return cmd
}
func NewCmdSecrets(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "secrets",
Short: "Set up Secrets on your Kubernetes or OpenShift environment",
Long: `set up Secrets on your Kubernetes or OpenShift environment`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
util.Info("Setting up secrets on your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
if confirmAction(cmd.Flags()) {
typeOfMaster := util.TypeOfMaster(c)
if typeOfMaster == util.Kubernetes {
util.Fatal("Support for Kubernetes not yet available...\n")
} else {
oc, _ := client.NewOpenShiftClient(cfg)
t := getTemplates(oc, ns)
count := 0
// get all the Templates and find the annotations on any Pods
for _, i := range t.Items {
// convert TemplateList.Objects to Kubernetes resources
_ = runtime.DecodeList(i.Objects, api.Scheme, runtime.UnstructuredJSONScheme)
for _, rc := range i.Objects {
switch rc := rc.(type) {
case *api.ReplicationController:
for secretType, secretDataIdentifiers := range rc.Spec.Template.Annotations {
count += createAndPrintSecrets(secretDataIdentifiers, secretType, c, f, cmd.Flags())
}
}
}
}
if count == 0 {
util.Info("No secrets created as no fabric8 secrets annotations found in the templates\n")
util.Info("For more details see: https://github.com/fabric8io/fabric8/blob/master/docs/secretAnnotations.md\n")
}
}
}
},
}
cmd.PersistentFlags().BoolP("print-import-folder-structure", "", true, "Prints the folder structures that are being used by the template annotations to import secrets")
cmd.PersistentFlags().BoolP("write-generated-keys", "", false, "Write generated secrets to the local filesystem")
cmd.PersistentFlags().BoolP("generate-secrets-data", "g", true, "Generate secrets data if secrets cannot be found to import from the local filesystem")
return cmd
}
func NewCmdRun(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "run",
Short: "Runs a fabric8 microservice from one of the installed templates",
Long: `runs a fabric8 microservice from one of the installed templates`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
if len(args) == 0 {
util.Info("Please specify a template name to run\n")
return
}
domain := cmd.Flags().Lookup(domainFlag).Value.String()
apiserver := cmd.Flags().Lookup(apiServerFlag).Value.String()
pv := cmd.Flags().Lookup(pvFlag).Value.String() == "true"
typeOfMaster := util.TypeOfMaster(c)
util.Info("Running an app template to your ")
util.Success(string(typeOfMaster))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" for domain ")
util.Success(domain)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
if len(apiserver) == 0 {
apiserver = domain
}
yes := cmd.Flags().Lookup(yesFlag).Value.String() == "false"
if strings.Contains(domain, "=") {
util.Warnf("\nInvalid domain: %s\n\n", domain)
} else if confirmAction(yes) {
oc, _ := client.NewOpenShiftClient(cfg)
initSchema()
for _, app := range args {
runTemplate(c, oc, app, ns, domain, apiserver, pv)
}
}
},
}
cmd.PersistentFlags().StringP(domainFlag, "d", defaultDomain(), "The domain name to append to the service name to access web applications")
cmd.PersistentFlags().String(apiServerFlag, "", "overrides the api server url")
cmd.PersistentFlags().Bool(pvFlag, true, "Enable the use of persistence (enabling the PersistentVolumeClaims)?")
return cmd
}
func runTemplate(c *k8sclient.Client, oc *oclient.Client, appToRun string, ns string, domain string, apiserver string, pv bool) {
util.Info("\n\nInstalling: ")
util.Successf("%s\n\n", appToRun)
typeOfMaster := util.TypeOfMaster(c)
if typeOfMaster == util.Kubernetes {
jsonData, format, err := loadTemplateData(ns, appToRun, c, oc)
if err != nil {
printError("Failed to load app "+appToRun, err)
}
createTemplate(jsonData, format, appToRun, ns, domain, apiserver, c, oc, pv)
} else {
tmpl, err := oc.Templates(ns).Get(appToRun)
if err != nil {
printError("Failed to load template "+appToRun, err)
}
util.Infof("Loaded template with %d objects", len(tmpl.Objects))
processTemplate(tmpl, ns, domain, apiserver)
objectCount := len(tmpl.Objects)
util.Infof("Creating "+appToRun+" template resources from %d objects\n", objectCount)
for _, o := range tmpl.Objects {
err = processItem(c, oc, &o, ns, pv)
}
}
}
func runTemplate(c *k8sclient.Client, oc *oclient.Client, appToRun string, ns string, domain string, apiserver string) {
util.Info("\n\nInstalling: ")
util.Successf("%s\n\n", appToRun)
jsonData, err := loadTemplateData(ns, appToRun, c, oc)
if err != nil {
printError("Failed to load app "+appToRun, err)
}
createTemplate(jsonData, appToRun, ns, domain, apiserver, c)
}
func confirmAction(flags *pflag.FlagSet) bool {
if flags.Lookup(yesFlag).Value.String() == "false" {
util.Info("Continue? [Y/n] ")
cont := util.AskForConfirmation(true)
if !cont {
util.Fatal("Cancelled...\n")
return false
}
}
return true
}
func NewCmdValidate(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "validate",
Short: "Validate your Kubernetes or OpenShift environment",
Long: `validate your Kubernetes or OpenShift environment`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
util.Info("Validating your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
printValidationResult("Service account", validateServiceAccount, c, f)
printValidationResult("Console", validateConsoleDeployment, c, f)
r, err := validateProxyServiceRestAPI(c, f, cfg.Host)
printResult("REST Proxy Service API", r, err)
if util.TypeOfMaster(c) == util.Kubernetes {
printValidationResult("Jenkinshift Service", validateJenkinshiftService, c, f)
}
if util.TypeOfMaster(c) == util.OpenShift {
printValidationResult("Router", validateRouter, c, f)
oc, _ := client.NewOpenShiftClient(cfg)
printOValidationResult("Templates", validateTemplates, oc, f)
printValidationResult("SecurityContextConstraints", validateSecurityContextConstraints, c, f)
}
printValidationResult("PersistentVolumeClaims", validatePersistenceVolumeClaims, c, f)
printValidationResult("ConfigMaps", validateConfigMaps, c, f)
},
}
return cmd
}
func validatePersistenceVolumeClaims(c *k8sclient.Client, f *cmdutil.Factory) (Result, error) {
ns, _, err := f.DefaultNamespace()
if err != nil {
return Failure, err
}
rc, err := c.PersistentVolumeClaims(ns).List(api.ListOptions{})
if err != nil {
util.Fatalf("Failed to get PersistentVolumeClaims, %s in namespace %s\n", err, ns)
}
if rc != nil {
items := rc.Items
pendingClaimNames := make([]string, 0, len(items))
for _, item := range items {
status := item.Status.Phase
if status != "Bound" {
pendingClaimNames = append(pendingClaimNames, item.ObjectMeta.Name)
}
}
if len(pendingClaimNames) > 0 {
util.Failuref("PersistentVolumeClaim not Bound for: %s. You need to create a PersistentVolume!\n", strings.Join(pendingClaimNames, ", "))
util.Info(`
You can enable dynamic PersistentVolume creation with Kubernetes 1.4 or later.
Or to get gofabric8 to create HostPath based PersistentVolume resources for you on minikube and minishift type:
gofabric8 volumes
For other clusters you could do something like this - though ideally with a persistent volume implementation other than hostPath:
cat <<EOF | oc create -f -
---
kind: PersistentVolume
apiVersion: v1
metadata:
name: fabric8
spec:
accessModes:
- ReadWrite
capacity:
storage: 1000
hostPath:
path: /opt/fabric8-data
EOF
`)
return Failure, err
}
return Success, err
}
return Failure, err
}
// simulates: oadm policy add-cluster-role-to-user roleName userName
func addClusterRoleToUser(c *oclient.Client, f *cmdutil.Factory, roleName string, userName string) error {
namespace, _, err := f.DefaultNamespace()
if err != nil {
util.Info("No namespace!'\n")
return err
}
options := policy.RoleModificationOptions{
RoleName: roleName,
RoleBindingAccessor: policy.NewLocalRoleBindingAccessor(namespace, c),
Users: []string{userName},
}
return options.AddRole()
}
func printSummary(typeOfMaster util.MasterType, externalNodeName string, mini bool, ns string, domain string) {
util.Info("\n")
util.Info("-------------------------\n")
util.Info("\n")
clientType := getClientTypeName(typeOfMaster)
if externalNodeName != "" {
util.Info("Deploying ingress controller on node ")
util.Successf("%s", externalNodeName)
util.Info(" use its external ip when configuring your wildcard DNS.\n")
util.Infof("To change node move the label: `%s label node %s %s- && %s label node $YOUR_NEW_NODE %s=true`\n", clientType, externalNodeName, externalIPLabel, clientType, externalIPLabel)
util.Info("\n")
}
util.Info("Default GOGS admin username/password = "******"%s/%s\n", gogsDefaultUsername, gogsDefaultPassword)
util.Info("\n")
util.Infof("Downloading images and waiting to open the fabric8 console...\n")
util.Info("\n")
util.Info("-------------------------\n")
}
func checkIfPVCsPending(c *k8sclient.Client, ns string) (bool, error) {
timeout := time.After(20 * time.Second)
tick := time.Tick(2 * time.Second)
util.Info("Checking if PersistentVolumeClaims bind to a PersistentVolume ")
// Keep trying until we're timed out or got a result or got an error
for {
select {
// Got a timeout! fail with a timeout error
case <-timeout:
return true, errors.New("timed out")
// Got a tick, check if PVc have bound
case <-tick:
found, _, _ := findPendingPVs(c, ns)
if !found {
util.Info("\n")
return false, nil
}
util.Info(".")
// retry
}
}
}
func downloadDockerImage(imageName string) error {
util.Info("Downloading image ")
util.Success(imageName)
util.Info("\n")
cmd := exec.Command("docker", "pull", imageName)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
var waitStatus syscall.WaitStatus
if err := cmd.Run(); err != nil {
printErr(err)
if exitError, ok := err.(*exec.ExitError); ok {
waitStatus = exitError.Sys().(syscall.WaitStatus)
printStatus(waitStatus.ExitStatus())
}
return err
} else {
waitStatus = cmd.ProcessState.Sys().(syscall.WaitStatus)
printStatus(waitStatus.ExitStatus())
return nil
}
}
func NewCmdCopyEndpoints(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "copy-endpoints",
Short: "Copies endpoints from the current namespace to a target namespace",
Long: `Copies endpoints from the current namespace to a target namespace`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) == 0 {
util.Info("Please specify one or more endpoint names to copy as arguments!\n")
return
}
c, cfg := client.NewClient(f)
oc, _ := client.NewOpenShiftClient(cfg)
initSchema()
toNamespace := cmd.Flags().Lookup(toNamespaceFlag).Value.String()
fromNamespace := cmd.Flags().Lookup(fromNamespaceFlag).Value.String()
if len(fromNamespace) == 0 {
ns, _, err := f.DefaultNamespace()
if err != nil {
util.Fatal("No default namespace")
}
fromNamespace = ns
}
if len(toNamespace) == 0 {
util.Fatal("No target namespace specified!")
}
util.Infof("Copying endpoints from namespace: %s to namespace: %s\n", fromNamespace, toNamespace)
err := ensureNamespaceExists(c, oc, toNamespace)
if err != nil {
util.Fatalf("Failed to copy endpoints %v", err)
}
err = copyEndpoints(c, fromNamespace, toNamespace, args)
if err != nil {
util.Fatalf("Failed to copy endpoints %v", err)
}
},
}
cmd.PersistentFlags().StringP(fromNamespaceFlag, "f", "", "the source namespace or uses the default namespace")
cmd.PersistentFlags().StringP(toNamespaceFlag, "t", "", "the destination namespace")
return cmd
}
func validatePersistenceVolumeClaims(c *k8sclient.Client, f *cmdutil.Factory) (Result, error) {
ns, _, err := f.DefaultNamespace()
if err != nil {
return Failure, err
}
rc, err := c.PersistentVolumeClaims(ns).List(labels.Everything(), fields.Everything())
if err != nil {
util.Fatalf("Failed to get PersistentVolumeClaims, %s in namespace %s\n", err, ns)
}
if rc != nil {
items := rc.Items
pendingClaimNames := make([]string, 0, len(items))
for _, item := range items {
status := item.Status.Phase
if status != "Bound" {
pendingClaimNames = append(pendingClaimNames, item.ObjectMeta.Name)
}
}
if len(pendingClaimNames) > 0 {
util.Failuref("PersistentVolumeClaim not Bound for: %s. You need to create a PersistentVolume!\n", strings.Join(pendingClaimNames, ", "))
util.Info(`
to generate a single node PersistentVolume then type something like this:
cat <<EOF | oc create -f -
---
kind: PersistentVolume
apiVersion: v1
metadata:
name: fabric8
spec:
accessModes:
- ReadWrite
capacity:
storage: 1000
hostPath:
path: /opt/fabric8-data
EOF
`)
return Failure, err
}
return Success, err
}
return Failure, err
}
func keepTryingToGetClient(f *cmdutil.Factory) (*k8client.Client, *restclient.Config, error) {
timeout := time.After(2 * time.Minute)
tick := time.Tick(1 * time.Second)
// Keep trying until we're timed out or got a result or got an error
for {
select {
// Got a timeout! fail with a timeout error
case <-timeout:
return nil, nil, errors.New("timed out")
// Got a tick, try and get teh client
case <-tick:
c, cfg, _ := getClient(f)
// return if we have a client
if c != nil {
return c, cfg, nil
}
util.Info("Cannot connect to api server, retrying...\n")
// retry
}
}
}
// CheckService waits for the specified service to be ready by returning an error until the service is up
// The check is done by polling the endpoint associated with the service and when the endpoint exists, returning no error->service-online
// Credits: https://github.com/kubernetes/minikube/blob/v0.9.0/cmd/minikube/cmd/service.go#L89
func CheckService(ns string, service string, c *k8sclient.Client) error {
svc, err := c.Services(ns).Get(service)
if err != nil {
return err
}
url := svc.ObjectMeta.Annotations[exposeURLAnnotation]
if url == "" {
util.Info(".")
return errors.New("")
}
endpoints := c.Endpoints(ns)
if endpoints == nil {
util.Errorf("No endpoints found in namespace %s\n", ns)
}
endpoint, err := endpoints.Get(service)
if err != nil {
util.Errorf("No endpoints found for service %s\n", service)
return err
}
return CheckEndpointReady(endpoint)
}
func NewCmdDeploy(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploy fabric8 to your Kubernetes or OpenShift environment",
Long: `deploy fabric8 to your Kubernetes or OpenShift environment`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
domain := cmd.Flags().Lookup(domainFlag).Value.String()
apiserver := cmd.Flags().Lookup(apiServerFlag).Value.String()
arch := cmd.Flags().Lookup(archFlag).Value.String()
typeOfMaster := util.TypeOfMaster(c)
util.Info("Deploying fabric8 to your ")
util.Success(string(typeOfMaster))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" for domain ")
util.Success(domain)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
useIngress := cmd.Flags().Lookup(useIngressFlag).Value.String() == "true"
deployConsole := cmd.Flags().Lookup(consoleFlag).Value.String() == "true"
mavenRepo := cmd.Flags().Lookup(mavenRepoFlag).Value.String()
if !strings.HasSuffix(mavenRepo, "/") {
mavenRepo = mavenRepo + "/"
}
util.Info("Loading fabric8 releases from maven repository:")
util.Successf("%s\n", mavenRepo)
dockerRegistry := cmd.Flags().Lookup(dockerRegistryFlag).Value.String()
if len(dockerRegistry) > 0 {
util.Infof("Loading fabric8 docker images from docker registry: %s\n", dockerRegistry)
}
if len(apiserver) == 0 {
apiserver = domain
}
if strings.Contains(domain, "=") {
util.Warnf("\nInvalid domain: %s\n\n", domain)
} else if confirmAction(cmd.Flags()) {
v := cmd.Flags().Lookup("fabric8-version").Value.String()
consoleVersion := f8ConsoleVersion(mavenRepo, v, typeOfMaster)
versioniPaaS := cmd.Flags().Lookup(versioniPaaSFlag).Value.String()
versioniPaaS = versionForUrl(versioniPaaS, urlJoin(mavenRepo, iPaaSMetadataUrl))
versionDevOps := cmd.Flags().Lookup(versionDevOpsFlag).Value.String()
versionDevOps = versionForUrl(versionDevOps, urlJoin(mavenRepo, devOpsMetadataUrl))
versionKubeflix := cmd.Flags().Lookup(versionKubeflixFlag).Value.String()
versionKubeflix = versionForUrl(versionKubeflix, urlJoin(mavenRepo, kubeflixMetadataUrl))
versionZipkin := cmd.Flags().Lookup(versionZipkinFlag).Value.String()
versionZipkin = versionForUrl(versionZipkin, urlJoin(mavenRepo, zipkinMetadataUrl))
util.Warnf("\nStarting fabric8 console deployment using %s...\n\n", consoleVersion)
oc, _ := client.NewOpenShiftClient(cfg)
aapi.AddToScheme(api.Scheme)
aapiv1.AddToScheme(api.Scheme)
tapi.AddToScheme(api.Scheme)
tapiv1.AddToScheme(api.Scheme)
if typeOfMaster == util.Kubernetes {
uri := fmt.Sprintf(urlJoin(mavenRepo, baseConsoleKubernetesUrl), consoleVersion)
if fabric8ImageAdaptionNeeded(dockerRegistry, arch) {
jsonData, err := loadJsonDataAndAdaptFabric8Images(uri, dockerRegistry, arch)
if err == nil {
tmpFileName := "/tmp/fabric8-console.json"
t, err := os.OpenFile(tmpFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0777)
if err != nil {
util.Fatalf("Cannot open the converted fabric8 console template file: %v", err)
}
defer t.Close()
_, err = io.Copy(t, bytes.NewReader(jsonData))
if err != nil {
util.Fatalf("Cannot write the converted fabric8 console template file: %v", err)
}
uri = tmpFileName
}
}
filenames := []string{uri}
if deployConsole {
createCmd := &cobra.Command{}
cmdutil.AddValidateFlags(createCmd)
cmdutil.AddOutputFlagsForMutation(createCmd)
cmdutil.AddApplyAnnotationFlags(createCmd)
cmdutil.AddRecordFlag(createCmd)
err := kcmd.RunCreate(f, createCmd, ioutil.Discard, &kcmd.CreateOptions{Filenames: filenames})
if err != nil {
printResult("fabric8 console", Failure, err)
} else {
printResult("fabric8 console", Success, nil)
}
}
printAddServiceAccount(c, f, "fluentd")
printAddServiceAccount(c, f, "registry")
} else {
r, err := verifyRestrictedSecurityContextConstraints(c, f)
printResult("SecurityContextConstraints restricted", r, err)
r, err = deployFabric8SecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints fabric8", r, err)
r, err = deployFabric8SASSecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints "+Fabric8SASSCC, r, err)
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":fabric8")
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":jenkins")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":metrics")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":fluentd")
printAddServiceAccount(c, f, "fluentd")
printAddServiceAccount(c, f, "registry")
printAddServiceAccount(c, f, "router")
if cmd.Flags().Lookup(templatesFlag).Value.String() == "true" {
if deployConsole {
uri := fmt.Sprintf(urlJoin(mavenRepo, baseConsoleUrl), consoleVersion)
jsonData, err := loadJsonDataAndAdaptFabric8Images(uri, dockerRegistry, arch)
if err != nil {
printError("failed to apply docker registry prefix", err)
}
// lets delete the OAuthClient first as the domain may have changed
oc.OAuthClients().Delete("fabric8")
createTemplate(jsonData, "fabric8 console", ns, domain, apiserver, c)
}
} else {
printError("Ignoring the deploy of the fabric8 console", nil)
}
}
if deployConsole {
println("Created fabric8 console")
}
if cmd.Flags().Lookup(templatesFlag).Value.String() == "true" {
println("Installing templates!")
printError("Install DevOps templates", installTemplates(c, oc, f, versionDevOps, urlJoin(mavenRepo, devopsTemplatesDistroUrl), dockerRegistry, arch, domain))
printError("Install iPaaS templates", installTemplates(c, oc, f, versioniPaaS, urlJoin(mavenRepo, iPaaSTemplatesDistroUrl), dockerRegistry, arch, domain))
printError("Install Kubeflix templates", installTemplates(c, oc, f, versionKubeflix, urlJoin(mavenRepo, kubeflixTemplatesDistroUrl), dockerRegistry, arch, domain))
printError("Install Zipkin templates", installTemplates(c, oc, f, versionZipkin, urlJoin(mavenRepo, zipkinTemplatesDistroUrl), dockerRegistry, arch, domain))
} else {
printError("Ignoring the deploy of templates", nil)
}
appToRun := cmd.Flags().Lookup(runFlag).Value.String()
if len(appToRun) > 0 {
runTemplate(c, oc, appToRun, ns, domain, apiserver)
}
if typeOfMaster == util.Kubernetes {
if useIngress {
runTemplate(c, oc, "ingress-nginx", ns, domain, apiserver)
printError("Create ingress resources", createIngressForDomain(ns, domain, c, f))
}
} else {
printError("Create route resources", createRoutesForDomain(ns, domain, c, oc, f))
}
// lets label the namespace/project as a developer team
nss := c.Namespaces()
namespace, err := nss.Get(ns)
if err != nil {
printError("Failed to load namespace", err)
} else {
if addLabelIfNotxisEt(&namespace.ObjectMeta, typeLabel, teamTypeLabelValue) {
_, err = nss.Update(namespace)
if err != nil {
printError("Failed to label namespace", err)
}
}
}
}
},
}
cmd.PersistentFlags().StringP("domain", "d", defaultDomain(), "The domain name to append to the service name to access web applications")
cmd.PersistentFlags().String("api-server", "", "overrides the api server url")
cmd.PersistentFlags().String(archFlag, goruntime.GOARCH, "CPU architecture for referencing Docker images with this as a name suffix")
cmd.PersistentFlags().String(versioniPaaSFlag, "latest", "The version to use for the Fabric8 iPaaS templates")
cmd.PersistentFlags().String(versionDevOpsFlag, "latest", "The version to use for the Fabric8 DevOps templates")
cmd.PersistentFlags().String(versionKubeflixFlag, "latest", "The version to use for the Kubeflix templates")
cmd.PersistentFlags().String(versionZipkinFlag, "latest", "The version to use for the Zipkin templates")
cmd.PersistentFlags().String(mavenRepoFlag, "https://repo1.maven.org/maven2/", "The maven repo used to find releases of fabric8")
cmd.PersistentFlags().String(dockerRegistryFlag, "", "The docker registry used to download fabric8 images. Typically used to point to a staging registry")
cmd.PersistentFlags().String(runFlag, "", "The name of the fabric8 app to startup. e.g. use `--app=cd-pipeline` to run the main CI/CD pipeline app")
cmd.PersistentFlags().Bool(templatesFlag, true, "Should the standard Fabric8 templates be installed?")
cmd.PersistentFlags().Bool(consoleFlag, true, "Should the Fabric8 console be deployed?")
cmd.PersistentFlags().Bool(useIngressFlag, true, "Should Ingress be enabled by default?")
return cmd
}
func NewCmdDeploy(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploy fabric8 to your Kubernetes or OpenShift environment",
Long: `deploy fabric8 to your Kubernetes or OpenShift environment`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
domain := cmd.Flags().Lookup(domainFlag).Value.String()
apiserver := cmd.Flags().Lookup(apiServerFlag).Value.String()
arch := cmd.Flags().Lookup(archFlag).Value.String()
mini := isMini(c, ns)
typeOfMaster := util.TypeOfMaster(c)
// extract the ip address from the URL
ip := strings.Split(cfg.Host, ":")[1]
ip = strings.Replace(ip, "/", "", 2)
if mini && typeOfMaster == util.OpenShift {
domain = ip + ".xip.io"
apiserver = ip
}
util.Info("Deploying fabric8 to your ")
util.Success(string(typeOfMaster))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" for domain ")
util.Success(domain)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
useIngress := cmd.Flags().Lookup(useIngressFlag).Value.String() == "true"
deployConsole := cmd.Flags().Lookup(consoleFlag).Value.String() == "true"
pv, err := shouldEnablePV(c, cmd.Flags())
if err != nil {
util.Fatalf("No nodes available, something bad has happened: %v", err)
}
mavenRepo := cmd.Flags().Lookup(mavenRepoFlag).Value.String()
if !strings.HasSuffix(mavenRepo, "/") {
mavenRepo = mavenRepo + "/"
}
util.Info("Loading fabric8 releases from maven repository:")
util.Successf("%s\n", mavenRepo)
dockerRegistry := cmd.Flags().Lookup(dockerRegistryFlag).Value.String()
if len(dockerRegistry) > 0 {
util.Infof("Loading fabric8 docker images from docker registry: %s\n", dockerRegistry)
}
if len(apiserver) == 0 {
apiserver = domain
}
if strings.Contains(domain, "=") {
util.Warnf("\nInvalid domain: %s\n\n", domain)
} else if confirmAction(cmd.Flags()) {
v := cmd.Flags().Lookup("fabric8-version").Value.String()
consoleVersion := f8ConsoleVersion(mavenRepo, v, typeOfMaster)
versioniPaaS := cmd.Flags().Lookup(versioniPaaSFlag).Value.String()
versioniPaaS = versionForUrl(versioniPaaS, urlJoin(mavenRepo, iPaaSMetadataUrl))
versionDevOps := cmd.Flags().Lookup(versionDevOpsFlag).Value.String()
versionDevOps = versionForUrl(versionDevOps, urlJoin(mavenRepo, devOpsMetadataUrl))
versionKubeflix := cmd.Flags().Lookup(versionKubeflixFlag).Value.String()
versionKubeflix = versionForUrl(versionKubeflix, urlJoin(mavenRepo, kubeflixMetadataUrl))
versionZipkin := cmd.Flags().Lookup(versionZipkinFlag).Value.String()
versionZipkin = versionForUrl(versionZipkin, urlJoin(mavenRepo, zipkinMetadataUrl))
util.Warnf("\nStarting fabric8 console deployment using %s...\n\n", consoleVersion)
oc, _ := client.NewOpenShiftClient(cfg)
initSchema()
if typeOfMaster == util.Kubernetes {
uri := fmt.Sprintf(urlJoin(mavenRepo, baseConsoleKubernetesUrl), consoleVersion)
if fabric8ImageAdaptionNeeded(dockerRegistry, arch) {
jsonData, err := loadJsonDataAndAdaptFabric8Images(uri, dockerRegistry, arch)
if err == nil {
tmpFileName := path.Join(os.TempDir(), "fabric8-console.json")
t, err := os.OpenFile(tmpFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0777)
if err != nil {
util.Fatalf("Cannot open the converted fabric8 console template file: %v", err)
}
defer t.Close()
_, err = io.Copy(t, bytes.NewReader(jsonData))
if err != nil {
util.Fatalf("Cannot write the converted fabric8 console template file: %v", err)
}
uri = tmpFileName
}
}
filenames := []string{uri}
if deployConsole {
createCmd := &cobra.Command{}
cmdutil.AddValidateFlags(createCmd)
cmdutil.AddOutputFlagsForMutation(createCmd)
cmdutil.AddApplyAnnotationFlags(createCmd)
cmdutil.AddRecordFlag(createCmd)
err := kcmd.RunCreate(f, createCmd, ioutil.Discard, &kcmd.CreateOptions{Filenames: filenames})
if err != nil {
printResult("fabric8 console", Failure, err)
} else {
printResult("fabric8 console", Success, nil)
}
}
printAddServiceAccount(c, f, "fluentd")
printAddServiceAccount(c, f, "registry")
} else {
r, err := verifyRestrictedSecurityContextConstraints(c, f)
printResult("SecurityContextConstraints restricted", r, err)
r, err = deployFabric8SecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints fabric8", r, err)
r, err = deployFabric8SASSecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints "+Fabric8SASSCC, r, err)
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":fabric8")
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":jenkins")
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":exposecontroller")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":metrics")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":fluentd")
printAddClusterRoleToGroup(oc, f, "cluster-reader", "system:serviceaccounts")
printAddServiceAccount(c, f, "fluentd")
printAddServiceAccount(c, f, "registry")
printAddServiceAccount(c, f, "router")
if cmd.Flags().Lookup(templatesFlag).Value.String() == "true" {
if deployConsole {
uri := fmt.Sprintf(urlJoin(mavenRepo, baseConsoleUrl), consoleVersion)
format := "json"
jsonData, err := loadJsonDataAndAdaptFabric8Images(uri, dockerRegistry, arch)
if err != nil {
printError("failed to apply docker registry prefix", err)
}
// lets delete the OAuthClient first as the domain may have changed
oc.OAuthClients().Delete("fabric8")
createTemplate(jsonData, format, "fabric8 console", ns, domain, apiserver, c, oc, pv)
oac, err := oc.OAuthClients().Get("fabric8")
if err != nil {
printError("failed to get the OAuthClient called fabric8", err)
}
// lets add the nodePort URL to the OAuthClient
service, err := c.Services(ns).Get("fabric8")
if err != nil {
printError("failed to get the Service called fabric8", err)
}
port := 0
for _, p := range service.Spec.Ports {
port = p.NodePort
}
if port == 0 {
printError("failed to find nodePort on the Service called fabric8", err)
}
ip := apiserver
redirectURL := fmt.Sprintf("http://%s:%d", ip, port)
println("Adding OAuthClient redirectURL: " + redirectURL)
oac.RedirectURIs = append(oac.RedirectURIs, redirectURL)
oac.ResourceVersion = ""
oc.OAuthClients().Delete("fabric8")
_, err = oc.OAuthClients().Create(oac)
if err != nil {
printError("failed to create the OAuthClient called fabric8", err)
}
}
} else {
printError("Ignoring the deploy of the fabric8 console", nil)
}
}
if deployConsole {
println("Created fabric8 console")
}
if cmd.Flags().Lookup(templatesFlag).Value.String() == "true" {
println("Installing templates!")
printError("Install DevOps templates", installTemplates(c, oc, f, versionDevOps, urlJoin(mavenRepo, devopsTemplatesDistroUrl), dockerRegistry, arch, domain))
printError("Install iPaaS templates", installTemplates(c, oc, f, versioniPaaS, urlJoin(mavenRepo, iPaaSTemplatesDistroUrl), dockerRegistry, arch, domain))
printError("Install Kubeflix templates", installTemplates(c, oc, f, versionKubeflix, urlJoin(mavenRepo, kubeflixTemplatesDistroUrl), dockerRegistry, arch, domain))
printError("Install Zipkin templates", installTemplates(c, oc, f, versionZipkin, urlJoin(mavenRepo, zipkinTemplatesDistroUrl), dockerRegistry, arch, domain))
} else {
printError("Ignoring the deploy of templates", nil)
}
runTemplate(c, oc, "exposecontroller", ns, domain, apiserver, pv)
externalNodeName := ""
if typeOfMaster == util.Kubernetes {
if useIngress && !mini {
runTemplate(c, oc, "ingress-nginx", ns, domain, apiserver, pv)
externalNodeName = addIngressInfraLabel(c, ns)
}
}
// create a populate the exposecontroller config map
cfgms := c.ConfigMaps(ns)
useLoadBalancer := cmd.Flags().Lookup(useLoadbalancerFlag).Value.String() == "true"
_, err := cfgms.Get(exposecontrollerCM)
if err == nil {
util.Infof("\nRecreating configmap %s \n", exposecontrollerCM)
err = cfgms.Delete(exposecontrollerCM)
if err != nil {
printError("\nError deleting ConfigMap: "+exposecontrollerCM, err)
}
}
configMap := kapi.ConfigMap{
ObjectMeta: kapi.ObjectMeta{
Name: exposecontrollerCM,
Labels: map[string]string{
"provider": "fabric8.io",
},
},
Data: map[string]string{
"domain": domain,
exposeRule: defaultExposeRule(c, mini, useLoadBalancer),
},
}
_, err = cfgms.Create(&configMap)
if err != nil {
printError("Failed to create ConfigMap: "+exposecontrollerCM, err)
}
appToRun := cmd.Flags().Lookup(runFlag).Value.String()
if len(appToRun) > 0 {
runTemplate(c, oc, appToRun, ns, domain, apiserver, pv)
// lets create any missing PVs if on minikube or minishift
found, pendingClaimNames := findPendingPVS(c, ns)
if found {
createPV(c, ns, pendingClaimNames, cmd)
}
}
// lets label the namespace/project as a developer team
nss := c.Namespaces()
namespace, err := nss.Get(ns)
if err != nil {
printError("Failed to load namespace", err)
} else {
changed := addLabelIfNotExist(&namespace.ObjectMeta, typeLabel, teamTypeLabelValue)
if len(domain) > 0 {
if addAnnotationIfNotExist(&namespace.ObjectMeta, domainAnnotation, domain) {
changed = true
}
}
if changed {
_, err = nss.Update(namespace)
if err != nil {
printError("Failed to label and annotate namespace", err)
}
}
}
// lets ensure that there is a `fabric8-environments` ConfigMap so that the current namespace
// shows up as a Team page in the console
_, err = cfgms.Get(fabric8Environments)
if err != nil {
configMap := kapi.ConfigMap{
ObjectMeta: kapi.ObjectMeta{
Name: fabric8Environments,
Labels: map[string]string{
"provider": "fabric8.io",
"kind": "environments",
},
},
}
_, err = cfgms.Create(&configMap)
if err != nil {
printError("Failed to create ConfigMap: "+fabric8Environments, err)
}
}
nodeClient := c.Nodes()
nodes, err := nodeClient.List(api.ListOptions{})
changed := false
for _, node := range nodes.Items {
// if running on a single node then we can use node ports to access kubernetes services
if len(nodes.Items) == 1 {
changed = addAnnotationIfNotExist(&node.ObjectMeta, externalIPNodeLabel, ip)
}
changed = addAnnotationIfNotExist(&node.ObjectMeta, externalAPIServerAddressLabel, cfg.Host)
if changed {
_, err = nodeClient.Update(&node)
if err != nil {
printError("Failed to annotate node with ", err)
}
}
}
printSummary(typeOfMaster, externalNodeName, mini, ns, domain)
openService(ns, "fabric8", c, false)
}
},
}
cmd.PersistentFlags().StringP(domainFlag, "d", defaultDomain(), "The domain name to append to the service name to access web applications")
cmd.PersistentFlags().String(apiServerFlag, "", "overrides the api server url")
cmd.PersistentFlags().String(archFlag, goruntime.GOARCH, "CPU architecture for referencing Docker images with this as a name suffix")
cmd.PersistentFlags().String(versioniPaaSFlag, "latest", "The version to use for the Fabric8 iPaaS templates")
cmd.PersistentFlags().String(versionDevOpsFlag, "latest", "The version to use for the Fabric8 DevOps templates")
cmd.PersistentFlags().String(versionKubeflixFlag, "latest", "The version to use for the Kubeflix templates")
cmd.PersistentFlags().String(versionZipkinFlag, "latest", "The version to use for the Zipkin templates")
cmd.PersistentFlags().String(mavenRepoFlag, "https://repo1.maven.org/maven2/", "The maven repo used to find releases of fabric8")
cmd.PersistentFlags().String(dockerRegistryFlag, "", "The docker registry used to download fabric8 images. Typically used to point to a staging registry")
cmd.PersistentFlags().String(runFlag, "cd-pipeline", "The name of the fabric8 app to startup. e.g. use `--app=cd-pipeline` to run the main CI/CD pipeline app")
cmd.PersistentFlags().Bool(pvFlag, true, "Enable the use of persistence (Not currently supported on the CDK)")
cmd.PersistentFlags().Bool(noPVFlag, false, "(Deprecated use --pv=false to disable instead) Disable the use of persistence (disabling the PersistentVolumeClaims)?")
cmd.PersistentFlags().Bool(templatesFlag, true, "Should the standard Fabric8 templates be installed?")
cmd.PersistentFlags().Bool(consoleFlag, true, "Should the Fabric8 console be deployed?")
cmd.PersistentFlags().Bool(useIngressFlag, true, "Should Ingress NGINX controller be enabled by default when deploying to Kubernetes?")
cmd.PersistentFlags().Bool(useLoadbalancerFlag, false, "Should Cloud Provider LoadBalancer be used to expose services when running to Kubernetes? (overrides ingress)")
return cmd
}
func NewCmdDeploy(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "deploy",
Short: "Deploy fabric8 to your Kubernetes or OpenShift environment",
Long: `deploy fabric8 to your Kubernetes or OpenShift environment`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
util.Info("Deploying fabric8 to your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
if confirmAction(cmd.Flags()) {
v := cmd.Flags().Lookup("version").Value.String()
typeOfMaster := util.TypeOfMaster(c)
v = f8Version(v, typeOfMaster)
versioniPaaS := cmd.Flags().Lookup(versioniPaaSFlag).Value.String()
versioniPaaS = versionForUrl(versioniPaaS, iPaaSMetadataUrl)
util.Warnf("\nStarting deployment of %s...\n\n", v)
if typeOfMaster == util.Kubernetes {
uri := fmt.Sprintf(baseConsoleKubernetesUrl, v)
filenames := []string{uri}
createCmd := cobra.Command{}
createCmd.Flags().StringSlice("filename", filenames, "")
err := kcmd.RunCreate(f, &createCmd, ioutil.Discard)
if err != nil {
printResult("fabric8 console", Failure, err)
} else {
printResult("fabric8 console", Success, nil)
}
} else {
oc, _ := client.NewOpenShiftClient(cfg)
r, err := verifyRestrictedSecurityContextConstraints(c, f)
printResult("SecurityContextConstraints restricted", r, err)
r, err = deployFabric8SecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints fabric8", r, err)
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":fabric8")
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":jenkins")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":metrics")
printAddServiceAccount(c, f, "metrics")
printAddServiceAccount(c, f, "router")
if cmd.Flags().Lookup(templatesFlag).Value.String() == "true" {
uri := fmt.Sprintf(baseConsoleUrl, v)
resp, err := http.Get(uri)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
defer resp.Body.Close()
jsonData, err := ioutil.ReadAll(resp.Body)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
var v1tmpl tapiv1.Template
err = json.Unmarshal(jsonData, &v1tmpl)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
var tmpl tapi.Template
err = api.Scheme.Convert(&v1tmpl, &tmpl)
if err != nil {
util.Fatalf("Cannot get fabric8 template to deploy: %v", err)
}
generators := map[string]generator.Generator{
"expression": generator.NewExpressionValueGenerator(rand.New(rand.NewSource(time.Now().UnixNano()))),
}
p := template.NewProcessor(generators)
tmpl.Parameters = append(tmpl.Parameters, tapi.Parameter{
Name: "DOMAIN",
Value: cmd.Flags().Lookup("domain").Value.String(),
})
p.Process(&tmpl)
for _, o := range tmpl.Objects {
switch o := o.(type) {
case *runtime.Unstructured:
var b []byte
b, err = json.Marshal(o.Object)
if err != nil {
break
}
req := c.Post().Body(b)
if o.Kind != "OAuthClient" {
req.Namespace(ns).Resource(strings.ToLower(o.TypeMeta.Kind + "s"))
} else {
req.AbsPath("oapi", "v1", strings.ToLower(o.TypeMeta.Kind+"s"))
}
res := req.Do()
if res.Error() != nil {
err = res.Error()
break
}
var statusCode int
res.StatusCode(&statusCode)
if statusCode != http.StatusCreated {
err = fmt.Errorf("Failed to create %s: %d", o.TypeMeta.Kind, statusCode)
break
}
}
}
if err != nil {
printResult("fabric8 console", Failure, err)
} else {
printResult("fabric8 console", Success, nil)
}
} else {
printError("Ignoring the deploy of the fabric8 console", nil)
}
if cmd.Flags().Lookup(templatesFlag).Value.String() == "true" {
printError("Install DevOps templates", installTemplates(oc, f, v, templatesDistroUrl))
printError("Install iPaaS templates", installTemplates(oc, f, versioniPaaS, iPaaSTemplatesDistroUrl))
} else {
printError("Ignoring the deploy of templates", nil)
}
domain := cmd.Flags().Lookup(domainFlag).Value.String()
printError("Create routes", createRoutesForDomain(ns, domain, c, oc, f))
}
}
},
}
cmd.PersistentFlags().StringP("domain", "d", defaultDomain(), "The domain name to append to the service name to access web applications")
cmd.PersistentFlags().StringP(versioniPaaSFlag, "", "latest", "The version to use for the Fabric8 iPaaS templates")
cmd.PersistentFlags().Bool(templatesFlag, true, "Should the standard Fabric8 templates be installed?")
cmd.PersistentFlags().Bool(consoleFlag, true, "Should the Fabric8 console be deployed?")
return cmd
}
func removePVCVolumes(jsonData []byte, format string, templateName string, kind string) []byte {
var err error
if kind == "Deployment" {
var deployment v1beta1.Deployment
if format == "yaml" {
err = yaml.Unmarshal(jsonData, &deployment)
} else {
err = json.Unmarshal(jsonData, &deployment)
}
if err != nil {
util.Fatalf("Cannot unmarshal Deployment %s. error: %v\ntemplate: %s", templateName, err, string(jsonData))
} else {
updated := false
podSpec := &deployment.Spec.Template.Spec
for i, _ := range podSpec.Volumes {
v := &podSpec.Volumes[i]
pvc := v.PersistentVolumeClaim
if pvc != nil {
updated = true
// lets convert the PVC to an EmptyDir
v.PersistentVolumeClaim = nil
v.EmptyDir = &v1.EmptyDirVolumeSource{
Medium: v1.StorageMediumDefault,
}
}
}
if updated {
util.Info("Converted Deployment to avoid the use of PersistentVolumeClaim\n")
format = "json"
jsonData, err = json.Marshal(&deployment)
if err != nil {
util.Fatalf("Failed to marshal modified Deployment %s. error: %v\ntemplate: %s", templateName, err, string(jsonData))
}
//util.Infof("Updated: %s\n", string(jsonData))
}
}
}
if kind == "DeploymentConfig" {
var deployment deployapiv1.DeploymentConfig
if format == "yaml" {
err = yaml.Unmarshal(jsonData, &deployment)
} else {
err = json.Unmarshal(jsonData, &deployment)
}
if err != nil {
util.Fatalf("Cannot unmarshal DeploymentConfig %s. error: %v\ntemplate: %s", templateName, err, string(jsonData))
} else {
updated := false
podSpec := &deployment.Spec.Template.Spec
for i, _ := range podSpec.Volumes {
v := &podSpec.Volumes[i]
pvc := v.PersistentVolumeClaim
if pvc != nil {
updated = true
// lets convert the PVC to an EmptyDir
v.PersistentVolumeClaim = nil
v.EmptyDir = &v1.EmptyDirVolumeSource{
Medium: v1.StorageMediumDefault,
}
}
}
if updated {
util.Info("Converted DeploymentConfig to avoid the use of PersistentVolumeClaim\n")
format = "json"
jsonData, err = json.Marshal(&deployment)
if err != nil {
util.Fatalf("Failed to marshal modified DeploymentConfig %s. error: %v\ntemplate: %s", templateName, err, string(jsonData))
}
//util.Infof("Updated: %s\n", string(jsonData))
}
}
}
return jsonData
}
func createTemplate(jsonData []byte, format string, templateName string, ns string, domain string, apiserver string, c *k8sclient.Client, oc *oclient.Client, pv bool) {
var v1tmpl tapiv1.Template
var err error
if format == "yaml" {
err = yaml.Unmarshal(jsonData, &v1tmpl)
} else {
err = json.Unmarshal(jsonData, &v1tmpl)
}
if err != nil {
util.Fatalf("Cannot get %s template to deploy. error: %v\ntemplate: %s", templateName, err, string(jsonData))
}
var tmpl tapi.Template
err = api.Scheme.Convert(&v1tmpl, &tmpl, nil)
if err != nil {
util.Fatalf("Cannot convert %s template to deploy: %v", templateName, err)
}
processTemplate(&tmpl, ns, domain, apiserver)
objectCount := len(tmpl.Objects)
if objectCount == 0 {
// can't be a template so lets try just process it directly
var v1List v1.List
if format == "yaml" {
err = yaml.Unmarshal(jsonData, &v1List)
} else {
err = json.Unmarshal(jsonData, &v1List)
}
if err != nil {
util.Fatalf("Cannot unmarshal List %s. error: %v\ntemplate: %s", templateName, err, string(jsonData))
}
if len(v1List.Items) == 0 {
processData(jsonData, format, templateName, ns, c, oc, pv)
} else {
for _, i := range v1List.Items {
data := i.Raw
if data == nil {
util.Infof("no data!\n")
continue
}
kind := ""
o := i.Object
if o != nil {
objectKind := o.GetObjectKind()
if objectKind != nil {
groupVersionKind := objectKind.GroupVersionKind()
kind = groupVersionKind.Kind
}
}
if len(kind) == 0 {
processData(data, format, templateName, ns, c, oc, pv)
} else {
// TODO how to find the Namespace?
err = processResource(c, data, ns, kind)
if err != nil {
util.Fatalf("Failed to process kind %s template: %s error: %v\n", kind, err, templateName)
}
}
if err != nil {
util.Info("No kind found so processing data directly\n")
printResult(templateName, Failure, err)
}
}
}
} else {
util.Infof("Creating "+templateName+" template resources in namespace %s from %d objects\n", ns, objectCount)
for _, o := range tmpl.Objects {
err = processItem(c, oc, &o, ns, pv)
}
}
if err != nil {
printResult(templateName, Failure, err)
} else {
printResult(templateName, Success, nil)
}
}
func NewCmdSecrets(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "secrets",
Short: "Set up Secrets on your Kubernetes or OpenShift environment",
Long: `set up Secrets on your Kubernetes or OpenShift environment`,
PreRun: func(cmd *cobra.Command, args []string) {
showBanner()
},
Run: func(cmd *cobra.Command, args []string) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
util.Info("Setting up secrets on your ")
util.Success(string(util.TypeOfMaster(c)))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
yes := cmd.Flags().Lookup(yesFlag).Value.String() == "false"
if confirmAction(yes) {
tapi.AddToScheme(api.Scheme)
tapiv1.AddToScheme(api.Scheme)
count := 0
typeOfMaster := util.TypeOfMaster(c)
catalogSelector := map[string]string{
"provider": "fabric8.io",
"kind": "catalog",
}
configmaps, err := c.ConfigMaps(ns).List(api.ListOptions{
LabelSelector: labels.Set(catalogSelector).AsSelector(),
})
if err != nil {
fmt.Println("Failed to load Catalog configmaps %s", err)
} else {
for _, configmap := range configmaps.Items {
for key, data := range configmap.Data {
obj, err := runtime.Decode(api.Codecs.UniversalDecoder(), []byte(data))
if err != nil {
util.Infof("Failed to decodeconfig map %s with key %s. Got error: %s", configmap.ObjectMeta.Name, key, err)
} else {
switch rc := obj.(type) {
case *api.ReplicationController:
for secretType, secretDataIdentifiers := range rc.Spec.Template.Annotations {
count += createAndPrintSecrets(secretDataIdentifiers, secretType, c, f, cmd.Flags())
}
case *tapi.Template:
count += processSecretsForTemplate(c, *rc, f, cmd)
}
}
}
}
}
if typeOfMaster != util.Kubernetes {
oc, _ := client.NewOpenShiftClient(cfg)
t := getTemplates(oc, ns)
// get all the Templates and find the annotations on any Pods
for _, i := range t.Items {
count += processSecretsForTemplate(c, i, f, cmd)
}
}
if count == 0 {
util.Info("No secrets created as no fabric8 secrets annotations found in the Fabric8 Catalog\n")
util.Info("For more details see: https://github.com/fabric8io/fabric8/blob/master/docs/secretAnnotations.md\n")
}
}
},
}
cmd.PersistentFlags().BoolP("print-import-folder-structure", "", true, "Prints the folder structures that are being used by the template annotations to import secrets")
cmd.PersistentFlags().BoolP("write-generated-keys", "", false, "Write generated secrets to the local filesystem")
cmd.PersistentFlags().BoolP("generate-secrets-data", "g", true, "Generate secrets data if secrets cannot be found to import from the local filesystem")
return cmd
}
func printSummary(typeOfMaster util.MasterType, externalNodeName string, ns string, domain string, c *k8sclient.Client) {
util.Info("\n")
util.Info("-------------------------\n")
util.Info("\n")
clientType := getClientTypeName(typeOfMaster)
if externalNodeName != "" {
util.Info("Deploying ingress controller on node ")
util.Successf("%s", externalNodeName)
util.Info(" use its external ip when configuring your wildcard DNS.\n")
util.Infof("To change node move the label: `%s label node %s %s- && %s label node $YOUR_NEW_NODE %s=true`\n", clientType, externalNodeName, externalIPLabel, clientType, externalIPLabel)
util.Info("\n")
}
util.Info("Default GOGS admin username/password = "******"%s/%s\n", gogsDefaultUsername, gogsDefaultPassword)
util.Info("\n")
found, _ := checkIfPVCsPending(c, ns)
if found {
util.Errorf("There are pending PersistentVolumeClaims\n")
util.Infof("If using a local cluster run `gofabric8 volumes` to create missing HostPath volumes\n")
util.Infof("If using a remote cloud then enable dynamic persistence with a StorageClass. For details see http://fabric8.io/guide/getStarted/persistence.html\n")
util.Info("\n")
}
util.Infof("Downloading images and waiting to open the fabric8 console...\n")
util.Info("\n")
util.Info("-------------------------\n")
}
func getSecretData(secretType string, name string, keysNames []string, flags *flag.FlagSet) map[string][]byte {
var dataType = strings.Split(secretType, "/")
var data = make(map[string][]byte)
switch dataType[1] {
case "secret-ssh-key":
if flags.Lookup("print-import-folder-structure").Value.String() == "true" {
logSecretImport(name + "/ssh-key")
logSecretImport(name + "/ssh-key.pub")
}
sshKey, err1 := ioutil.ReadFile(name + "/ssh-key")
sshKeyPub, err2 := ioutil.ReadFile(name + "/ssh-key.pub")
// if we cant find the public and private key to import, and generation flag is set then lets generate the keys
if (err1 != nil && err2 != nil) && flags.Lookup("generate-secrets-data").Value.String() == "true" {
util.Info("No secrets found on local filesystem, generating SSH public and private key pair\n")
keypair := generateSshKeyPair()
if flags.Lookup("write-generated-keys").Value.String() == "true" {
writeFile(name+"/ssh-key", keypair.priv)
writeFile(name+"/ssh-key.pub", keypair.pub)
}
data["ssh-key"] = keypair.priv
data["ssh-key.pub"] = keypair.pub
} else if (err1 != nil || err2 != nil) && flags.Lookup("generate-secrets-data").Value.String() == "true" {
util.Infof("Found some keys to import but with errors so unable to generate SSH public and private key pair. %s\n", name)
check(err1)
check(err2)
} else {
// if we're not generating the keys and there's an error importing them then still create the secret but with empty data
check(err1)
check(err2)
data["ssh-key"] = sshKey
data["ssh-key.pub"] = sshKeyPub
}
return data
case "secret-ssh-public-key":
for i := 0; i < len(keysNames); i++ {
if flags.Lookup("print-import-folder-structure").Value.String() == "true" {
logSecretImport(name + "/" + keysNames[i])
}
sshPub, err := ioutil.ReadFile(name + "/" + keysNames[i])
// if we cant find the public key to import and generation flag is set then lets generate the key
if (err != nil) && flags.Lookup("generate-secrets-data").Value.String() == "true" {
util.Info("No secrets found on local filesystem, generating SSH public key\n")
keypair := generateSshKeyPair()
if flags.Lookup("write-generated-keys").Value.String() == "true" {
writeFile(name+"/ssh-key.pub", keypair.pub)
}
data[keysNames[i]] = keypair.pub
} else {
// if we're not generating the keys and there's an error importing them then still create the secret but with empty data
check(err)
data[keysNames[i]] = sshPub
}
}
return data
case "secret-gpg-key":
for i := 0; i < len(keysNames); i++ {
if flags.Lookup("print-import-folder-structure").Value.String() == "true" {
logSecretImport(name + "/" + keysNames[i])
}
gpg, err := ioutil.ReadFile(name + "/" + keysNames[i])
check(err)
data[keysNames[i]] = gpg
}
case "secret-github-api-token":
if flags.Lookup("print-import-folder-structure").Value.String() == "true" {
logSecretImport(name + "/apitoken")
}
apitoken, err := ioutil.ReadFile(name + "/apitoken")
check(err)
data["apitoken"] = apitoken
case "secret-docker-cfg":
if flags.Lookup("print-import-folder-structure").Value.String() == "true" {
logSecretImport(name + "/config.json")
}
dockerCfg, err := ioutil.ReadFile(name + "/config.json")
check(err)
data["config.json"] = dockerCfg
case "secret-maven-settings":
if flags.Lookup("print-import-folder-structure").Value.String() == "true" {
logSecretImport(name + "/settings.xml")
}
mvn, err := ioutil.ReadFile(name + "/settings.xml")
check(err)
if err != nil && flags.Lookup("generate-secrets-data").Value.String() == "true" {
defaultSettingsXML := "https://raw.githubusercontent.com/fabric8io/gofabric8/master/default-secrets/mvnsettings.xml"
logSecretImport("Using deafult maven settings from " + defaultSettingsXML)
resp, err := http.Get(defaultSettingsXML)
if err != nil {
util.Fatalf("Cannot get fabric8 version to deploy: %v", err)
}
defer resp.Body.Close()
// read xml http response
mvn, err := ioutil.ReadAll(resp.Body)
if err != nil {
util.Fatalf("Cannot get fabric8 version to deploy: %v", err)
}
data["settings.xml"] = mvn
} else {
data["settings.xml"] = mvn
}
return data
default:
util.Fatalf("No matching data type %s\n", dataType)
}
return data
}
func deploy(f *cmdutil.Factory, d DefaultFabric8Deployment) {
c, cfg := client.NewClient(f)
ns, _, _ := f.DefaultNamespace()
domain := d.domain
dockerRegistry := d.dockerRegistry
mini, err := util.IsMini()
if err != nil {
util.Failuref("error checking if minikube or minishift %v", err)
}
packageName := d.packageName
if len(packageName) == 0 {
util.Fatalf("Missing value for --%s", packageFlag)
}
typeOfMaster := util.TypeOfMaster(c)
// extract the ip address from the URL
u, err := url.Parse(cfg.Host)
if err != nil {
util.Fatalf("%s", err)
}
ip, _, err := net.SplitHostPort(u.Host)
if err != nil && !strings.Contains(err.Error(), "missing port in address") {
util.Fatalf("%s", err)
}
// default xip domain if local deployment incase users deploy ingress controller or router
if mini && typeOfMaster == util.OpenShift {
domain = ip + ".xip.io"
}
// default to the server from the current context
apiserver := u.Host
if d.apiserver != "" {
apiserver = d.apiserver
}
util.Info("Deploying fabric8 to your ")
util.Success(string(typeOfMaster))
util.Info(" installation at ")
util.Success(cfg.Host)
util.Info(" for domain ")
util.Success(domain)
util.Info(" in namespace ")
util.Successf("%s\n\n", ns)
mavenRepo := d.mavenRepo
if !strings.HasSuffix(mavenRepo, "/") {
mavenRepo = mavenRepo + "/"
}
util.Info("Loading fabric8 releases from maven repository:")
util.Successf("%s\n", mavenRepo)
if len(dockerRegistry) > 0 {
util.Infof("Loading fabric8 docker images from docker registry: %s\n", dockerRegistry)
}
if len(apiserver) == 0 {
apiserver = domain
}
if len(d.appToRun) > 0 {
util.Warn("Please note that the --app parameter is now deprecated.\n")
util.Warn("Please use the --package argument to specify a package like `platform`, `console`, `ipaas` or to refer to a URL or file of the YAML package to install\n")
}
if strings.Contains(domain, "=") {
util.Warnf("\nInvalid domain: %s\n\n", domain)
} else if confirmAction(d.yes) {
oc, _ := client.NewOpenShiftClient(cfg)
initSchema()
ensureNamespaceExists(c, oc, ns)
versionPlatform := ""
baseUri := ""
switch packageName {
case "":
case platformPackage:
baseUri = platformPackageUrlPrefix
versionPlatform = versionForUrl(d.versionPlatform, urlJoin(mavenRepo, platformMetadataUrl))
logPackageVersion(packageName, versionPlatform)
case consolePackage:
baseUri = consolePackageUrlPrefix
versionPlatform = versionForUrl(d.versionPlatform, urlJoin(mavenRepo, consolePackageMetadataUrl))
logPackageVersion(packageName, versionPlatform)
case iPaaSPackage:
baseUri = ipaasPackageUrlPrefix
versionPlatform = versionForUrl(d.versioniPaaS, urlJoin(mavenRepo, ipaasMetadataUrl))
logPackageVersion(packageName, versionPlatform)
default:
baseUri = ""
}
uri := ""
if len(baseUri) > 0 {
uri = fmt.Sprintf(urlJoin(mavenRepo, baseUri), versionPlatform)
} else {
// lets assume the package is a file or a uri already
if strings.Contains(packageName, "://") {
uri = packageName
} else {
d, err := os.Stat(packageName)
if err != nil {
util.Fatalf("package %s not recognised and is not a local file %s\n", packageName, err)
}
if m := d.Mode(); m.IsDir() {
util.Fatalf("package %s not recognised and is not a local file %s\n", packageName, err)
}
absFile, err := filepath.Abs(packageName)
if err != nil {
util.Fatalf("package %s not recognised and is not a local file %s\n", packageName, err)
}
uri = "file://" + absFile
}
}
if typeOfMaster == util.Kubernetes {
if !strings.HasPrefix(uri, "file://") {
uri += "kubernetes.yml"
}
} else {
if !strings.HasPrefix(uri, "file://") {
uri += "openshift.yml"
}
r, err := verifyRestrictedSecurityContextConstraints(c, f)
printResult("SecurityContextConstraints restricted", r, err)
r, err = deployFabric8SecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints fabric8", r, err)
r, err = deployFabric8SASSecurityContextConstraints(c, f, ns)
printResult("SecurityContextConstraints "+Fabric8SASSCC, r, err)
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":fabric8")
// TODO replace all of this with the necessary RoleBindings inside the OpenShift YAML...
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":jenkins")
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":configmapcontroller")
printAddClusterRoleToUser(oc, f, "cluster-admin", "system:serviceaccount:"+ns+":exposecontroller")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":metrics")
printAddClusterRoleToUser(oc, f, "cluster-reader", "system:serviceaccount:"+ns+":fluentd")
printAddClusterRoleToGroup(oc, f, "cluster-reader", "system:serviceaccounts")
printAddServiceAccount(c, f, "fluentd")
printAddServiceAccount(c, f, "registry")
printAddServiceAccount(c, f, "router")
}
// now lets apply this template
util.Infof("Now about to install package %s\n", uri)
yamlData := []byte{}
format := "yaml"
if strings.HasPrefix(uri, "file://") {
fileName := strings.TrimPrefix(uri, "file://")
if strings.HasSuffix(fileName, ".json") {
format = "json"
}
yamlData, err = ioutil.ReadFile(fileName)
if err != nil {
util.Fatalf("Cannot load file %s got: %v", fileName, err)
}
} else {
resp, err := http.Get(uri)
if err != nil {
util.Fatalf("Cannot load YAML package at %s got: %v", uri, err)
}
defer resp.Body.Close()
yamlData, err = ioutil.ReadAll(resp.Body)
if err != nil {
util.Fatalf("Cannot load YAML from %s got: %v", uri, err)
}
}
createTemplate(yamlData, format, packageName, ns, domain, apiserver, c, oc, d.pv)
externalNodeName := ""
if typeOfMaster == util.Kubernetes {
if !mini && d.useIngress {
ensureNamespaceExists(c, oc, fabric8SystemNamespace)
util.Infof("ns is %s\n", ns)
runTemplate(c, oc, "ingress-nginx", ns, domain, apiserver, d.pv)
externalNodeName = addIngressInfraLabel(c, ns)
}
}
updateExposeControllerConfig(c, ns, apiserver, domain, mini, d.useLoadbalancer)
mini, _ := util.IsMini()
if mini {
createMissingPVs(c, ns)
}
printSummary(typeOfMaster, externalNodeName, ns, domain, c)
if d.openConsole {
openService(ns, "fabric8", c, false, true)
}
}
}
