jcarr
/
repostatus
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

NEVER LEAVE JUNK IN GO REPOS EVER

This commit is contained in:
Jeff Carr 2025-02-22 19:11:51 -06:00
parent 3ab156a9c4
commit a72e9ce5f4
4 changed files with 0 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
ideas/interface.go
View File

@ -1,95 +0,0 @@
package repolist
// attempt to make a golang 'interface' for a 'view' of git repos
import (
"context"
"errors"
"fmt"
"go.wit.com/lib/protobuf/virtbuf"
)
// ViewRepoManager is a concrete implementation of the RepoManager interface.
type ViewRepoManager struct {
// client represents a hypothetical API client for interacting with the cloud.
client ViewAPIClient
}
// ViewAPIClient defines the methods required from the API client.
// This is useful if you want to mock this client for testing.
type ViewAPIClient interface {
GetRepoByName(ctx context.Context, name string) (*virtbuf.Cluster, error)
StartRepo(ctx context.Context, clusterID string) error
StopRepo(ctx context.Context, clusterID string) error
ListRepos(ctx context.Context) ([]*virtbuf.Cluster, error)
GetRepoStatus(ctx context.Context, clusterID string) (string, error)
}
// NewViewRepoManager creates a new ViewRepoManager with the provided API client.
func NewViewRepoManager(client ViewAPIClient) *ViewRepoManager {
return &ViewRepoManager{client: client}
}
// FindByName retrieves a cluster by name.
func (m *ViewRepoManager) FindByName(ctx context.Context, name string) (*virtbuf.Cluster, error) {
cluster, err := m.client.GetRepoByName(ctx, name)
if err != nil {
return nil, fmt.Errorf("error finding cluster by name %q: %w", name, err)
}
return cluster, nil
}
// Start initiates the startup process for the specified cluster.
func (m *ViewRepoManager) Start(ctx context.Context, cluster *virtbuf.Cluster) error {
if cluster == nil {
return errors.New("cluster cannot be nil")
}
/*
err := m.client.StartRepo(ctx, cluster.Id)
if err != nil {
return fmt.Errorf("error starting cluster %q: %w", cluster.Id, err)
}
*/
return nil
}
// Stop halts the specified cluster.
func (m *ViewRepoManager) Stop(ctx context.Context, cluster *virtbuf.Cluster) error {
if cluster == nil {
return errors.New("cluster cannot be nil")
}
/*
err := m.client.StopRepo(ctx, cluster.Id)
if err != nil {
return fmt.Errorf("error stopping cluster %q: %w", cluster.Id, err)
}
*/
return nil
}
// List retrieves all available clusters.
func (m *ViewRepoManager) List(ctx context.Context) ([]*virtbuf.Cluster, error) {
/*
clusters, err := m.client.ListRepos(ctx)
if err != nil {
return nil, fmt.Errorf("error listing clusters: %w", err)
}
return clusters, nil
*/
return nil, errors.New("List not done yet")
}
// Status checks the current status of a specified cluster.
func (m *ViewRepoManager) Status(ctx context.Context, cluster *virtbuf.Cluster) (string, error) {
if cluster == nil {
return "", errors.New("cluster cannot be nil")
}
/*
status, err := m.client.GetRepoStatus(ctx, cluster.Id)
if err != nil {
return "", fmt.Errorf("error getting status of cluster %q: %w", cluster.Id, err)
}
*/
return "", nil
}

32
ideas/pruneTags.go
View File

@ -1,32 +0,0 @@
package repostatus
import (
"strings"
"go.wit.com/log"
)
func (rs *RepoStatus) setGitCommands() {
var line1, line2, line3 []string
var all [][]string
newTag := rs.newversion.String()
line1 = append(line1, "git", "tag", "v"+newTag, "-m", rs.versionMessage.String())
all = append(all, line1)
line2 = append(line2, "git", "push", "--tags")
all = append(all, line2)
line3 = append(line3, "git", "push", "--prune", "--tags")
all = append(all, line3)
rs.versionCmds = all
var tmp []string
// convert to displayable to the user text
for _, line := range all {
s := strings.Join(line, " ")
log.Log(INFO, "s =", s)
tmp = append(tmp, s)
}
rs.versionCmdOutput.SetValue(strings.Join(tmp, "\n"))
}

41
ideas/revert.go
View File

@ -1,41 +0,0 @@
package repostatus
// reverts master to devel
// used in the unwind process of making GUI releases
/*
func (rs *RepoStatus) RevertMasterToDevel() bool {
if rs.CheckDirty() {
log.Info("sorry, it's still dirty")
return false
}
curName := rs.GetCurrentBranchName()
dName := rs.GetDevelBranchName()
mName := rs.GetMasterBranchName()
if curName != mName {
log.Info("repo is not working from main branch", curName, "!=", mName)
return false
}
log.Info("reset master to devel", curName, rs.String())
var all [][]string
all = append(all, []string{"git", "checkout", dName}) // switch to the devel branch
all = append(all, []string{"git", "branch", "-D", mName})
all = append(all, []string{"git", "branch", mName}) // make a master branch based on devel
all = append(all, []string{"git", "checkout", mName})
all = append(all, []string{"git", "push", "--set-upstream", "--force", "origin", mName})
// don't do anything with tags here
// all = append(all, []string{"git", "tag", "--delete", release.version.String()})
// all = append(all, []string{"git", "push", "--delete", "origin", release.version.String()})
if rs.DoAll(all) {
log.Info("EVERYTHING OK. RERELEASED", rs.String())
return true
}
log.Info("SOMETHING FAILED")
return false
}
*/

36
ideas/timer.go
View File

@ -1,36 +0,0 @@
package repostatus
import (
"time"
)
// timeFunction takes a function as an argument and returns the execution time.
func timeFunction(f func()) time.Duration {
startTime := time.Now() // Record the start time
f() // Execute the function
return time.Since(startTime) // Calculate the elapsed time
}
func (ls *RepoStatus) SetSpeedActual(s string) {
if !ls.Ready() {
return
}
ls.speedActual.SetValue(s)
}
func (rs *RepoStatus) setSpeed(duration time.Duration) {
s := fmt.Sprint(duration)
if rs.speedActual == nil {
log.Log(WARN, "rs.speedActual == nil")
return
}
rs.speedActual.SetValue(s)
if duration > 200*time.Millisecond {
rs.speed.SetValue("SLOW")
} else if duration > 50*time.Millisecond {
rs.speed.SetValue("OK")
} else {
rs.speed.SetValue("FAST")
}
}