Manage all dependencies itself

Author: mohanson

cmd/daze/main.go

@@ -15,13 +15,13 @@ import (
 	"time"
 
 	"github.com/libraries/daze"
+	"github.com/libraries/daze/lib/doa"
+	"github.com/libraries/daze/lib/gracefulexit"
+	"github.com/libraries/daze/lib/rate"
 	"github.com/libraries/daze/protocol/ashe"
 	"github.com/libraries/daze/protocol/baboon"
 	"github.com/libraries/daze/protocol/czar"
 	"github.com/libraries/daze/protocol/dahlia"
-	"github.com/libraries/go/doa"
-	"github.com/libraries/go/gracefulexit"
-	"github.com/libraries/go/rate"
 )
 
 // Conf is acting as package level configuration.

daze.go

@@ -27,10 +27,10 @@ import (
 	"sync"
 	"time"
 
-	"github.com/libraries/go/doa"
-	"github.com/libraries/go/lru"
-	"github.com/libraries/go/pretty"
-	"github.com/libraries/go/rate"
+	"github.com/libraries/daze/lib/doa"
+	"github.com/libraries/daze/lib/lru"
+	"github.com/libraries/daze/lib/pretty"
+	"github.com/libraries/daze/lib/rate"
 )
 
 // ============================================================================
@@ -1209,7 +1209,7 @@ func LoadApnic() map[string][]*net.IPNet {
 	log.Println("main: load apnic data from", url)
 	rep := doa.Try(http.Get(url))
 	defer rep.Body.Close()
-	f := io.TeeReader(rep.Body, pretty.NewProgressWriter(rep.ContentLength))
+	f := io.TeeReader(rep.Body, pretty.NewProgressWriter(uint64(rep.ContentLength)))
 	r := map[string][]*net.IPNet{}
 	s := bufio.NewScanner(f)
 	for s.Scan() {

daze_test.go

@@ -6,7 +6,7 @@ import (
 	"os/exec"
 	"testing"
 
-	"github.com/libraries/go/doa"
+	"github.com/libraries/daze/lib/doa"
 )
 
 const (

go.mod

@@ -1,5 +1,3 @@
 module github.com/libraries/daze
 
 go 1.25.0
-
-require github.com/libraries/go v1.0.5

lib/doa/README.md

@@ -0,0 +1,7 @@
+# Doa
+
+Package doa is the abbreviation of the "Dead or alive". It provides some easy ways to make you panic down the program.
+
+> One of the benefits of detecting problems as soon as you can is that you can crash earlier, and crashing is often the bet thing you can do. The alternative may be to continue, writing corrupted data to some vital database or commanding the washing machine into its twentieth consecutive spin cycle.
+
+Crash is not poison, it's "Quit gracefully".

lib/doa/doa.go

@@ -0,0 +1,38 @@
+// Package doa stands for "dead or alive". It provides simple utilities to intentionally crash the program with a panic.
+package doa
+
+import (
+	"log"
+)
+
+// Doa checks a boolean condition and triggers a panic if it’s false.
+func Doa(b bool) {
+	if !b {
+		log.Panicln("doa: unreachable")
+	}
+}
+
+// Err returns the error passed to it, ignoring the first argument.
+func Err(a any, err error) error {
+	return err
+}
+
+// Nil checks if an error is non-nil and panics if it is.
+func Nil(err error) {
+	if err != nil {
+		log.Panicln("doa:", err)
+	}
+}
+
+// Try returns a value if there’s no error, otherwise it panics.
+func Try[T any](a T, err error) T {
+	if err != nil {
+		log.Panicln("doa:", err)
+	}
+	return a
+}
+
+// Val returns the first argument, ignoring the error.
+func Val[T any](a T, err error) T {
+	return a
+}

lib/gracefulexit/README.md

@@ -0,0 +1,3 @@
+# Gracefulexit
+
+Package gracefulexit provides a method to exit the program gracefully. A graceful exit (or graceful handling) is a simple programming idiom[citation needed] wherein a program detects a serious error condition and "exits gracefully" in a controlled manner as a result. Often the program prints a descriptive error message to a terminal or log as part of the graceful exit.

lib/gracefulexit/cmd/http/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"log"
+	"net"
+	"net/http"
+
+	"github.com/libraries/daze/lib/gracefulexit"
+)
+
+func main() {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("Hello World!"))
+		w.Write([]byte("\n"))
+	})
+	log.Println("main: listen and server on 127.0.0.1:8080")
+	l, err := net.Listen("tcp", "127.0.0.1:8080")
+	if err != nil {
+		log.Panicln("main:", err)
+	}
+	server := http.Server{}
+	go server.Serve(l)
+	gracefulexit.Wait()
+	log.Println("main: server close")
+	server.Close()
+	log.Println("main: done")
+}

lib/gracefulexit/gracefulexit.go

@@ -0,0 +1,22 @@
+// Package gracefulexit provides a method to exit the program gracefully. A graceful exit (or graceful handling) is a
+// simple programming idiom[citation needed] wherein a program detects a serious error condition and "exits gracefully"
+// in a controlled manner as a result. Often the program prints a descriptive error message to a terminal or log as part
+// of the graceful exit.
+package gracefulexit
+
+import (
+	"os"
+	"os/signal"
+)
+
+// Chan create a channel for os.Signal.
+func Chan() chan os.Signal {
+	buffer := make(chan os.Signal, 1)
+	signal.Notify(buffer, os.Interrupt)
+	return buffer
+}
+
+// Wait for a signal.
+func Wait() {
+	<-Chan()
+}

lib/lru/README.md

@@ -0,0 +1,3 @@
+# Lru
+
+Package lru implements an LRU cache.