refactor(provider): rename ProInstance to PlatformInstance

cmd/pro/cluster/add.go

@@ -425,21 +425,21 @@ func ensureHost(devsyConfig *config.Config, host string) (string, error) {
 		return host, nil
 	}
 
-	proInstances, err := workspace.ListPlatformInstances(devsyConfig)
+	platformInstances, err := workspace.ListPlatformInstances(devsyConfig)
 	if err != nil {
-		return "", fmt.Errorf("list pro instances: %w", err)
+		return "", fmt.Errorf("list platform instances: %w", err)
 	}
 	options := []string{}
-	for _, pro := range proInstances {
+	for _, pro := range platformInstances {
 		options = append(options, pro.Host)
 	}
 	h, err := log.QuestionDefault(&survey.QuestionOptions{
-		Question:     "Select Pro instance to connect your cluster to",
+		Question:     "Select Platform instance to connect your cluster to",
 		Options:      options,
 		DefaultValue: options[0],
 	})
 	if err != nil {
-		return "", fmt.Errorf("select pro instance: %w", err)
+		return "", fmt.Errorf("select platform instance: %w", err)
 	}
 
 	return h, nil

cmd/pro/completion/suggestions.go

@@ -21,14 +21,14 @@ func GetPlatformHostSuggestions(
 		return nil, cobra.ShellCompDirectiveError
 	}
 
-	proInstances, err := workspace.ListPlatformInstances(devsyConfig)
+	platformInstances, err := workspace.ListPlatformInstances(devsyConfig)
 	if err != nil {
 		return nil, cobra.ShellCompDirectiveError
 	}
 
 	var suggestions []string
 
-	for _, instance := range proInstances {
+	for _, instance := range platformInstances {
 		if strings.HasPrefix(instance.Host, toComplete) {
 			suggestions = append(suggestions, instance.Host)
 		}

cmd/pro/list.go

@@ -48,7 +48,7 @@ func NewListCmd(flags *proflags.GlobalFlags) *cobra.Command {
 			&cmd.Login,
 			names.Login,
 			false,
-			"Check if the user is logged into the pro instance",
+			"Check if the user is logged into the platform instance",
 		),
 	)
 	return listCmd
@@ -61,7 +61,7 @@ func (cmd *ListCmd) Run(ctx context.Context) error {
 		return err
 	}
 
-	proInstances, err := workspace.ListPlatformInstances(devsyConfig)
+	platformInstances, err := workspace.ListPlatformInstances(devsyConfig)
 	if err != nil {
 		return err
 	}
@@ -72,9 +72,9 @@ func (cmd *ListCmd) Run(ctx context.Context) error {
 	}
 	switch mode {
 	case output.ModePlain:
-		cmd.printPlain(ctx, devsyConfig, proInstances)
+		cmd.printPlain(ctx, devsyConfig, platformInstances)
 	case output.ModeJSON:
-		return cmd.printJSON(ctx, devsyConfig, proInstances)
+		return cmd.printJSON(ctx, devsyConfig, platformInstances)
 	}
 
 	return nil
@@ -83,17 +83,17 @@ func (cmd *ListCmd) Run(ctx context.Context) error {
 func (cmd *ListCmd) printPlain(
 	ctx context.Context,
 	devsyConfig *config.Config,
-	proInstances []*provider.ProInstance,
+	platformInstances []*provider.PlatformInstance,
 ) {
 	tableEntries := [][]string{}
-	for _, proInstance := range proInstances {
+	for _, platformInstance := range platformInstances {
 		entry := []string{
-			proInstance.Host,
-			proInstance.Provider,
-			time.Since(proInstance.CreationTimestamp.Time).Round(1 * time.Second).String(),
+			platformInstance.Host,
+			platformInstance.Provider,
+			time.Since(platformInstance.CreationTimestamp.Time).Round(1 * time.Second).String(),
 		}
 		if cmd.Login {
-			err := checkLogin(ctx, devsyConfig, proInstance)
+			err := checkLogin(ctx, devsyConfig, platformInstance)
 			entry = append(entry, fmt.Sprintf("%t", err == nil))
 		}
 
@@ -118,17 +118,17 @@ func (cmd *ListCmd) printPlain(
 func (cmd *ListCmd) printJSON(
 	ctx context.Context,
 	devsyConfig *config.Config,
-	proInstances []*provider.ProInstance,
+	platformInstances []*provider.PlatformInstance,
 ) error {
 	tableEntries := []*proTableEntry{}
-	for _, proInstance := range proInstances {
+	for _, platformInstance := range platformInstances {
 		entry := &proTableEntry{
-			ProInstance:  proInstance,
-			Context:      devsyConfig.DefaultContext,
-			Capabilities: getCapabilities(devsyConfig, proInstance),
+			PlatformInstance: platformInstance,
+			Context:          devsyConfig.DefaultContext,
+			Capabilities:     getCapabilities(devsyConfig, platformInstance),
 		}
 		if cmd.Login {
-			err := checkLogin(ctx, devsyConfig, proInstance)
+			err := checkLogin(ctx, devsyConfig, platformInstance)
 			isAuthenticated := err == nil
 			entry.Authenticated = &isAuthenticated
 		}
@@ -149,7 +149,7 @@ func (cmd *ListCmd) printJSON(
 }
 
 type proTableEntry struct {
-	*provider.ProInstance
+	*provider.PlatformInstance
 
 	Authenticated *bool        `json:"authenticated,omitempty"`
 	Context       string       `json:"context,omitempty"`
@@ -167,30 +167,30 @@ var (
 func checkLogin(
 	ctx context.Context,
 	devsyConfig *config.Config,
-	proInstance *provider.ProInstance,
+	platformInstance *provider.PlatformInstance,
 ) error {
-	// for every pro instance, check auth status by calling login
+	// for every platform instance, check auth status by calling login
 	if err := login(
 		ctx,
 		devsyConfig,
-		proInstance.Host,
-		proInstance.Provider,
+		platformInstance.Host,
+		platformInstance.Provider,
 		"",
 		true,
 		false,
 	); err != nil {
-		return fmt.Errorf("not logged into %s", proInstance.Host)
+		return fmt.Errorf("not logged into %s", platformInstance.Host)
 	}
 
 	return nil
 }
 
 func getCapabilities(
 	devsyConfig *config.Config,
-	proInstance *provider.ProInstance,
+	platformInstance *provider.PlatformInstance,
 ) []Capability {
 	capabilities := []Capability{}
-	provider, err := workspace.FindProvider(devsyConfig, proInstance.Provider)
+	provider, err := workspace.FindProvider(devsyConfig, platformInstance.Provider)
 	if err != nil {
 		return capabilities
 	}

cmd/pro/login.go

@@ -125,7 +125,10 @@ func (cmd *LoginCmd) prepareProvider(ctx context.Context, fullURL string) (*conf
 	if err != nil {
 		return nil, fmt.Errorf("invalid url %s: %w", fullURL, err)
 	}
-	loginLock, err := provider.GetProInstanceOperationLock(initial.DefaultContext, parsedURL.Host)
+	loginLock, err := provider.GetPlatformInstanceOperationLock(
+		initial.DefaultContext,
+		parsedURL.Host,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("get Pro login lock: %w", err)
 	}
@@ -187,7 +190,7 @@ func (cmd *LoginCmd) normalizeURL(fullURL string) (string, error) {
 func (cmd *LoginCmd) resolveInstance(
 	fullURL string,
 	contextName string,
-) (*config.Config, *provider.ProInstance, error) {
+) (*config.Config, *provider.PlatformInstance, error) {
 	parsedURL, err := url.Parse(fullURL)
 	if err != nil {
 		return nil, nil, fmt.Errorf("invalid url %s: %w", fullURL, err)
@@ -199,12 +202,12 @@ func (cmd *LoginCmd) resolveInstance(
 		return nil, nil, err
 	}
 
-	proInstances, err := workspace.ListPlatformInstances(devsyConfig)
+	platformInstances, err := workspace.ListPlatformInstances(devsyConfig)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	currentInstance, err := findInstance(proInstances, host)
+	currentInstance, err := findInstance(platformInstances, host)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -220,15 +223,18 @@ func (cmd *LoginCmd) resolveInstance(
 	return devsyConfig, nil, nil
 }
 
-func findInstance(instances []*provider.ProInstance, host string) (*provider.ProInstance, error) {
-	instanceID := provider.ToProInstanceID(host)
+func findInstance(
+	instances []*provider.PlatformInstance,
+	host string,
+) (*provider.PlatformInstance, error) {
+	instanceID := provider.ToPlatformInstanceID(host)
 	for _, inst := range instances {
 		if strings.EqualFold(inst.Host, host) {
 			return inst, nil
 		}
-		if provider.ToProInstanceID(inst.Host) == instanceID {
+		if provider.ToPlatformInstanceID(inst.Host) == instanceID {
 			return nil, fmt.Errorf(
-				"pro instance host %q conflicts with existing host %q after normalization",
+				"platform instance host %q conflicts with existing host %q after normalization",
 				host,
 				inst.Host,
 			)
@@ -241,15 +247,15 @@ func (cmd *LoginCmd) resolveNewProviderName(devsyConfig *config.Config, host str
 	if cmd.Provider == "" {
 		cmd.Provider = config.ProReleaseName
 	}
-	cmd.Provider = provider.ToProInstanceID(cmd.Provider)
+	cmd.Provider = provider.ToPlatformInstanceID(cmd.Provider)
 
 	providers, err := workspace.LoadAllProviders(devsyConfig)
 	if err != nil {
 		return fmt.Errorf("load providers: %w", err)
 	}
 
 	if providers[cmd.Provider] != nil {
-		cmd.Provider = provider.ToProInstanceID(config.BinaryName + "-" + host)
+		cmd.Provider = provider.ToPlatformInstanceID(config.BinaryName + "-" + host)
 		if providers[cmd.Provider] != nil {
 			return fmt.Errorf(
 				"provider %s already exists, choose a different name via --provider",
@@ -264,15 +270,15 @@ func (cmd *LoginCmd) resolveNewProviderName(devsyConfig *config.Config, host str
 func (cmd *LoginCmd) ensureProvider(
 	ctx context.Context,
 	devsyConfig *config.Config,
-	currentInstance *provider.ProInstance,
+	currentInstance *provider.PlatformInstance,
 	fullURL string,
 ) (*config.Config, error) {
 	if currentInstance != nil {
 		return devsyConfig, nil
 	}
 
 	parsedURL, _ := url.Parse(fullURL)
-	instance := &provider.ProInstance{
+	instance := &provider.PlatformInstance{
 		Provider:          cmd.Provider,
 		Host:              parsedURL.Host,
 		CreationTimestamp: types.Now(),
@@ -282,7 +288,10 @@ func (cmd *LoginCmd) ensureProvider(
 		return nil, err
 	}
 
-	if err := provider.SaveProInstanceConfig(devsyConfig.DefaultContext, instance); err != nil {
+	if err := provider.SavePlatformInstanceConfig(
+		devsyConfig.DefaultContext,
+		instance,
+	); err != nil {
 		return nil, err
 	}
 

cmd/pro/login_test.go

@@ -40,7 +40,7 @@ func (s *loginSuite) TearDownTest() {
 }
 
 func (s *loginSuite) TestConcurrentLoginFindsCreatedInstance() {
-	lock, err := provider.GetProInstanceOperationLock("default", "pro.example")
+	lock, err := provider.GetPlatformInstanceOperationLock("default", "pro.example")
 	s.Require().NoError(err)
 	s.Require().NoError(lock.Lock())
 	s.T().Cleanup(func() { _ = lock.Unlock() })
@@ -57,7 +57,7 @@ func (s *loginSuite) TestConcurrentLoginFindsCreatedInstance() {
 	case <-time.After(50 * time.Millisecond):
 	}
 
-	s.Require().NoError(provider.SaveProInstanceConfig("default", &provider.ProInstance{
+	s.Require().NoError(provider.SavePlatformInstanceConfig("default", &provider.PlatformInstance{
 		Provider: testProProviderName,
 		Host:     "pro.example",
 	}))
@@ -67,11 +67,11 @@ func (s *loginSuite) TestConcurrentLoginFindsCreatedInstance() {
 }
 
 func (s *loginSuite) TestDifferentHostDoesNotWaitForLoginLock() {
-	lock, err := provider.GetProInstanceOperationLock("default", "first.example")
+	lock, err := provider.GetPlatformInstanceOperationLock("default", "first.example")
 	s.Require().NoError(err)
 	s.Require().NoError(lock.Lock())
 	defer func() { _ = lock.Unlock() }()
-	s.Require().NoError(provider.SaveProInstanceConfig("default", &provider.ProInstance{
+	s.Require().NoError(provider.SavePlatformInstanceConfig("default", &provider.PlatformInstance{
 		Provider: "other",
 		Host:     "second.example",
 	}))
@@ -92,7 +92,7 @@ func (s *loginSuite) TestDifferentHostDoesNotWaitForLoginLock() {
 }
 
 func (s *loginSuite) TestHostLockDoesNotConflictWithProviderLock() {
-	hostLock, err := provider.GetProInstanceOperationLock("default", "pro.example")
+	hostLock, err := provider.GetPlatformInstanceOperationLock("default", "pro.example")
 	s.Require().NoError(err)
 	providerLock, err := provider.GetProviderOperationLock("default", "pro-login")
 	s.Require().NoError(err)
@@ -105,15 +105,15 @@ func (s *loginSuite) TestHostLockDoesNotConflictWithProviderLock() {
 }
 
 func (s *loginSuite) TestEquivalentHostsShareLock() {
-	first, err := provider.GetProInstanceOperationLock("default", "Foo.Example.com")
+	first, err := provider.GetPlatformInstanceOperationLock("default", "Foo.Example.com")
 	s.Require().NoError(err)
-	second, err := provider.GetProInstanceOperationLock("default", "foo.example.com")
+	second, err := provider.GetPlatformInstanceOperationLock("default", "foo.example.com")
 	s.Require().NoError(err)
 	s.Equal(first.Path(), second.Path())
 }
 
 func (s *loginSuite) TestEquivalentHostFindsExistingInstance() {
-	s.Require().NoError(provider.SaveProInstanceConfig("default", &provider.ProInstance{
+	s.Require().NoError(provider.SavePlatformInstanceConfig("default", &provider.PlatformInstance{
 		Provider: testProProviderName,
 		Host:     "Foo.Example.com",
 	}))
@@ -124,14 +124,14 @@ func (s *loginSuite) TestEquivalentHostFindsExistingInstance() {
 }
 
 func (s *loginSuite) TestDistinctHostsWithSameInstanceIDAreRejected() {
-	s.Require().NoError(provider.SaveProInstanceConfig("default", &provider.ProInstance{
+	s.Require().NoError(provider.SavePlatformInstanceConfig("default", &provider.PlatformInstance{
 		Provider: testProProviderName,
 		Host:     "foo.example.com",
 	}))
 	cmd := &LoginCmd{GlobalFlags: proflags.GlobalFlags{GlobalFlags: &rootflags.GlobalFlags{}}}
 	_, err := cmd.prepareProvider(context.Background(), "https://foo-example.com")
 	s.Require().ErrorContains(err, "conflicts with existing host")
-	stored, err := provider.LoadProInstanceConfig("default", "foo.example.com")
+	stored, err := provider.LoadPlatformInstanceConfig("default", "foo.example.com")
 	s.Require().NoError(err)
 	s.Equal("foo.example.com", stored.Host)
 }