Delay flag-Parse() for merge later

config/defaults.go

@@ -2,13 +2,13 @@ package config
 
 import (
 	"time"
-
-	"github.com/bahner/go-ma"
-	"go.deanishe.net/env"
 )
 
 const (
 
+	// The name of the application
+	name = "go-ma-actor"
+
 	// The default entity to connect to.
 	GO_MA_ACTOR_KEYSET_VAR                   = "GO_MA_ACTOR_KEYSET"
 	GO_MA_ACTOR_ENTITY_VAR                   = "GO_MA_ACTOR_ENTITY"
@@ -21,33 +21,18 @@ const (
 	GO_MA_ACTOR_LOGLEVEL_VAR                 = "GO_MA_ACTOR_LOGLEVEL"
 	GO_MA_ACTOR_LOGFILE_VAR                  = "GO_MA_ACTOR_LOGFILE"
 
-	defaultLowWaterMark  int = 3 // This will be used for the connection manager and the number of peers to search for
+	defaultLowWaterMark  int = 3
 	defaultHighWaterMark int = 10
 	defaultDesiredPeers  int = 3
 
 	defaultDiscoveryTimeout       time.Duration = time.Second * 30
 	defaultConnMgrGrace           time.Duration = time.Minute * 1
 	defaultDiscoveryRetryInterval time.Duration = time.Second * 1
-)
-
-var (
-	logLevel string = env.Get(ma.LOGLEVEL_VAR, "info")
-	logfile  string = env.Get(ma.LOGFILE_VAR, name+".log")
-
-	desiredPeers  int = env.GetInt(GO_MA_ACTOR_DESIRED_PEERS_VAR, defaultDesiredPeers)
-	highWaterMark int = env.GetInt(GO_MA_ACTOR_HIGH_WATERMARK_VAR, defaultHighWaterMark)
-	lowWaterMark  int = env.GetInt(GO_MA_ACTOR_LOW_WATERMARK_VAR, defaultLowWaterMark)
-
-	connmgrGracePeriod     time.Duration = env.GetDuration(GO_MA_ACTOR_CONNMGR_GRACE_VAR, defaultConnMgrGrace)
-	discoveryTimeout       time.Duration = env.GetDuration(GO_MA_ACTOR_DISCOVERY_TIMEOUT_VAR, defaultDiscoveryTimeout)
-	discoveryRetryInterval time.Duration = env.GetDuration(GO_MA_ACTOR_DISCOVERY_RETRY_INTERVAL_VAR, defaultDiscoveryRetryInterval)
-
-	// What we want to communicate with initially
-	entity string = env.Get(GO_MA_ACTOR_ENTITY_VAR, "")
 
-	// Actor
-	keyset_string string = env.Get(GO_MA_ACTOR_KEYSET_VAR, "")
+	defaultLogLevel string = "info"
+	defaultLogfile  string = name + ".log"
 
-	// Nick is only used for keyset generation. Must be a valid NanoID.
-	nick string = env.Get("USER")
+	defaultNick   string = "ghost"
+	defaultKeyset string = ""
+	defaultEntity string = ""
 )

config/entity.go

@@ -0,0 +1,16 @@
+package config
+
+import (
+	"flag"
+
+	"go.deanishe.net/env"
+)
+
+var (
+	entity = flag.String("entity", env.Get(GO_MA_ACTOR_ENTITY_VAR, defaultEntity),
+		"DID of the entity to communicate with. You can use environment variable "+GO_MA_ACTOR_ENTITY_VAR+" to set this.")
+)
+
+func GetEntity() string {
+	return *entity
+}

config/keyset.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"flag"
 	"fmt"
 	"os"
 
@@ -9,33 +10,51 @@ import (
 	"github.com/bahner/go-ma/key/set"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
+	"go.deanishe.net/env"
 )
 
-func initKeyset(keyset_string string) {
+var (
+
+	// Booleans with control flow
+	generate     = flag.Bool("generate", false, "Generates one-time keyset and uses it")
+	genenv       = flag.Bool("genenv", false, "Generates a keyset and prints it to stdout and uses it")
+	publish      = flag.Bool("publish", false, "Publishes keyset to IPFS when using genenv or generate")
+	forcePublish = flag.Bool("forcePublish", false, "Like -publish, force publication even if keyset is already published. This is probably the one you want.")
+
+	// Entities
+	nick          = flag.String("nick", env.Get("USER", defaultNick), "Nickname to use in character creation")
+	keyset        *set.Keyset
+	keyset_string = flag.String("keyset", env.Get(GO_MA_ACTOR_KEYSET_VAR, defaultKeyset),
+		"Base58 encoded *secret* keyset used to identify the client. You. You can use environment variable "+GO_MA_ACTOR_KEYSET_VAR+" to set this.")
+)
+
+func InitKeyset() {
+
+	keyset = GetKeyset()
 
 	var err error
 
 	// Generate a new keysets if requested
 	if *generate || *genenv {
-		log.Debugf("config.initKeyset: Generating new keyset for %s", nick)
-		keyset_string = generateKeyset()
+		log.Debugf("config.initKeyset: Generating new keyset for %s", *nick)
+		*keyset_string = generateKeyset()
 	}
 
-	log.Debugf("config.initKeyset: %s", keyset_string)
+	log.Debugf("config.initKeyset: %s", *keyset_string)
 	// Create the actor keyset
-	if keyset_string == "" {
+	if *keyset_string == "" {
 		log.Errorf("config.initKeyset: You need to define actorKeyset or generate a new one.")
 		os.Exit(64) // EX_USAGE
 	}
 
-	keyset, err = set.Unpack(keyset_string)
+	keyset, err = set.Unpack(*keyset_string)
 	if err != nil {
 		log.Errorf("config.initKeyset: Failed to unpack keyset: %v", err)
 		os.Exit(65) // EX_DATAERR
 	}
 
 	if *publish || *forcePublish {
-		if keyset_string != "" {
+		if *keyset_string != "" {
 			publishIdentity(keyset)
 		} else {
 			log.Errorf("No actor keyset to publish.")
@@ -50,12 +69,12 @@ func initKeyset(keyset_string string) {
 
 func generateKeyset() string {
 
-	if nick == "ghost" {
+	if *nick == "ghost" {
 		log.Errorf("You need to set a nick when generating an identity.")
 		os.Exit(64) // EX_USAGE
 	}
 
-	ks, err := set.New(nick, *forcePublish)
+	ks, err := set.New(*nick, *forcePublish)
 	if err != nil {
 		log.Errorf("Failed to generate new keyset: %v", err)
 		os.Exit(70) // EX_SOFTWARE
@@ -113,3 +132,20 @@ func GetKeyset() *set.Keyset {
 func GetIPNSKey() *ipns.Key {
 	return keyset.IPNSKey
 }
+
+func GetKeysetString() string {
+	return *keyset_string
+}
+
+func GetNick() string {
+	return *nick
+}
+
+func GetPublish() bool {
+
+	return *publish
+}
+
+func GetForcePublish() bool {
+	return *forcePublish
+}

config/logger.go

@@ -0,0 +1,46 @@
+package config
+
+import (
+	"flag"
+	"os"
+
+	log "github.com/sirupsen/logrus"
+	"go.deanishe.net/env"
+)
+
+var (
+
+	// Logging
+	logLevel = flag.String("loglevel", env.Get(GO_MA_ACTOR_LOGLEVEL_VAR, defaultLogLevel),
+		"Loglevel to use for application. You can use environment variable "+GO_MA_ACTOR_LOGLEVEL_VAR+" to set this.")
+	logfile = flag.String("logfile", env.Get(GO_MA_ACTOR_LOGFILE_VAR, defaultLogfile),
+		"Logfile to use for application. You can use environment variable "+GO_MA_ACTOR_LOGFILE_VAR+" to set this.")
+)
+
+func InitLogging() {
+
+	// Init logger
+	level, err := log.ParseLevel(*logLevel)
+	if err != nil {
+		log.Error(err)
+		os.Exit(64) // EX_USAGE
+	}
+	log.SetLevel(level)
+	file, err := os.OpenFile(name+".log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		log.Errorf("Failed to open log file: %v", err)
+		os.Exit(73) // EX_CANTCREAT
+	}
+	log.SetOutput(file)
+
+	log.Info("Logger initialized")
+
+}
+
+func GetLogLevel() string {
+	return *logLevel
+}
+
+func GetLogFile() string {
+	return *logfile
+}