From 742938b00222c7ad57ad11eb24850d9202c2503d Mon Sep 17 00:00:00 2001
From: Mitchell Riedstra <mitch@riedstra.dev>
Date: Wed, 4 Aug 2021 20:06:07 -0400
Subject: Pretty large structural changes. Non-building development snapshot

---
 steam/status.go | 200 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 steam/status.go

(limited to 'steam/status.go')

diff --git a/steam/status.go b/steam/status.go
new file mode 100644
index 0000000..12f5e3b
--- /dev/null
+++ b/steam/status.go
@@ -0,0 +1,200 @@
+package steam
+
+import (
+	"sync"
+	"time"
+)
+
+// JobStatus provides specific information about an individual job
+type Job struct {
+	action  string
+	target  *Game
+	running bool
+	start   *time.Time
+	errors  []error
+
+	// If applicablle
+	size        *int64
+	transferred *int64
+	eta         *time.Duration
+
+	m sync.Mutex
+}
+
+// Action is a short string describing the action, i.e. "packaging", "deleting"
+func (j *Job) Action() string {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.action
+}
+
+// Target returns the game that is the target of the action
+func (j *Job) Target() *Game {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.target
+}
+
+// IsRunning returns true if the job is currently running, otherwise false
+func (j *Job) IsRunning() bool {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.running
+}
+
+// StartTime returns the time in which the job started
+func (j *Job) StartTime() *time.Time {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.start
+}
+
+func (j *Job) Errors() []error {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.errors
+}
+
+// newJob sets up a job of action for the target Game
+func newJob(action string, target *Game) *Job {
+	t := time.Now()
+	return &Job{
+		action:  action,
+		target:  target,
+		running: true,
+		start:   &t,
+	}
+}
+
+func (j *Job) setSize(size int64) {
+	j.m.Lock()
+	defer j.m.Unlock()
+	j.size = &size
+}
+
+// GetSize returns the size set if applicable for the operation
+func (j *Job) GetSize() *int64 {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.size
+}
+
+func (j *Job) setTransferred(transferred int64) {
+	j.m.Lock()
+	defer j.m.Unlock()
+	j.transferred = &transferred
+}
+
+// GetTransferred returns the transferred set if applicable for the operation
+func (j *Job) GetTransferred() *int64 {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.transferred
+}
+
+// setETA sets the eta to the speicifed duration
+func (j *Job) setETA(d time.Duration) {
+	j.m.Lock()
+	defer j.m.Unlock()
+	j.eta = &d
+}
+
+// GetETA returns the ETA to completion as a *time.Duration. nil represents
+// when
+func (j *Job) GetETA() *time.Duration {
+	j.m.Lock()
+	defer j.m.Unlock()
+	return j.eta
+}
+
+// done sets running to false
+func (j *Job) done() {
+	j.m.Lock()
+	defer j.m.Unlock()
+	j.running = false
+}
+
+// addError appends an error to the internal slice of errors
+func (j *Job) addError(err error) {
+	j.m.Lock()
+	defer j.m.Unlock()
+	j.errors = append(j.errors, err)
+}
+
+// Jobs is by the Library to determine whether or not we currently have any
+// jobs running on this library, as well as to give some history as to
+// what jobs have been run previously
+type Jobs struct {
+	running  []*Job
+	previous []*Job
+
+	m sync.Mutex
+}
+
+func (jobs *Jobs) scan() {
+	jobs.m.Lock()
+	defer jobs.m.Unlock()
+	running := []*Job{}
+	notrunning := []*Job{}
+
+	for _, job := range jobs.running {
+		if job == nil {
+			continue
+		}
+
+		if job.IsRunning() == true {
+			running = append(running, job)
+		} else {
+			notrunning = append(notrunning, job)
+		}
+	}
+
+	if len(notrunning) > 0 {
+		jobs.previous = append(jobs.previous, notrunning...)
+	}
+
+	jobs.running = running
+}
+
+// Running returns true if any job is currently running, otherwise false
+func (jobs *Jobs) Running() bool {
+	jobs.scan()
+	jobs.m.Lock()
+	defer jobs.m.Unlock()
+	if len(jobs.running) == 0 {
+		return false
+	}
+	return true
+}
+
+// GetJobs returns all of the jobs regardless of their state
+func (jobs *Jobs) GetJobs() []*Job {
+	jobs.scan()
+	jobs.m.Lock()
+	defer jobs.m.Unlock()
+	return append(jobs.running, jobs.previous...)
+}
+
+// GetRunningJobs returns all of the running jobs
+func (jobs *Jobs) GetRunningJobs() []*Job {
+	jobs.scan()
+	jobs.m.Lock()
+	defer jobs.m.Unlock()
+	return jobs.running
+}
+
+// GetStoppedJobs returns all of the stopped jobs
+func (jobs *Jobs) GetStoppedJobs() []*Job {
+	jobs.scan()
+	jobs.m.Lock()
+	defer jobs.m.Unlock()
+	return jobs.previous
+}
+
+// addJob adds a job to the internal slice
+func (jobs *Jobs) addJob(j *Job) {
+	jobs.m.Lock()
+	jobs.running = append(jobs.running, j)
+	jobs.m.Unlock()
+	jobs.scan()
+}
-- 
cgit v1.2.3