Update from master

OWNERS

@@ -5,3 +5,4 @@ approvers:
   - installer-approvers
 reviewers:
   - installer-reviewers
+component: Installer

README.md

@@ -18,7 +18,7 @@
 
 First, install all [build dependencies](docs/dev/dependencies.md).
 
-Clone this repository to `src/github.com/openshift/installer` in your [GOPATH](https://golang.org/cmd/go/#hdr-GOPATH_environment_variable). Then build the `openshift-install` binary with:
+Clone this repository. Then build the `openshift-install` binary with:
 
 ```sh
 hack/build.sh

cmd/openshift-install/create.go

@@ -32,6 +32,7 @@ import (
 	assetstore "github.com/openshift/installer/pkg/asset/store"
 	targetassets "github.com/openshift/installer/pkg/asset/targets"
 	destroybootstrap "github.com/openshift/installer/pkg/destroy/bootstrap"
+	timer "github.com/openshift/installer/pkg/metrics/timer"
 	"github.com/openshift/installer/pkg/types/baremetal"
 	cov1helpers "github.com/openshift/library-go/pkg/config/clusteroperator/v1helpers"
 )
@@ -96,6 +97,7 @@ var (
 					logrus.Fatal(errors.Wrap(err, "loading kubeconfig"))
 				}
 
+				timer.StartTimer("Bootstrap Complete")
 				err = waitForBootstrapComplete(ctx, config, rootOpts.dir)
 				if err != nil {
 					if err2 := logClusterOperatorConditions(ctx, config); err2 != nil {
@@ -106,6 +108,8 @@ var (
 					}
 					logrus.Fatal("Bootstrap failed to complete: ", err)
 				}
+				timer.StopTimer("Bootstrap Complete")
+				timer.StartTimer("Bootstrap Destroy")
 
 				if oi, ok := os.LookupEnv("OPENSHIFT_INSTALL_PRESERVE_BOOTSTRAP"); ok && oi != "" {
 					logrus.Warn("OPENSHIFT_INSTALL_PRESERVE_BOOTSTRAP is set, not destroying bootstrap resources. " +
@@ -117,6 +121,7 @@ var (
 						logrus.Fatal(err)
 					}
 				}
+				timer.StopTimer("Bootstrap Destroy")
 
 				err = waitForInstallComplete(ctx, config, rootOpts.dir)
 				if err != nil {
@@ -125,6 +130,8 @@ var (
 					}
 					logrus.Fatal(err)
 				}
+				timer.StopTimer(timer.TotalTimeElapsed)
+				timer.LogSummary()
 			},
 		},
 		assets: targetassets.Cluster,
@@ -181,6 +188,8 @@ func runTargetCmd(targets ...asset.WritableAsset) func(cmd *cobra.Command, args
 	}
 
 	return func(cmd *cobra.Command, args []string) {
+		timer.StartTimer(timer.TotalTimeElapsed)
+
 		cleanup := setupFileHook(rootOpts.dir)
 		defer cleanup()
 
@@ -249,6 +258,7 @@ func waitForBootstrapComplete(ctx context.Context, config *rest.Config, director
 
 	apiTimeout := 20 * time.Minute
 	logrus.Infof("Waiting up to %v for the Kubernetes API at %s...", apiTimeout, config.Host)
+
 	apiContext, cancel := context.WithTimeout(ctx, apiTimeout)
 	defer cancel()
 	// Poll quickly so we notice changes, but only log when the response
@@ -257,10 +267,12 @@ func waitForBootstrapComplete(ctx context.Context, config *rest.Config, director
 	logDownsample := 15
 	silenceRemaining := logDownsample
 	previousErrorSuffix := ""
+	timer.StartTimer("API")
 	wait.Until(func() {
 		version, err := discovery.ServerVersion()
 		if err == nil {
 			logrus.Infof("API %s up", version)
+			timer.StopTimer("API")
 			cancel()
 		} else {
 			silenceRemaining--
@@ -347,6 +359,7 @@ func waitForInitializedCluster(ctx context.Context, config *rest.Config) error {
 	defer cancel()
 
 	failing := configv1.ClusterStatusConditionType("Failing")
+	timer.StartTimer("Cluster Operators")
 	var lastError string
 	_, err = clientwatch.UntilWithSync(
 		clusterVersionContext,
@@ -362,6 +375,7 @@ func waitForInitializedCluster(ctx context.Context, config *rest.Config) error {
 					return false, nil
 				}
 				if cov1helpers.IsStatusConditionTrue(cv.Status.Conditions, configv1.OperatorAvailable) {
+					timer.StopTimer("Cluster Operators")
 					return true, nil
 				}
 				if cov1helpers.IsStatusConditionTrue(cv.Status.Conditions, failing) {
@@ -413,6 +427,7 @@ func waitForConsole(ctx context.Context, config *rest.Config, directory string)
 	// no route in a row (to show we're still alive).
 	logDownsample := 15
 	silenceRemaining := logDownsample
+	timer.StartTimer("Console")
 	wait.Until(func() {
 		consoleRoutes, err := rc.RouteV1().Routes(consoleNamespace).List(metav1.ListOptions{})
 		if err == nil && len(consoleRoutes.Items) > 0 {
@@ -445,6 +460,7 @@ func waitForConsole(ctx context.Context, config *rest.Config, directory string)
 	if url == "" {
 		return url, errors.New("could not get openshift-console URL")
 	}
+	timer.StopTimer("Console")
 	return url, nil
 }
 
@@ -463,7 +479,7 @@ func logComplete(directory, consoleURL string) error {
 	logrus.Info("Install complete!")
 	logrus.Infof("To access the cluster as the system:admin user when using 'oc', run 'export KUBECONFIG=%s'", kubeconfig)
 	logrus.Infof("Access the OpenShift web-console here: %s", consoleURL)
-	logrus.Infof("Login to the console with user: kubeadmin, password: %s", pw)
+	logrus.Infof("Login to the console with user: %q, and password: %q", "kubeadmin", pw)
 	return nil
 }
 

cmd/openshift-install/destroy.go

@@ -19,6 +19,7 @@ import (
 	_ "github.com/openshift/installer/pkg/destroy/openstack"
 	_ "github.com/openshift/installer/pkg/destroy/ovirt"
 	_ "github.com/openshift/installer/pkg/destroy/vsphere"
+	timer "github.com/openshift/installer/pkg/metrics/timer"
 	"github.com/openshift/installer/pkg/terraform"
 )
 
@@ -54,6 +55,7 @@ func newDestroyClusterCmd() *cobra.Command {
 }
 
 func runDestroyCmd(directory string) error {
+	timer.StartTimer(timer.TotalTimeElapsed)
 	destroyer, err := destroy.New(logrus.StandardLogger(), directory)
 	if err != nil {
 		return errors.Wrap(err, "Failed while preparing to destroy cluster")
@@ -82,6 +84,8 @@ func runDestroyCmd(directory string) error {
 	if err != nil && !os.IsNotExist(err) {
 		return errors.Wrap(err, "failed to remove Terraform state")
 	}
+	timer.StopTimer(timer.TotalTimeElapsed)
+	timer.LogSummary()
 
 	return nil
 }
@@ -95,10 +99,13 @@ func newDestroyBootstrapCmd() *cobra.Command {
 			cleanup := setupFileHook(rootOpts.dir)
 			defer cleanup()
 
+			timer.StartTimer(timer.TotalTimeElapsed)
 			err := bootstrap.Destroy(rootOpts.dir)
 			if err != nil {
 				logrus.Fatal(err)
 			}
+			timer.StopTimer(timer.TotalTimeElapsed)
+			timer.LogSummary()
 		},
 	}
 }

cmd/openshift-install/gather.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"net"
 	"os"
 	"path/filepath"
@@ -20,6 +21,7 @@ import (
 
 	"github.com/openshift/installer/pkg/asset/installconfig"
 	assetstore "github.com/openshift/installer/pkg/asset/store"
+	"github.com/openshift/installer/pkg/asset/tls"
 	"github.com/openshift/installer/pkg/gather/ssh"
 	"github.com/openshift/installer/pkg/terraform"
 	gatheraws "github.com/openshift/installer/pkg/terraform/gather/aws"
@@ -85,18 +87,35 @@ func newGatherBootstrapCmd() *cobra.Command {
 }
 
 func runGatherBootstrapCmd(directory string) error {
-	tfStateFilePath := filepath.Join(directory, terraform.StateFileName)
-	_, err := os.Stat(tfStateFilePath)
-	if os.IsNotExist(err) {
-		return unSupportedPlatformGather(directory)
+	assetStore, err := assetstore.NewStore(directory)
+	if err != nil {
+		return errors.Wrap(err, "failed to create asset store")
+	}
+	// add the default bootstrap key pair to the sshKeys list
+	bootstrapSSHKeyPair := &tls.BootstrapSSHKeyPair{}
+	if err := assetStore.Fetch(bootstrapSSHKeyPair); err != nil {
+		return errors.Wrapf(err, "failed to fetch %s", bootstrapSSHKeyPair.Name())
 	}
+	tmpfile, err := ioutil.TempFile("", "bootstrap-ssh")
 	if err != nil {
 		return err
 	}
+	defer os.Remove(tmpfile.Name())
+	if _, err := tmpfile.Write(bootstrapSSHKeyPair.Private()); err != nil {
+		return err
+	}
+	if err := tmpfile.Close(); err != nil {
+		return err
+	}
+	gatherBootstrapOpts.sshKeys = append(gatherBootstrapOpts.sshKeys, tmpfile.Name())
 
-	assetStore, err := assetstore.NewStore(directory)
+	tfStateFilePath := filepath.Join(directory, terraform.StateFileName)
+	_, err = os.Stat(tfStateFilePath)
+	if os.IsNotExist(err) {
+		return unSupportedPlatformGather(directory)
+	}
 	if err != nil {
-		return errors.Wrap(err, "failed to create asset store")
+		return err
 	}
 
 	config := &installconfig.InstallConfig{}
@@ -136,7 +155,11 @@ func logGatherBootstrap(bootstrap string, port int, masters []string, directory
 	if err := ssh.PullFileTo(client, fmt.Sprintf("/home/core/log-bundle-%s.tar.gz", gatherID), file); err != nil {
 		return errors.Wrap(err, "failed to pull log file from remote")
 	}
-	logrus.Infof("Bootstrap gather logs captured here %q", file)
+	path, err := filepath.Abs(file)
+	if err != nil {
+		return errors.Wrap(err, "failed to stat log file")
+	}
+	logrus.Infof("Bootstrap gather logs captured here %q", path)
 	return nil
 }
 

cmd/openshift-install/main.go

@@ -54,6 +54,7 @@ func installerMain() {
 		newVersionCmd(),
 		newGraphCmd(),
 		newCompletionCmd(),
+		newMigrateCmd(),
 	} {
 		rootCmd.AddCommand(subCmd)
 	}

cmd/openshift-install/migrate.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"github.com/spf13/cobra"
+
+	azure "github.com/openshift/installer/cmd/openshift-install/migrate/azure"
+)
+
+func newMigrateCmd() *cobra.Command {
+	migrateCmd := &cobra.Command{
+		Use:   "migrate",
+		Short: "Do a migration",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return cmd.Help()
+		},
+	}
+
+	migrateCmd.AddCommand(azure.NewMigrateAzurePrivateDNSEligibleCmd())
+	migrateCmd.AddCommand(azure.NewMigrateAzurePrivateDNSMigrateCmd())
+
+	return migrateCmd
+}

cmd/openshift-install/migrate/azure/eligible.go

@@ -0,0 +1,23 @@
+package azure
+
+import (
+	"github.com/spf13/cobra"
+
+	azmigrate "github.com/openshift/installer/pkg/migrate/azure"
+)
+
+func runMigrateAzurePrivateDNSEligibleCmd(cmd *cobra.Command, args []string) error {
+	return azmigrate.Eligible()
+}
+
+// NewMigrateAzurePrivateDNSEligibleCmd adds the eligble command to openshift-install
+func NewMigrateAzurePrivateDNSEligibleCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "azure-privatedns-eligible",
+		Short: "Show legacy Azure zones that are eligible to be migrated",
+		Long:  "This will show legacy Azure private zones that can be migrated to new private zones.",
+		RunE:  runMigrateAzurePrivateDNSEligibleCmd,
+	}
+
+	return cmd
+}

cmd/openshift-install/migrate/azure/migrate.go

@@ -0,0 +1,53 @@
+package azure
+
+import (
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+
+	azmigrate "github.com/openshift/installer/pkg/migrate/azure"
+)
+
+var (
+	azureMigrateOpts struct {
+		zone              string
+		resourceGroup     string
+		virtualNetwork    string
+		vnetResourceGroup string
+		link              bool
+	}
+)
+
+func runMigrateAzurePrivateDNSMigrateCmd(cmd *cobra.Command, args []string) error {
+	if azureMigrateOpts.zone == "" {
+		return errors.New("zone is a required argument")
+	}
+	if azureMigrateOpts.resourceGroup == "" {
+		return errors.New("resource-group is a required argument")
+	}
+	if azureMigrateOpts.link == true && azureMigrateOpts.virtualNetwork == "" {
+		return errors.New("link requires virtual-network to be set")
+	}
+	if azureMigrateOpts.virtualNetwork != "" && azureMigrateOpts.vnetResourceGroup == "" {
+		return errors.New("virtual-network requires virtual-network-resource-group to be set")
+	}
+
+	return azmigrate.Migrate(azureMigrateOpts.resourceGroup, azureMigrateOpts.zone, azureMigrateOpts.virtualNetwork, azureMigrateOpts.vnetResourceGroup, azureMigrateOpts.link)
+}
+
+// NewMigrateAzurePrivateDNSMigrateCmd adds the migrate command to openshift-install
+func NewMigrateAzurePrivateDNSMigrateCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "azure-privatedns",
+		Short: "Migrate a legacy Azure zone",
+		Long:  "This will migrate a legacy Azure private zone to a new style private zone.",
+		RunE:  runMigrateAzurePrivateDNSMigrateCmd,
+	}
+
+	cmd.PersistentFlags().StringVar(&azureMigrateOpts.zone, "zone", "", "The zone to migrate")
+	cmd.PersistentFlags().StringVar(&azureMigrateOpts.resourceGroup, "resource-group", "", "The resource group of the zone")
+	cmd.PersistentFlags().StringVar(&azureMigrateOpts.virtualNetwork, "virtual-network", "", "The virtual network to create the private zone in")
+	cmd.PersistentFlags().StringVar(&azureMigrateOpts.vnetResourceGroup, "virtual-network-resource-group", "", "The resource group the virtual network is in")
+	cmd.PersistentFlags().BoolVar(&azureMigrateOpts.link, "link", false, "Link the newly created private zone to the virtual network")
+
+	return cmd
+}

cmd/openshift-install/waitfor.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"path/filepath"
 
+	timer "github.com/openshift/installer/pkg/metrics/timer"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -34,6 +35,7 @@ func newWaitForBootstrapCompleteCmd() *cobra.Command {
 		Short: "Wait until cluster bootstrapping has completed",
 		Args:  cobra.ExactArgs(0),
 		Run: func(_ *cobra.Command, _ []string) {
+			timer.StartTimer(timer.TotalTimeElapsed)
 			ctx := context.Background()
 
 			cleanup := setupFileHook(rootOpts.dir)
@@ -43,7 +45,7 @@ func newWaitForBootstrapCompleteCmd() *cobra.Command {
 			if err != nil {
 				logrus.Fatal(errors.Wrap(err, "loading kubeconfig"))
 			}
-
+			timer.StartTimer("Bootstrap Complete")
 			err = waitForBootstrapComplete(ctx, config, rootOpts.dir)
 			if err != nil {
 				if err2 := logClusterOperatorConditions(ctx, config); err2 != nil {
@@ -56,6 +58,9 @@ func newWaitForBootstrapCompleteCmd() *cobra.Command {
 			}
 
 			logrus.Info("It is now safe to remove the bootstrap resources")
+			timer.StopTimer("Bootstrap Complete")
+			timer.StopTimer(timer.TotalTimeElapsed)
+			timer.LogSummary()
 		},
 	}
 }
@@ -66,6 +71,7 @@ func newWaitForInstallCompleteCmd() *cobra.Command {
 		Short: "Wait until the cluster is ready",
 		Args:  cobra.ExactArgs(0),
 		Run: func(cmd *cobra.Command, args []string) {
+			timer.StartTimer(timer.TotalTimeElapsed)
 			ctx := context.Background()
 
 			cleanup := setupFileHook(rootOpts.dir)
@@ -84,6 +90,8 @@ func newWaitForInstallCompleteCmd() *cobra.Command {
 
 				logrus.Fatal(err)
 			}
+			timer.StopTimer(timer.TotalTimeElapsed)
+			timer.LogSummary()
 		},
 	}
 }