provisionerd/runner: use Options struct

ammario · ammario · commit 208b9eb84f5e · 2022-11-10T23:01:41.000Z
diff --git a/docs/admin/quotas.md b/docs/admin/quotas.md
@@ -1,15 +1,16 @@
 # Quotas
 
-Coder Enterprise admins may define deployment-level quotas to protect against
-Denial-of-Service, control costs, and ensure equitable access to cloud resources.
+Coder Enterprise admins may define deployment-level quotas to control costs
+and ensure equitable access to cloud resources.
 
-The quota is enabled by either the `CODER_USER_WORKSPACE_QUOTA`
-environment variable or the `--user-workspace-quota` flag. For example,
-you may limit each user in a deployment to 5 workspaces like so:
+Quotas are available to any license with support for [Groups](./groups.md).
 
-```bash
-coder server --user-workspace-quota=5
-```
+Templates describe their quota cost through [`resource_metadata`](../templates/resource-metadata.md).
+
+Coder checks for Quota availability on workspace create, start, and stop
+operations.
+
+When a user creates a workspace, the `resource_metadata.cost` fields are summed up,
 
 Then, when users create workspaces they would see:
 
diff --git a/provisionerd/provisionerd.go b/provisionerd/provisionerd.go
@@ -322,16 +322,17 @@ func (p *Server) acquireJob(ctx context.Context) {
 	p.activeJob = runner.New(
 		ctx,
 		job,
-		p,
-		p.opts.Logger,
-		p.opts.Filesystem,
-		p.opts.WorkDirectory,
-		provisioner,
-		p.opts.UpdateInterval,
-		p.opts.ForceCancelInterval,
-		p.opts.LogBufferInterval,
-		p.tracer,
-		p.opts.Metrics.Runner,
+		runner.Options{
+			Logger:              p.opts.Logger,
+			Filesystem:          p.opts.Filesystem,
+			WorkDirectory:       p.opts.WorkDirectory,
+			Provisioner:         provisioner,
+			UpdateInterval:      p.opts.UpdateInterval,
+			ForceCancelInterval: p.opts.ForceCancelInterval,
+			LogDebounceInterval: p.opts.LogBufferInterval,
+			Tracer:              p.tracer,
+			Metrics:             p.opts.Metrics.Runner,
+		},
 	)
 
 	go p.activeJob.Run()
diff --git a/provisionerd/runner/runner.go b/provisionerd/runner/runner.go
@@ -86,19 +86,23 @@ type JobUpdater interface {
 	CompleteJob(ctx context.Context, in *proto.CompletedJob) error
 }
 
+type Options struct {
+	Updater             JobUpdater
+	Logger              slog.Logger
+	Filesystem          afero.Fs
+	WorkDirectory       string
+	Provisioner         sdkproto.DRPCProvisionerClient
+	UpdateInterval      time.Duration
+	ForceCancelInterval time.Duration
+	LogDebounceInterval time.Duration
+	Tracer              trace.Tracer
+	Metrics             Metrics
+}
+
 func New(
 	ctx context.Context,
 	job *proto.AcquiredJob,
-	updater JobUpdater,
-	logger slog.Logger,
-	filesystem afero.Fs,
-	workDirectory string,
-	provisioner sdkproto.DRPCProvisionerClient,
-	updateInterval time.Duration,
-	forceCancelInterval time.Duration,
-	logDebounceInterval time.Duration,
-	tracer trace.Tracer,
-	metrics Metrics,
+	opts Options,
 ) *Runner {
 	m := new(sync.Mutex)
 
@@ -107,17 +111,17 @@ func New(
 	gracefulContext, cancelFunc := context.WithCancel(forceStopContext)
 
 	return &Runner{
-		tracer:              tracer,
-		metrics:             metrics,
+		tracer:              opts.Tracer,
+		metrics:             opts.Metrics,
 		job:                 job,
-		sender:              updater,
-		logger:              logger.With(slog.F("job_id", job.JobId)),
-		filesystem:          filesystem,
-		workDirectory:       workDirectory,
-		provisioner:         provisioner,
-		updateInterval:      updateInterval,
-		forceCancelInterval: forceCancelInterval,
-		logBufferInterval:   logDebounceInterval,
+		sender:              opts.Updater,
+		logger:              opts.Logger.With(slog.F("job_id", job.JobId)),
+		filesystem:          opts.Filesystem,
+		workDirectory:       opts.WorkDirectory,
+		provisioner:         opts.Provisioner,
+		updateInterval:      opts.UpdateInterval,
+		forceCancelInterval: opts.ForceCancelInterval,
+		logBufferInterval:   opts.LogDebounceInterval,
 		queuedLogs:          make([]*proto.Log, 0),
 		mutex:               m,
 		cond:                sync.NewCond(m),
