Merge pull request #2329 from ActiveState/DX-1490

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

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,72 @@
+package rtusage
+
+import (
+	"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"
+	"github.com/patrickmn/go-cache"
+	"time"
+)
+
+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 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
+}