use logger in passd

cmd/ppassd/ppassd.go

@@ -3,76 +3,67 @@ 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")
+	//logger    = logging.Logger("globaldb")
 )
 
-
 func main() {
 	flag.Parse()
 	ctx := context.Background()
 	data := *dbPath
 
+	InitLogger(*debug)
+
 	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 +78,7 @@ func main() {
 	Cfg, err := storageHandler.NewConfig(*dbPath + "/config.json")
 
 	if err != nil {
-		logger.Fatal(err)
+		Logger.Fatal(err)
 	}
 
 	storageHandler.Config = Cfg

internal/log/log.go

@@ -25,20 +25,24 @@ func (f *CustomTextFormatter) Format(entry *logrus.Entry) ([]byte, error) {
 }
 
 
-func InitLogger() {
-	Logger.SetFormatter(&CustomTextFormatter{
-		logrus.TextFormatter{
+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)
+	}
 
-  // Output to stdout instead of the default stderr
-  // Can be any io.Writer, see below for File example
   Logger.SetOutput(os.Stdout)
-
-  // Only log the warning severity or above.
-  Logger.SetLevel(logrus.DebugLevel)
-
 }