Merge branch 'version/0-36-0-RC1'

# Conflicts:
#	internal/runbits/requirements/requirements.go

Author: Naatan

activestate.generators.yaml

@@ -88,8 +88,8 @@ scripts:
     language: bash
     description: Generates graph server and client files
     value: |
-      type gqlgen &>/dev/null || go install github.com/99designs/gqlgen@v0.13.0
-      cd ./cmd/state-svc && gqlgen
+      go install github.com/99designs/gqlgen@v0.17.24
+      cd ./cmd/state-svc && gqlgen --verbose
   - name: generate-test-update
     language: bash
     standalone: true

changelog.md

@@ -6,6 +6,65 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres
 to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+### 0.36.0
+
+### Added 
+
+- All commands have been updated to proactively mention project and runtime 
+  information, making it easier to understand what is going on and how to configure
+  your tooling.
+- State Tool will now give you a heads-up if the organization you're accessing
+  has gone over its runtime limit.
+- State Tool will now configure itself for all supported shells on your system, 
+  rather than just the currently active shell.
+- Better support for Bash on Windows. 
+
+### Changed
+
+- Significantly improved the performance of runtime executors.
+- `state revert` now reverts "a" commit, rather than reverting "to" a commit. This
+  is meant to bring the user-experience in line with that of git.
+- Bash on macOS is no longer supported as a shell. This is due to the fact that
+  macOS has deprecated the use of bash in favor of zsh. Using bash should still
+  work, but you will receive warnings, and it may stop working in the future.
+- The state-svc is now installed as an App on macOS. Solving the issue of macOS 
+  referring to it as an sh script which isn't very useful for end-users.
+- Progress indication for runtime installations will now show build progress for
+  all artifacts, even if they are cached.
+- Reorganized the `--help` output.
+
+### Fixed
+
+- Fixed error message received when running State Tool without the `HOME` env var
+  not being indicative of that root cause.
+- Fixed progress count being off when installing runtimes.
+- Fixed progress sometimes hangs or panics while installing runtimes.
+- Fixed `state languages install` and `state platforms add` should not modify the 
+  remote project (that's what `state push` is for).
+- Fixed `state import` panics when ran outside of a project folder.
+- Fixed malformed error message when `state clean uninstall` fails.
+- Fixed `state push` creating the remote project even if the user told it not to.
+- Fixed unstable subcommands not showing a warning explaining that they are unstable.
+- Fixed `state shell` giving a misleading error when no default project is configured.
+- Fixed `state update` showing redundant output.
+- Fixed `state import --non-interactive` cancelling out of import rather than 
+  continuing without prompting.
+- Fixed `state revert <commit ID>` should not work on a commit that doesn't exist in
+  the history.
+- Fixed `state clean cache` not giving a success or abort messaging.
+- Fixed `state export private-key` giving an uninformative error message when 
+  improperly authenticated.
+- Fixed `state show` not working with commits that haven't been pushed to the platform.
+
+### Removed
+
+- Removed the `--set-version` flag from `state update`. Instead, you can run the
+  installation script with the `-v` flag.
+- The experimental tray tool (ActiveState Desktop) has been removed. It will be 
+  making a reappearance in the future.
+- The `--namespace` flag has been removed from `state history`. To inspect projects
+  without checking them out you can use the website.
+
 ### 0.35.0
 
 We are introducing a set of new environment management commands that will

cmd/state-svc/internal/resolver/resolver.go

@@ -2,6 +2,7 @@ package resolver
 
 import (
 	"encoding/json"
+	"github.com/ActiveState/cli/cmd/state-svc/internal/rtusage"
 	"sort"
 	"time"
 
@@ -30,6 +31,8 @@ type Resolver struct {
 	cfg            *config.Instance
 	depPoller      *poller.Poller
 	updatePoller   *poller.Poller
+	authPoller     *poller.Poller
+	usageChecker   *rtusage.Checker
 	projectIDCache *projectcache.ID
 	an             *sync.Client
 	anForClient    *sync.Client // Use separate client for events sent through service so we don't contaminate one with the other
@@ -49,11 +52,22 @@ func New(cfg *config.Instance, an *sync.Client, auth *authentication.Auth) (*Res
 		return upchecker.Check()
 	})
 
+	pollAuth := poller.New(1*time.Minute, func() (interface{}, error) {
+		if auth.SyncRequired() {
+			return nil, auth.Sync()
+		}
+		return nil, nil
+	})
+
+	usageChecker := rtusage.NewChecker(cfg, auth)
+
 	anForClient := sync.New(cfg, auth)
 	return &Resolver{
 		cfg,
 		pollDep,
 		pollUpdate,
+		pollAuth,
+		usageChecker,
 		projectcache.NewID(),
 		an,
 		anForClient,
@@ -64,6 +78,7 @@ func New(cfg *config.Instance, an *sync.Client, auth *authentication.Auth) (*Res
 func (r *Resolver) Close() error {
 	r.depPoller.Close()
 	r.updatePoller.Close()
+	r.authPoller.Close()
 	r.anForClient.Close()
 	return r.rtwatch.Close()
 }
@@ -158,16 +173,34 @@ func (r *Resolver) AnalyticsEvent(_ context.Context, category, action string, _l
 	return &graph.AnalyticsEventResponse{Sent: true}, nil
 }
 
-func (r *Resolver) RuntimeUsage(ctx context.Context, pid int, exec string, dimensionsJSON string) (*graph.RuntimeUsageResponse, error) {
+func (r *Resolver) ReportRuntimeUsage(_ context.Context, pid int, exec string, dimensionsJSON string) (*graph.ReportRuntimeUsageResponse, error) {
 	logging.Debug("Runtime usage resolver: %d - %s", pid, exec)
 	var dims *dimensions.Values
 	if err := json.Unmarshal([]byte(dimensionsJSON), &dims); err != nil {
-		return &graph.RuntimeUsageResponse{Received: false}, errs.Wrap(err, "Could not unmarshal")
+		return &graph.ReportRuntimeUsageResponse{Received: false}, errs.Wrap(err, "Could not unmarshal")
 	}
 
 	r.rtwatch.Watch(pid, exec, dims)
 
-	return &graph.RuntimeUsageResponse{Received: true}, nil
+	return &graph.ReportRuntimeUsageResponse{Received: true}, nil
+}
+
+func (r *Resolver) CheckRuntimeUsage(_ context.Context, organizationName string) (*graph.CheckRuntimeUsageResponse, error) {
+	logging.Debug("CheckRuntimeUsage resolver")
+
+	usage, err := r.usageChecker.Check(organizationName)
+	if err != nil {
+		return nil, errs.Wrap(err, "Could not check runtime usage: %s", errs.JoinMessage(err))
+	}
+
+	result := &graph.CheckRuntimeUsageResponse{
+		Limit: int(usage.LimitDynamicRuntimes),
+		Usage: int(usage.ActiveDynamicRuntimes),
+	}
+
+	logging.Debug("Returning %v, based on %v", result, usage)
+
+	return result, nil
 }
 
 func (r *Resolver) CheckDeprecation(ctx context.Context) (*graph.DeprecationInfo, error) {

cmd/state-svc/internal/rtusage/rtusage.go

@@ -0,0 +1,80 @@
+package rtusage
+
+import (
+	"time"
+
+	"github.com/patrickmn/go-cache"
+
+	"github.com/ActiveState/cli/internal/errs"
+	"github.com/ActiveState/cli/internal/logging"
+	"github.com/ActiveState/cli/pkg/platform/api/graphql"
+	"github.com/ActiveState/cli/pkg/platform/api/graphql/model"
+	"github.com/ActiveState/cli/pkg/platform/api/graphql/request"
+	"github.com/ActiveState/cli/pkg/platform/authentication"
+)
+
+const cacheKey = "runtime-usage-"
+
+// Checker is the struct that we use to do checks with
+type Checker struct {
+	config configurable
+	cache  *cache.Cache
+	auth   *authentication.Auth
+}
+
+// configurable defines the configuration function used by the functions in this package
+type configurable interface {
+	ConfigPath() string
+	GetTime(key string) time.Time
+	Set(key string, value interface{}) error
+	Close() error
+}
+
+// NewChecker returns a new instance of the Checker struct
+func NewChecker(configuration configurable, auth *authentication.Auth) *Checker {
+	checker := &Checker{
+		configuration,
+		cache.New(1*time.Hour, 1*time.Hour),
+		auth,
+	}
+
+	return checker
+}
+
+// Check will check the runtime usage for the given organization, it may return a cached result
+func (c *Checker) Check(organizationName string) (*model.RuntimeUsage, error) {
+	if !c.auth.Authenticated() {
+		// Usage information can only be given to authenticated users, and the API doesn't support authentication errors
+		// so we just don't even attempt it if not authenticated.
+		return nil, nil
+	}
+
+	if cached, ok := c.cache.Get(cacheKey + organizationName); ok {
+		return cached.(*model.RuntimeUsage), nil
+	}
+
+	client := graphql.New()
+
+	orgsResponse := model.Organizations{}
+	if err := client.Run(request.OrganizationsByName(organizationName), &orgsResponse); err != nil {
+		return nil, errs.Wrap(err, "Could not fetch organization: %s", organizationName)
+	}
+	if len(orgsResponse.Organizations) == 0 {
+		return nil, errs.New("Could not find organization: %s", organizationName)
+	}
+	org := orgsResponse.Organizations[0]
+
+	usageResponse := model.RuntimeUsageResponse{}
+	if err := client.Run(request.RuntimeUsage(org.ID), &usageResponse); err != nil {
+		return nil, errs.Wrap(err, "Could not fetch runtime usage information")
+	}
+
+	if len(usageResponse.Usage) == 0 {
+		logging.Debug("No runtime usage information found for organization: %s", organizationName)
+		return nil, nil
+	}
+
+	c.cache.Set(cacheKey+organizationName, &usageResponse.Usage[0], 0)
+
+	return &usageResponse.Usage[0], nil
+}