From 1f0a18a0a8e21a831dbc002b8b4110298739b875 Mon Sep 17 00:00:00 2001 From: Jeff Carr Date: Thu, 21 Nov 2024 19:00:08 -0600 Subject: prepare to autogen these files Signed-off-by: Jeff Carr --- helpers.go | 63 ----------------- machine.marshal.go | 39 +++++++++++ machine.sort.go | 146 +++++++++++++++++++++++++++++++++++++++ machines.go | 146 --------------------------------------- package.marshal.go | 42 ++++++++++++ package.sort.go | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++++ packages.go | 196 ----------------------------------------------------- 7 files changed, 423 insertions(+), 405 deletions(-) delete mode 100644 helpers.go create mode 100644 machine.marshal.go create mode 100644 machine.sort.go delete mode 100644 machines.go create mode 100644 package.marshal.go create mode 100644 package.sort.go delete mode 100644 packages.go diff --git a/helpers.go b/helpers.go deleted file mode 100644 index 390da5c..0000000 --- a/helpers.go +++ /dev/null @@ -1,63 +0,0 @@ -package zoopb - -// functions to import and export the protobuf -// data to and from config files - -import ( - "google.golang.org/protobuf/encoding/protojson" - "google.golang.org/protobuf/encoding/prototext" - "google.golang.org/protobuf/proto" - // "google.golang.org/protobuf/proto" -) - -// human readable JSON -func (p *Packages) FormatJSON() string { - return protojson.Format(p) -} - -// apparently this isn't supposed to be used? -// https://protobuf.dev/reference/go/faq/#unstable-text -// this is a shame because this is much nicer output than JSON Format() -func (p *Packages) FormatTEXT() string { - return prototext.Format(p) -} - -// marshal json -func (p *Packages) MarshalJSON() ([]byte, error) { - return protojson.Marshal(p) -} - -// unmarshal -func (p *Packages) UnmarshalJSON(data []byte) error { - return protojson.Unmarshal(data, p) -} - -// marshal to wire -func (p *Packages) Marshal() ([]byte, error) { - return proto.Marshal(p) -} - -// unmarshal from wire -func (p *Packages) Unmarshal(data []byte) error { - return proto.Unmarshal(data, p) -} - -// marshal to wire -func (m *Machine) Marshal() ([]byte, error) { - return proto.Marshal(m) -} - -// unmarshal from wire -func (m *Machine) Unmarshal(data []byte) error { - return proto.Unmarshal(data, m) -} - -// marshal to wire -func (m *Machines) Marshal() ([]byte, error) { - return proto.Marshal(m) -} - -// unmarshal from wire -func (m *Machines) Unmarshal(data []byte) error { - return proto.Unmarshal(data, m) -} diff --git a/machine.marshal.go b/machine.marshal.go new file mode 100644 index 0000000..00959cb --- /dev/null +++ b/machine.marshal.go @@ -0,0 +1,39 @@ +package zoopb + +// todo: autogen this + +import ( + "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/encoding/prototext" + "google.golang.org/protobuf/proto" +) + +// marshal to wire +func (m *Machine) Marshal() ([]byte, error) { + return proto.Marshal(m) +} + +// marshal to TEXT +func (m *Machine) MarshalTEXT() ([]byte, error) { + return prototext.Marshal(m) +} + +// marshal to JSON +func (m *Machine) MarshalJSON() ([]byte, error) { + return protojson.Marshal(m) +} + +// unmarshal from wire +func (m *Machine) Unmarshal(data []byte) error { + return proto.Unmarshal(data, m) +} + +// marshal to wire +func (m *Machines) Marshal() ([]byte, error) { + return proto.Marshal(m) +} + +// unmarshal from wire +func (m *Machines) Unmarshal(data []byte) error { + return proto.Unmarshal(data, m) +} diff --git a/machine.sort.go b/machine.sort.go new file mode 100644 index 0000000..3766ae7 --- /dev/null +++ b/machine.sort.go @@ -0,0 +1,146 @@ +package zoopb + +// this is becoming a standard format +// todo: autogenerate this from the .proto file? + +import ( + "fmt" + "os" + "sort" + sync "sync" + "time" +) + +// bad global lock until I figure out some other plan +var machinesLock sync.RWMutex + +type MachineIterator struct { + sync.RWMutex + + packs []*Machine + index int +} + +// NewMachineIterator initializes a new iterator. +func NewMachineIterator(packs []*Machine) *MachineIterator { + return &MachineIterator{packs: packs} +} + +// Scan moves to the next element and returns false if there are no more packs. +func (it *MachineIterator) Scan() bool { + if it.index >= len(it.packs) { + return false + } + it.index++ + return true +} + +// Machine returns the current repo. +func (it *MachineIterator) Machine() *Machine { + if it.packs[it.index-1] == nil { + for i, d := range it.packs { + fmt.Println("i =", i, d) + } + fmt.Println("len =", len(it.packs)) + fmt.Println("repo == nil", it.index, it.index-1) + os.Exit(-1) + } + return it.packs[it.index-1] +} + +// Use Scan() in a loop, similar to a while loop +// +// for iterator.Scan() { +// d := iterator.Machine() +// fmt.Println("Machine UUID:", d.Uuid) +// } + +func (r *Machines) All() *MachineIterator { + repoPointers := r.selectAllMachines() + + iterator := NewMachineIterator(repoPointers) + return iterator +} + +func (r *Machines) SortByName() *MachineIterator { + packs := r.selectAllMachines() + + sort.Sort(ByMachineName(packs)) + + iterator := NewMachineIterator(packs) + return iterator +} + +// enforces no duplicate package names +func (r *Machines) Append(newP *Machine) bool { + machinesLock.Lock() + defer machinesLock.Unlock() + + for _, p := range r.Machines { + if p.Hostname == newP.Hostname { + return false + } + } + + r.Machines = append(r.Machines, newP) + return true +} + +// returns time.Duration since last Update() +func (r *Machine) Age(newP *Machine) time.Duration { + t := time.Since(r.Laststamp.AsTime()) + return t +} + +// find a machine by name +func (r *Machines) FindByName(name string) *Machine { + machinesLock.RLock() + defer machinesLock.RUnlock() + + for _, p := range r.Machines { + if p.Hostname == name { + return p + } + } + + return nil +} + +// find a package by name +func (m *Machine) FindPackageByName(name string) *Package { + if m == nil { + return nil + } + if m.Packages == nil { + return nil + } + return m.Packages.FindByName(name) +} + +func (r *Machines) Len() int { + machinesLock.RLock() + defer machinesLock.RUnlock() + + return len(r.Machines) +} + +type ByMachineName []*Machine + +func (a ByMachineName) Len() int { return len(a) } +func (a ByMachineName) Less(i, j int) bool { return a[i].Hostname < a[j].Hostname } +func (a ByMachineName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } + +// safely returns a slice of pointers to the Machine protobufs +func (r *Machines) selectAllMachines() []*Machine { + machinesLock.RLock() + defer machinesLock.RUnlock() + + // Create a new slice to hold pointers to each Machine + var allPacks []*Machine + allPacks = make([]*Machine, len(r.Machines)) + for i, p := range r.Machines { + allPacks[i] = p // Copy pointers for safe iteration + } + + return allPacks +} diff --git a/machines.go b/machines.go deleted file mode 100644 index 3766ae7..0000000 --- a/machines.go +++ /dev/null @@ -1,146 +0,0 @@ -package zoopb - -// this is becoming a standard format -// todo: autogenerate this from the .proto file? - -import ( - "fmt" - "os" - "sort" - sync "sync" - "time" -) - -// bad global lock until I figure out some other plan -var machinesLock sync.RWMutex - -type MachineIterator struct { - sync.RWMutex - - packs []*Machine - index int -} - -// NewMachineIterator initializes a new iterator. -func NewMachineIterator(packs []*Machine) *MachineIterator { - return &MachineIterator{packs: packs} -} - -// Scan moves to the next element and returns false if there are no more packs. -func (it *MachineIterator) Scan() bool { - if it.index >= len(it.packs) { - return false - } - it.index++ - return true -} - -// Machine returns the current repo. -func (it *MachineIterator) Machine() *Machine { - if it.packs[it.index-1] == nil { - for i, d := range it.packs { - fmt.Println("i =", i, d) - } - fmt.Println("len =", len(it.packs)) - fmt.Println("repo == nil", it.index, it.index-1) - os.Exit(-1) - } - return it.packs[it.index-1] -} - -// Use Scan() in a loop, similar to a while loop -// -// for iterator.Scan() { -// d := iterator.Machine() -// fmt.Println("Machine UUID:", d.Uuid) -// } - -func (r *Machines) All() *MachineIterator { - repoPointers := r.selectAllMachines() - - iterator := NewMachineIterator(repoPointers) - return iterator -} - -func (r *Machines) SortByName() *MachineIterator { - packs := r.selectAllMachines() - - sort.Sort(ByMachineName(packs)) - - iterator := NewMachineIterator(packs) - return iterator -} - -// enforces no duplicate package names -func (r *Machines) Append(newP *Machine) bool { - machinesLock.Lock() - defer machinesLock.Unlock() - - for _, p := range r.Machines { - if p.Hostname == newP.Hostname { - return false - } - } - - r.Machines = append(r.Machines, newP) - return true -} - -// returns time.Duration since last Update() -func (r *Machine) Age(newP *Machine) time.Duration { - t := time.Since(r.Laststamp.AsTime()) - return t -} - -// find a machine by name -func (r *Machines) FindByName(name string) *Machine { - machinesLock.RLock() - defer machinesLock.RUnlock() - - for _, p := range r.Machines { - if p.Hostname == name { - return p - } - } - - return nil -} - -// find a package by name -func (m *Machine) FindPackageByName(name string) *Package { - if m == nil { - return nil - } - if m.Packages == nil { - return nil - } - return m.Packages.FindByName(name) -} - -func (r *Machines) Len() int { - machinesLock.RLock() - defer machinesLock.RUnlock() - - return len(r.Machines) -} - -type ByMachineName []*Machine - -func (a ByMachineName) Len() int { return len(a) } -func (a ByMachineName) Less(i, j int) bool { return a[i].Hostname < a[j].Hostname } -func (a ByMachineName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -// safely returns a slice of pointers to the Machine protobufs -func (r *Machines) selectAllMachines() []*Machine { - machinesLock.RLock() - defer machinesLock.RUnlock() - - // Create a new slice to hold pointers to each Machine - var allPacks []*Machine - allPacks = make([]*Machine, len(r.Machines)) - for i, p := range r.Machines { - allPacks[i] = p // Copy pointers for safe iteration - } - - return allPacks -} diff --git a/package.marshal.go b/package.marshal.go new file mode 100644 index 0000000..2c8a4e7 --- /dev/null +++ b/package.marshal.go @@ -0,0 +1,42 @@ +package zoopb + +// todo: autogen this +// functions to import and export the protobuf + +import ( + "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/encoding/prototext" + "google.golang.org/protobuf/proto" +) + +// human readable JSON +func (p *Packages) FormatJSON() string { + return protojson.Format(p) +} + +// apparently this isn't supposed to be used? +// https://protobuf.dev/reference/go/faq/#unstable-text +// this is a shame because this is much nicer output than JSON Format() +func (p *Packages) FormatTEXT() string { + return prototext.Format(p) +} + +// marshal json +func (p *Packages) MarshalJSON() ([]byte, error) { + return protojson.Marshal(p) +} + +// unmarshal +func (p *Packages) UnmarshalJSON(data []byte) error { + return protojson.Unmarshal(data, p) +} + +// marshal to wire +func (p *Packages) Marshal() ([]byte, error) { + return proto.Marshal(p) +} + +// unmarshal from wire +func (p *Packages) Unmarshal(data []byte) error { + return proto.Unmarshal(data, p) +} diff --git a/package.sort.go b/package.sort.go new file mode 100644 index 0000000..0dead0a --- /dev/null +++ b/package.sort.go @@ -0,0 +1,196 @@ +package zoopb + +// this is becoming a standard format +// todo: autogenerate this from the .proto file? + +import ( + "fmt" + "os" + "sort" + sync "sync" + "time" + + timestamppb "google.golang.org/protobuf/types/known/timestamppb" +) + +// bad global lock until I figure out some other plan +var lock sync.RWMutex + +type PackageIterator struct { + sync.RWMutex + + packs []*Package + index int +} + +// NewPackageIterator initializes a new iterator. +func NewPackageIterator(packs []*Package) *PackageIterator { + return &PackageIterator{packs: packs} +} + +// Scan moves to the next element and returns false if there are no more packs. +func (it *PackageIterator) Scan() bool { + if it.index >= len(it.packs) { + return false + } + it.index++ + return true +} + +// Package returns the current repo. +func (it *PackageIterator) Package() *Package { + if it.packs[it.index-1] == nil { + for i, d := range it.packs { + fmt.Println("i =", i, d) + } + fmt.Println("len =", len(it.packs)) + fmt.Println("repo == nil", it.index, it.index-1) + os.Exit(-1) + } + return it.packs[it.index-1] +} + +// Use Scan() in a loop, similar to a while loop +// +// for iterator.Scan() { +// d := iterator.Package() +// fmt.Println("Package UUID:", d.Uuid) +// } + +func (r *Packages) All() *PackageIterator { + repoPointers := r.selectAllPackages() + + iterator := NewPackageIterator(repoPointers) + return iterator +} + +func (r *Packages) SortByName() *PackageIterator { + packs := r.selectAllPackages() + + sort.Sort(ByName(packs)) + + iterator := NewPackageIterator(packs) + return iterator +} + +// enforces no duplicate package names +func (r *Packages) Append(newP *Package) bool { + lock.Lock() + defer lock.Unlock() + + for _, p := range r.Packages { + if p.Name == newP.Name { + return false + } + } + + r.Packages = append(r.Packages, newP) + return true +} + +// Update version and timestamp. +// returns ok (ok == true if not found) +func (r *Packages) Update(newP *Package) bool { + lock.Lock() + defer lock.Unlock() + + var found *Package + for _, p := range r.Packages { + if p.Name == newP.Name { + found = p + } + } + if found == nil { + // r.Append(newP) // update here? + return true + } + + var changed bool = false + if newP.Version != found.Version { + changed = true + found.Version = newP.Version + } + + now := time.Now() + found.Laststamp = timestamppb.New(now) + return changed +} + +// returns time.Duration since last Update() +func (r *Package) Age(newP *Package) time.Duration { + t := time.Since(r.Laststamp.AsTime()) + return t +} + +// find a package by name +func (r *Packages) FindByName(name string) *Package { + lock.RLock() + defer lock.RUnlock() + + for _, p := range r.Packages { + if p.Name == name { + return p + } + } + + return nil +} + +func (r *Packages) Len() int { + lock.RLock() + defer lock.RUnlock() + + return len(r.Packages) +} + +type ByName []*Package + +func (a ByName) Len() int { return len(a) } +func (a ByName) Less(i, j int) bool { return a[i].Name < a[j].Name } +func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } + +// safely returns a slice of pointers to the Package protobufs +func (r *Packages) selectAllPackages() []*Package { + lock.RLock() + defer lock.RUnlock() + + // Create a new slice to hold pointers to each Package + var allPacks []*Package + allPacks = make([]*Package, len(r.Packages)) + for i, p := range r.Packages { + allPacks[i] = p // Copy pointers for safe iteration + } + + return allPacks +} + +/* +func (r *Packages) UnmergedPackageRepos() *PackageRepoIterator { + repoPointers := r.selectUnmergedPackageRepos() + + sort.Sort(ByName(repoPointers)) + + iterator := NewPackageRepoIterator(repoPointers) + + return iterator +} +*/ + +/* +// this sort doesn't really work. I think it forgets to sort the last two +// todo: sort this out. literally +// SelectPackagePointers safely returns a slice of pointers to Package records. +func (r *Packages) selectUnmergedPackages() []*PackageRow { + r.RLock() + defer r.RUnlock() + + // Create a new slice to hold pointers to each Package + // repoPointers := make([]*Package, len(c.E.Packages)) + var repoPointers []*PackageRow + for _, repo := range me.allrepos { + repoPointers = append(repoPointers, repo) // Copy pointers for safe iteration + } + + return repoPointers +} +*/ diff --git a/packages.go b/packages.go deleted file mode 100644 index 0dead0a..0000000 --- a/packages.go +++ /dev/null @@ -1,196 +0,0 @@ -package zoopb - -// this is becoming a standard format -// todo: autogenerate this from the .proto file? - -import ( - "fmt" - "os" - "sort" - sync "sync" - "time" - - timestamppb "google.golang.org/protobuf/types/known/timestamppb" -) - -// bad global lock until I figure out some other plan -var lock sync.RWMutex - -type PackageIterator struct { - sync.RWMutex - - packs []*Package - index int -} - -// NewPackageIterator initializes a new iterator. -func NewPackageIterator(packs []*Package) *PackageIterator { - return &PackageIterator{packs: packs} -} - -// Scan moves to the next element and returns false if there are no more packs. -func (it *PackageIterator) Scan() bool { - if it.index >= len(it.packs) { - return false - } - it.index++ - return true -} - -// Package returns the current repo. -func (it *PackageIterator) Package() *Package { - if it.packs[it.index-1] == nil { - for i, d := range it.packs { - fmt.Println("i =", i, d) - } - fmt.Println("len =", len(it.packs)) - fmt.Println("repo == nil", it.index, it.index-1) - os.Exit(-1) - } - return it.packs[it.index-1] -} - -// Use Scan() in a loop, similar to a while loop -// -// for iterator.Scan() { -// d := iterator.Package() -// fmt.Println("Package UUID:", d.Uuid) -// } - -func (r *Packages) All() *PackageIterator { - repoPointers := r.selectAllPackages() - - iterator := NewPackageIterator(repoPointers) - return iterator -} - -func (r *Packages) SortByName() *PackageIterator { - packs := r.selectAllPackages() - - sort.Sort(ByName(packs)) - - iterator := NewPackageIterator(packs) - return iterator -} - -// enforces no duplicate package names -func (r *Packages) Append(newP *Package) bool { - lock.Lock() - defer lock.Unlock() - - for _, p := range r.Packages { - if p.Name == newP.Name { - return false - } - } - - r.Packages = append(r.Packages, newP) - return true -} - -// Update version and timestamp. -// returns ok (ok == true if not found) -func (r *Packages) Update(newP *Package) bool { - lock.Lock() - defer lock.Unlock() - - var found *Package - for _, p := range r.Packages { - if p.Name == newP.Name { - found = p - } - } - if found == nil { - // r.Append(newP) // update here? - return true - } - - var changed bool = false - if newP.Version != found.Version { - changed = true - found.Version = newP.Version - } - - now := time.Now() - found.Laststamp = timestamppb.New(now) - return changed -} - -// returns time.Duration since last Update() -func (r *Package) Age(newP *Package) time.Duration { - t := time.Since(r.Laststamp.AsTime()) - return t -} - -// find a package by name -func (r *Packages) FindByName(name string) *Package { - lock.RLock() - defer lock.RUnlock() - - for _, p := range r.Packages { - if p.Name == name { - return p - } - } - - return nil -} - -func (r *Packages) Len() int { - lock.RLock() - defer lock.RUnlock() - - return len(r.Packages) -} - -type ByName []*Package - -func (a ByName) Len() int { return len(a) } -func (a ByName) Less(i, j int) bool { return a[i].Name < a[j].Name } -func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -// safely returns a slice of pointers to the Package protobufs -func (r *Packages) selectAllPackages() []*Package { - lock.RLock() - defer lock.RUnlock() - - // Create a new slice to hold pointers to each Package - var allPacks []*Package - allPacks = make([]*Package, len(r.Packages)) - for i, p := range r.Packages { - allPacks[i] = p // Copy pointers for safe iteration - } - - return allPacks -} - -/* -func (r *Packages) UnmergedPackageRepos() *PackageRepoIterator { - repoPointers := r.selectUnmergedPackageRepos() - - sort.Sort(ByName(repoPointers)) - - iterator := NewPackageRepoIterator(repoPointers) - - return iterator -} -*/ - -/* -// this sort doesn't really work. I think it forgets to sort the last two -// todo: sort this out. literally -// SelectPackagePointers safely returns a slice of pointers to Package records. -func (r *Packages) selectUnmergedPackages() []*PackageRow { - r.RLock() - defer r.RUnlock() - - // Create a new slice to hold pointers to each Package - // repoPointers := make([]*Package, len(c.E.Packages)) - var repoPointers []*PackageRow - for _, repo := range me.allrepos { - repoPointers = append(repoPointers, repo) // Copy pointers for safe iteration - } - - return repoPointers -} -*/ -- cgit v1.2.3