feat. add usage.

Author: PotatoCloud

default.go

@@ -1,8 +1,24 @@
 package packaged
 
+// internal holds the service manager instance.
 var internal = New()
 
-func Register(newFc NewService, opts ...UnitOptions) { internal.Register(newFc, opts...) }
-func Stop()                                          { internal.Stop() }
-func Run() error                                     { return internal.Run() }
-func Wait()                                          { internal.Wait() }
+// Register adds a new service to the internal service manager.
+func Register(newFc NewService, opts ...UnitOptions) {
+	internal.Register(newFc, opts...)
+}
+
+// Stop gracefully stops all services managed by the internal service manager.
+func Stop() {
+	internal.Stop()
+}
+
+// Run starts the internal service manager and launches all registered services.
+func Run() error {
+	return internal.Run()
+}
+
+// Wait blocks execution until all services have completed or stopped.
+func Wait() {
+	internal.Wait()
+}

example/0-startup/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"context"
+	"github.com/RealFax/packaged"
+	"log"
+	"net/http"
+)
+
+type httpServer struct {
+	*packaged.UnimplementedHandler
+	ctx packaged.Namespace
+	svc *http.Server
+}
+
+func (s httpServer) Name() string               { return "http-server" }
+func (s httpServer) Type() packaged.ServiceType { return packaged.ServiceTypeAsync }
+func (s httpServer) OnInstall() error {
+	addr, _ := s.ctx.GetEnv("HTTP_ADDR")
+	s.svc = &http.Server{Addr: addr}
+	return nil
+}
+func (s httpServer) OnStart() error {
+	return s.svc.ListenAndServe()
+}
+func (s httpServer) OnStop() error {
+	return s.svc.Shutdown(context.Background())
+}
+
+func main() {
+	packaged.Register(func(ns packaged.Namespace) packaged.Service {
+		return &httpServer{ctx: ns}
+	})
+
+	if err := packaged.Run(); err != nil {
+		log.Fatal(err)
+	}
+
+	packaged.Wait()
+}

refs.go

@@ -7,6 +7,12 @@ import (
 	"sync"
 )
 
+var (
+	_ Service        = &UnimplementedHandler{}
+	_ Namespace      = &namespace{}
+	_ sort.Interface = &unitSorter{}
+)
+
 type (
 	ServiceType int32
 	Restart     int32
@@ -91,21 +97,28 @@ const (
 func (h UnimplementedHandler) mustEmbedUnimplemented() {}
 func (h UnimplementedHandler) Name() string            { return "unimplemented" }
 func (h UnimplementedHandler) Type() ServiceType       { return ServiceTypeIgnore }
-func (h UnimplementedHandler) OnInstall() error        { panic("Unimplemented OnInstall") }
-func (h UnimplementedHandler) OnStart() error          { panic("Unimplemented OnStart") }
-func (h UnimplementedHandler) OnStop() error           { panic("Unimplemented OnStop") }
+func (h UnimplementedHandler) OnInstall() error        { return errors.New("unimplemented OnInstall") }
+func (h UnimplementedHandler) OnStart() error          { return errors.New("unimplemented OnStart") }
+func (h UnimplementedHandler) OnStop() error           { return errors.New("unimplemented OnStop") }
 
 func (n *namespace) Name() string { return n.name }
-func (n *namespace) Set(key string, value any) {
+
+func (n *namespace) setValueWithLock(action func()) {
 	n.rw.Lock()
 	defer n.rw.Unlock()
-	n.values[key] = value
+	action()
+}
+
+func (n *namespace) Set(key string, value any) {
+	n.setValueWithLock(func() {
+		n.values[key] = value
+	})
 }
 
 func (n *namespace) Del(key string) {
-	n.rw.Lock()
-	defer n.rw.Unlock()
-	delete(n.values, key)
+	n.setValueWithLock(func() {
+		delete(n.values, key)
+	})
 }
 
 func (n *namespace) Get(key string) (any, bool) {
@@ -134,22 +147,21 @@ func newNamespace(name string) Namespace {
 	}
 	return &namespace{
 		name:       name,
-		values:     make(map[string]any),
+		values:     make(map[string]any, 16),
 		services:   make([]Service, 0, 8),
 		EnvManager: env,
 	}
 }
 
 func (s unitSorter) Len() int { return len(s.units) }
 func (s unitSorter) Less(i, j int) bool {
-	if s.desc {
-		return s.units[i].Index > s.units[j].Index
-	}
-	return s.units[i].Index < s.units[j].Index
+	return (s.units[i].Index > s.units[j].Index) == s.desc
 }
 
 func (s unitSorter) Swap(i, j int) {
 	s.units[i], s.units[j] = s.units[j], s.units[i]
 }
 
-func (u Units) Sort(desc bool) { sort.Sort(unitSorter{units: u, desc: desc}) }
+func (u Units) Sort(desc bool) {
+	sort.Sort(unitSorter{units: u, desc: desc})
+}