storage use new logger

cmd/ppass/ppass.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/k4lipso/pentapass/rpc"
@@ -14,10 +13,6 @@ import (
 
 var (
 	dbPath = flag.String("db", "./db", "db file path")
-	logger    = logging.Logger("globaldb")
-//	topicName = "globaldb-example"
-//	netTopic  = "globaldb-example-net"
-//	config    = "globaldb-example"
 )
 
 // Create the root command

cmd/ppassd/ppassd.go

@@ -3,76 +3,62 @@ package main
 import (
 	"context"
 	"flag"
-	"fmt"
 
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	ipfslite "github.com/hsanjuan/ipfs-lite"
 	badger "github.com/ipfs/go-ds-badger2"
-	logging "github.com/ipfs/go-log/v2"
 
 	"github.com/k4lipso/pentapass/storage"
 	"github.com/k4lipso/pentapass/rpc"
 	"github.com/k4lipso/pentapass/crypto/age"
+	. "github.com/k4lipso/pentapass/internal/log"
 )
 
 var (
-	topicNameFlag = flag.String("topicName", "pentapass", "name of topic to join")
 	dbPath = flag.String("db", "./db", "db file path")
-	nameSpace = flag.String("namespace", "crdt", "namespace")
-	logger    = logging.Logger("globaldb")
-//	netTopic  = "globaldb-example-net"
-//	config    = "globaldb-example"
+	debug = flag.Bool("debug", false, "log debug information")
 )
 
-
 func main() {
 	flag.Parse()
+	InitLogger(*debug)
+
 	ctx := context.Background()
 	data := *dbPath
 
 	key, err := age.LoadOrGenerateKeys(*dbPath + "/age.key")
 
 	if err != nil {
-		panic(err)
+		Logger.Panic(err)
 	}
 
-	fmt.Printf("AgeKey: %s\n", key.String())
-	fmt.Printf("AgePublicKey: %s\n", key.Recipient().String())
-
-	//cipher, err := age.Encrypt([]byte("Test Message"), []string{key.Recipient().String()})
-	//fmt.Printf("Encrypted: %s\n", cipher)
-	//decrypted, err := age.Decrypt(cipher, key)
-	//fmt.Printf("Decrypted: %s\n", decrypted)
+	Logger.Debugf("AgeKey: %s\n", key.String())
+	Logger.Debugf("AgePublicKey: %s\n", key.Recipient().String())
 
 	h, dht, err := storage.SetupLibp2pHost(ctx, *dbPath)
 
-	fmt.Println(h.ID().String())
+	Logger.Debug(h.ID().String())
 
 	if err != nil {
-		panic(err)
+		Logger.Panic(err)
 	}
 
 	ps, err := pubsub.NewGossipSub(ctx, h)
 	if err != nil {
-		panic(err)
+		Logger.Panic(err)
 	}
 
-	//_, err = ps.Join(*topicNameFlag)
-	//if err != nil {
-	//	panic(err)
-	//}
-
 	go storage.DiscoverPeers(ctx, h, dht)
 
 	store, err := badger.NewDatastore(data, &badger.DefaultOptions)
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	}
 	defer store.Close()
 
 	ipfs, err := ipfslite.New(ctx, store, nil, h, dht, nil)
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	}
 
 	storageHandler := storage.StorageHandler{
@@ -87,7 +73,7 @@ func main() {
 	Cfg, err := storageHandler.NewConfig(*dbPath + "/config.json")
 
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	}
 
 	storageHandler.Config = Cfg

go.mod

@@ -9,11 +9,11 @@ require (
 	github.com/ipfs/go-datastore v0.6.0
 	github.com/ipfs/go-ds-badger2 v0.1.3
 	github.com/ipfs/go-ds-crdt v0.5.2
-	github.com/ipfs/go-log/v2 v2.5.1
 	github.com/libp2p/go-libp2p v0.35.4
 	github.com/libp2p/go-libp2p-kad-dht v0.25.2
 	github.com/libp2p/go-libp2p-pubsub v0.11.0
 	github.com/multiformats/go-multiaddr v0.13.0
+	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/cobra v0.0.5
 )
 
@@ -69,6 +69,7 @@ require (
 	github.com/ipfs/go-ipld-format v0.6.0 // indirect
 	github.com/ipfs/go-ipld-legacy v0.2.1 // indirect
 	github.com/ipfs/go-log v1.0.5 // indirect
+	github.com/ipfs/go-log/v2 v2.5.1 // indirect
 	github.com/ipfs/go-metrics-interface v0.0.1 // indirect
 	github.com/ipfs/go-peertaskqueue v0.8.1 // indirect
 	github.com/ipld/go-codec-dagpb v1.6.0 // indirect

go.sum

@@ -477,6 +477,8 @@ github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeV
 github.com/shurcooL/users v0.0.0-20180125191416-49c67e49c537/go.mod h1:QJTqeLYEDaXHZDBsXlPCDqdhQuJkuw4NOtaxYe3xii4=
 github.com/shurcooL/webdavfs v0.0.0-20170829043945-18c3829fa133/go.mod h1:hKmq5kWdCj2z2KEozexVbfEZIWiTjhE0+UjmZgPqehw=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
+github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=
 github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
 github.com/smartystreets/goconvey v1.7.2 h1:9RBaZCeXEQ3UselpuwUQHltGVXvdwm6cv1hgR6gDIPg=

internal/log/log.go

@@ -0,0 +1,48 @@
+package log
+
+import (
+	"bytes"
+	"os"
+
+	"github.com/sirupsen/logrus"
+)
+
+var Logger = logrus.New()
+
+type CustomTextFormatter struct {
+    logrus.TextFormatter
+}
+
+func (f *CustomTextFormatter) Format(entry *logrus.Entry) ([]byte, error) {
+	if entry.Level != logrus.InfoLevel {
+		return f.TextFormatter.Format(entry)
+	}
+
+  var b bytes.Buffer
+  b.WriteString(entry.Message)
+  b.WriteByte('\n')
+  return b.Bytes(), nil
+}
+
+
+func InitLogger(debug bool) {
+	if debug {
+		Logger.SetFormatter(&logrus.TextFormatter{
+			DisableLevelTruncation: true,
+			PadLevelText: true,
+			DisableTimestamp: true,
+		})
+		Logger.SetLevel(logrus.DebugLevel)
+	} else {
+		Logger.SetFormatter(&CustomTextFormatter{
+			logrus.TextFormatter{
+				DisableLevelTruncation: true,
+				PadLevelText: true,
+				DisableTimestamp: true,
+			},
+		})
+		Logger.SetLevel(logrus.InfoLevel)
+	}
+
+  Logger.SetOutput(os.Stdout)
+}

storage/storage.go

@@ -3,8 +3,8 @@ package storage
 import (
 	"context"
 	"errors"
-	"fmt"
 	"os"
+	"fmt"
 	"encoding/json"
 	"path/filepath"
 	"time"
@@ -32,16 +32,15 @@ import (
 	crdt "github.com/ipfs/go-ds-crdt"
 	crypto "github.com/libp2p/go-libp2p/core/crypto"
 	routed "github.com/libp2p/go-libp2p/p2p/host/routed"
-	logging "github.com/ipfs/go-log/v2"
 
   agelib "filippo.io/age"
 	password "github.com/k4lipso/pentapass/crypto"
 	"github.com/k4lipso/pentapass/crypto/age"
+	. "github.com/k4lipso/pentapass/internal/log"
 )
 
 var (
 	topicNameFlag = "pentapass"
-	logger    = logging.Logger("globaldb")
 	Listen = libp2p.ListenAddrStrings("/ip4/0.0.0.0/tcp/0")
 )
 
@@ -53,32 +52,32 @@ func SetupLibp2pHost(ctx context.Context, dbPath string) (host host.Host, dht *d
 	if os.IsNotExist(err) {
 		priv, _, err = crypto.GenerateKeyPair(crypto.Ed25519, 1)
 		if err != nil {
-			logger.Fatal(err)
+			Logger.Fatal(err)
 		}
 		data, err := crypto.MarshalPrivateKey(priv)
 		if err != nil {
-			logger.Fatal(err)
+			Logger.Fatal(err)
 		}
 		err = os.WriteFile(keyPath, data, 0400)
 		if err != nil {
-			logger.Fatal(err)
+			Logger.Fatal(err)
 		}
 	} else if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	} else {
 		key, err := os.ReadFile(keyPath)
 		if err != nil {
-			logger.Fatal(err)
+			Logger.Fatal(err)
 		}
 		priv, err = crypto.UnmarshalPrivateKey(key)
 		if err != nil {
-			logger.Fatal(err)
+			Logger.Fatal(err)
 		}
 
 	}
 
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	}
 
 	//whitelistedPeers := map[peer.ID]struct{} {
@@ -122,22 +121,19 @@ type WhitelistConnectionGater struct {
 }
 
 func (wg *WhitelistConnectionGater) InterceptPeerDial(p peer.ID) (allowed bool) {
-	//fmt.Println("PeerDial")
 	//_, allowed = wg.whitelistedPeers[p]
 	return true
 }
 
 func (wg *WhitelistConnectionGater) InterceptAddrDial(p peer.ID, addr multiaddr.Multiaddr) (bool) {
-	//fmt.Println("AddrDial")
 	return wg.InterceptPeerDial(p)
 }
 
 func (wg *WhitelistConnectionGater) InterceptAccept(conn network.ConnMultiaddrs) (bool) {
-	//fmt.Println("InterceptAccept")
 	addr, err := peer.AddrInfoFromP2pAddr(conn.RemoteMultiaddr())
 
 	if err != nil {
-		fmt.Printf("Error InterceptAccept: %s\n", err)
+		Logger.Debugf("Error InterceptAccept: %s\n", err)
 		return false
 	}
 
@@ -145,12 +141,10 @@ func (wg *WhitelistConnectionGater) InterceptAccept(conn network.ConnMultiaddrs)
 }
 
 func (wg *WhitelistConnectionGater) InterceptSecured(direction network.Direction, p peer.ID, conn network.ConnMultiaddrs) (allow bool) {
-	//fmt.Println("InterceptSecured")
 	return wg.InterceptPeerDial(p)
 }
 
 func (wg *WhitelistConnectionGater) InterceptUpgraded(conn network.Conn) (allow bool, reason control.DisconnectReason) {
-	//fmt.Println("InterceptUpgraded")
 	return wg.InterceptPeerDial(conn.RemotePeer()), 0
 }
 
@@ -180,8 +174,6 @@ type Namespace struct {
 func PeerFromString(str string) (Peer, error) {
 	parts := strings.Split(str, "/")
 
-	fmt.Println(str)
-	fmt.Println(parts)
 	if len(parts) != 2 {
 		return Peer{}, fmt.Errorf("Invalid Peer String")
 	}
@@ -322,7 +314,7 @@ func (n *Namespace) List() {
 			continue
 		}
 
-		fmt.Printf("[%s] -> %s\n", r.Key, string(val))
+		Logger.Infof("[%s] -> %s\n", r.Key, string(val))
 	}
 }
 
@@ -387,7 +379,7 @@ func (s *StorageHandler) GetSelfPeer() Peer {
 }
 
 func (s *StorageHandler) UpdateConfig() {
-	fmt.Println("Updating Config...")
+	Logger.Debug("Updating Config...")
 	s.recreateConfig()
 	s.writeConfig(s.ConfigPath, s.Config)
 }
@@ -411,7 +403,6 @@ func (s *StorageHandler) writeConfig(filename string, config []NamespaceConfig)
 	jsonData, err := json.Marshal(config)
 
 	if err != nil {
-		fmt.Printf("Error during config initialization")
 		return err
 	}
 
@@ -419,7 +410,6 @@ func (s *StorageHandler) writeConfig(filename string, config []NamespaceConfig)
 	err = os.WriteFile(filename, jsonData, 0644)
 
   if err != nil {
-		fmt.Printf("Error during config initialization")
 		return err
   }
 
@@ -473,7 +463,7 @@ func (s *StorageHandler) InitNamespaces() {
 		ns1, err := CreateNamespace(nsCfg.Id, s)
 
 		if err != nil {
-			logger.Fatal(err)
+			Logger.Fatal(err)
 		}
 
 		NamespaceMap[nsCfg.Name] = ns1
@@ -504,7 +494,7 @@ func PrintDBContent(ctx context.Context, store *badger.Datastore) {
 	
 	entries, _ := result.Rest()
 	for _, entry := range entries { 
-		fmt.Printf("Key: %s, Value: %s\n", entry.Key, string(entry.Value))
+		Logger.Infof("Key: %s, Value: %s\n", entry.Key, string(entry.Value))
 	}
 }
 
@@ -521,7 +511,7 @@ func (s *StorageHandler) DeleteNamespace(ID string) error {
 	ns, ok := s.Namespaces[ID]
 
 	if !ok {
-		fmt.Print("DeleteNamespace that does not exists")
+		Logger.Debug("DeleteNamespace that does not exists")
 		return nil
 	}
 
@@ -551,42 +541,42 @@ func (s *StorageHandler) AddNamespace(Name string) (*Namespace, error) {
 }
 
 func CreateNamespace(ID string, storageHandler *StorageHandler) (*Namespace, error) {
-	fmt.Printf("Creating Namespace %s\n", ID)
+	Logger.Debugf("Creating Namespace %s\n", ID)
 	err := storageHandler.PubSub.RegisterTopicValidator(
 		ID, //== topicName
 		func(ctx context.Context, id peer.ID, msg *pubsub.Message) bool {
-			fmt.Printf("PubSubmsg TOPIC: %s, PEER: %s\n", ID, id)
+			Logger.Debugf("PubSubmsg TOPIC: %s, PEER: %s\n", ID, id)
 			signer := msg.GetFrom()
 			trusted := IsTrustedPeer(ctx, signer, ID, storageHandler.Config)
 			if !trusted {
-				fmt.Printf("discarded pubsub message from non trusted source %s\n", signer)
+				Logger.Debugf("discarded pubsub message from non trusted source %s\n", signer)
 			}
 			return trusted
 		},
 	)
 	if err != nil {
-		logger.Errorf("error registering topic validator: %s", err)
+		Logger.Errorf("error registering topic validator: %s", err)
 	}
 
 	psubCtx, psubCancel := context.WithCancel(storageHandler.Ctx)
 	pubsubBC, err := crdt.NewPubSubBroadcaster(psubCtx, storageHandler.PubSub, ID)
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	}
 
 	opts := crdt.DefaultOptions()
-	opts.Logger = logger
+	//opts.Logger = Logger
 	opts.RebroadcastInterval = 5 * time.Second
 	opts.PutHook = func(k ds.Key, v []byte) {
-		fmt.Printf("Added: [%s]\n", k)
+		Logger.Infof("Added: [%s]\n", k)
 	}
 	opts.DeleteHook = func(k ds.Key) {
-		fmt.Printf("Removed: [%s]\n", k)
+		Logger.Infof("Removed: [%s]\n", k)
 	}
 
 	crdt, err := crdt.New(storageHandler.Store, ds.NewKey(ID), storageHandler.Ipfs, pubsubBC, opts)
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 		psubCancel()
 		return nil, err
 	}
@@ -596,7 +586,7 @@ func CreateNamespace(ID string, storageHandler *StorageHandler) (*Namespace, err
 	val, ok := PeerMap[ID]
 
 	if !ok {
-		fmt.Println("namespace config does not contain any peers")
+		Logger.Debug("namespace config does not contain any peers")
 	}
 
 	return &Namespace{ID: ID, Datastore: crdt, CancelFunc: psubCancel, ctx: storageHandler.Ctx, Key: storageHandler.Key, TrustedPeers: val}, nil
@@ -622,9 +612,9 @@ func initDHT(ctx context.Context, h host.Host) *dht.IpfsDHT {
 		go func() {
 			defer wg.Done()
 			if err := h.Connect(ctx, *peerinfo); err != nil {
-				fmt.Println("Bootstrap warning:", err)
+				Logger.Debugf("Bootstrap warning: %s", err)
 			} else {
-				fmt.Printf("Connection established with bootstrap node: %q\n", *peerinfo)
+				Logger.Debugf("Connection established with bootstrap node: %q\n", *peerinfo)
 			}
 		}()
 	}
@@ -639,10 +629,10 @@ func DiscoverPeers(ctx context.Context, h host.Host, dht *dht.IpfsDHT) {
 
 	// Look for others who have announced and attempt to connect to them
 	anyConnected := false
-	fmt.Printf("Own Id: %s\n", h.ID())
+	Logger.Debugf("Own Id: %s\n", h.ID())
 	for !anyConnected {
 		time.Sleep(2 * time.Second)
-		fmt.Println("Searching for peers...")
+		Logger.Debug("Searching for peers...")
 		peerChan, err := routingDiscovery.FindPeers(ctx, topicNameFlag)
 		if err != nil {
 			panic(err)
@@ -656,20 +646,20 @@ func DiscoverPeers(ctx context.Context, h host.Host, dht *dht.IpfsDHT) {
 				continue
 			}
 
-			fmt.Printf("Connecting to peer with id %s", peer.ID.String())
+			Logger.Debugf("Connecting to peer with id %s", peer.ID.String())
 			err := h.Connect(ctx, peer)
 			if err != nil {
-				fmt.Printf("Failed connecting to %s, error: %s\n", peer.ID, err)
+				Logger.Debugf("Failed connecting to %s, error: %s\n", peer.ID, err)
 			} else {
-				fmt.Println("Connected to:", peer.ID)
+				Logger.Debugf("Connected to: %s", peer.ID)
 			}
 		}
 	}
-	fmt.Println("Peer discovery complete")
+	Logger.Debugf("Peer discovery complete")
 }
 
 func printErr(err error) {
-	fmt.Println("error:", err)
+	Logger.Errorf("error: %s", err)
 }
 
 func ConnectedPeers(h host.Host) []*peer.AddrInfo {