Merge branch 'CmdFlags' into 'release'

Refactor flag usage in cmd

See merge request !274

cmd/broadcast.go

@@ -48,8 +48,8 @@ var broadcastCmd = &cobra.Command{
 		/* Set up underlying crypto broadcast.Channel */
 		var channel *crypto.Channel
 		var pk *rsa.PrivateKey
-		keyPath := viper.GetString("keyPath")
-		path, err := utils.ExpandPath(viper.GetString("chanPath"))
+		keyPath := viper.GetString(broadcastKeyPathFlag)
+		path, err := utils.ExpandPath(viper.GetString(broadcastChanPathFlag))
 		if utils.Exists(path) {
 			// Load symmetric from path
 			cBytes, err := utils.ReadFile(path)
@@ -62,8 +62,8 @@ var broadcastCmd = &cobra.Command{
 			}
 		} else {
 			// Load in broadcast channel info
-			name := viper.GetString("name")
-			desc := viper.GetString("description")
+			name := viper.GetString(broadcastNameFlag)
+			desc := viper.GetString(broadcastDescriptionFlag)
 			if name == "" {
 				jww.FATAL.Panicf("Name cannot be empty")
 			} else if desc == "" {
@@ -71,7 +71,7 @@ var broadcastCmd = &cobra.Command{
 			}
 
 			var cryptChannel *crypto.Channel
-			if viper.GetBool("new") {
+			if viper.GetBool(broadcastNewFlag) {
 				// Create a new broadcast channel
 				cryptChannel, pk, err = crypto.NewChannel(name, desc, client.GetRng().GetStream())
 				if err != nil {
@@ -88,12 +88,12 @@ var broadcastCmd = &cobra.Command{
 				}
 			} else {
 				// Read rest of info from config & build object manually
-				pubKeyBytes := []byte(viper.GetString("rsaPub"))
+				pubKeyBytes := []byte(viper.GetString(broadcastRsaPubFlag))
 				pubKey, err := rsa.LoadPublicKeyFromPem(pubKeyBytes)
 				if err != nil {
 					jww.FATAL.Panicf("Failed to load public key at path: %+v", err)
 				}
-				salt := []byte(viper.GetString("salt"))
+				salt := []byte(viper.GetString(broadcastSaltFlag))
 
 				rid, err := crypto.NewChannelID(name, desc, salt, pubKeyBytes)
 				if err != nil {
@@ -154,8 +154,8 @@ var broadcastCmd = &cobra.Command{
 
 		// Select broadcast method
 		var method broadcast.Method
-		symmetric := viper.GetBool("symmetric")
-		asymmetric := viper.GetBool("asymmetric")
+		symmetric := viper.GetBool(broadcastSymmetricFlag)
+		asymmetric := viper.GetBool(broadcastAsymmetricFlag)
 		if symmetric && asymmetric {
 			jww.FATAL.Panicf("Cannot simultaneously broadcast symmetric & asymmetric")
 		}
@@ -169,7 +169,7 @@ var broadcastCmd = &cobra.Command{
 		bcl, err := broadcast.NewBroadcastChannel(*channel, cb, client.GetCmix(), client.GetRng(), broadcast.Param{Method: method})
 
 		/* Create properly sized broadcast message */
-		message := viper.GetString("broadcast")
+		message := viper.GetString(broadcastFlag)
 		fmt.Println(message)
 		var broadcastMessage []byte
 		if message != "" {
@@ -202,8 +202,8 @@ var broadcastCmd = &cobra.Command{
 		}
 
 		/* Receive broadcast messages over the channel */
-		waitSecs := viper.GetUint("waitTimeout")
-		expectedCnt := viper.GetUint("receiveCount")
+		waitSecs := viper.GetUint(waitTimeoutFlag)
+		expectedCnt := viper.GetUint(receiveCountFlag)
 		waitTimeout := time.Duration(waitSecs) * time.Second
 		receivedCount := uint(0)
 		done := false
@@ -239,45 +239,45 @@ var broadcastCmd = &cobra.Command{
 
 func init() {
 	// Single-use subcommand options
-	broadcastCmd.Flags().StringP("name", "", "",
+	broadcastCmd.Flags().StringP(broadcastNameFlag, "", "",
 		"Symmetric channel name")
-	_ = viper.BindPFlag("name", broadcastCmd.Flags().Lookup("name"))
+	bindFlagHelper(broadcastNameFlag, broadcastCmd)
 
-	broadcastCmd.Flags().StringP("rsaPub", "", "",
+	broadcastCmd.Flags().StringP(broadcastRsaPubFlag, "", "",
 		"Broadcast channel rsa pub key")
-	_ = viper.BindPFlag("rsaPub", broadcastCmd.Flags().Lookup("rsaPub"))
+	bindFlagHelper(broadcastRsaPubFlag, broadcastCmd)
 
-	broadcastCmd.Flags().StringP("salt", "", "",
+	broadcastCmd.Flags().StringP(broadcastSaltFlag, "", "",
 		"Broadcast channel salt")
-	_ = viper.BindPFlag("salt", broadcastCmd.Flags().Lookup("salt"))
+	bindFlagHelper(broadcastSaltFlag, broadcastCmd)
 
-	broadcastCmd.Flags().StringP("description", "", "",
+	broadcastCmd.Flags().StringP(broadcastDescriptionFlag, "", "",
 		"Broadcast channel description")
-	_ = viper.BindPFlag("description", broadcastCmd.Flags().Lookup("description"))
+	bindFlagHelper(broadcastDescriptionFlag, broadcastCmd)
 
-	broadcastCmd.Flags().StringP("chanPath", "", "",
+	broadcastCmd.Flags().StringP(broadcastChanPathFlag, "", "",
 		"Broadcast channel output path")
-	_ = viper.BindPFlag("chanPath", broadcastCmd.Flags().Lookup("chanPath"))
+	bindFlagHelper(broadcastChanPathFlag, broadcastCmd)
 
-	broadcastCmd.Flags().StringP("keyPath", "", "",
+	broadcastCmd.Flags().StringP(broadcastKeyPathFlag, "", "",
 		"Broadcast channel private key output path")
-	_ = viper.BindPFlag("keyPath", broadcastCmd.Flags().Lookup("keyPath"))
+	bindFlagHelper(broadcastKeyPathFlag, broadcastCmd)
 
-	broadcastCmd.Flags().BoolP("new", "", false,
+	broadcastCmd.Flags().BoolP(broadcastNewFlag, "", false,
 		"Create new broadcast channel")
-	_ = viper.BindPFlag("new", broadcastCmd.Flags().Lookup("new"))
+	bindFlagHelper(broadcastNewFlag, broadcastCmd)
 
-	broadcastCmd.Flags().StringP("broadcast", "", "",
+	broadcastCmd.Flags().StringP(broadcastFlag, "", "",
 		"Message contents for broadcast")
-	_ = viper.BindPFlag("broadcast", broadcastCmd.Flags().Lookup("broadcast"))
+	bindFlagHelper(broadcastFlag, broadcastCmd)
 
-	broadcastCmd.Flags().BoolP("symmetric", "", false,
+	broadcastCmd.Flags().BoolP(broadcastSymmetricFlag, "", false,
 		"Set broadcast method to symmetric")
-	_ = viper.BindPFlag("symmetric", broadcastCmd.Flags().Lookup("symmetric"))
+	bindFlagHelper(broadcastSymmetricFlag, broadcastCmd)
 
-	broadcastCmd.Flags().BoolP("asymmetric", "", false,
+	broadcastCmd.Flags().BoolP(broadcastAsymmetricFlag, "", false,
 		"Set broadcast method to asymmetric")
-	_ = viper.BindPFlag("asymmetric", broadcastCmd.Flags().Lookup("asymmetric"))
+	bindFlagHelper(broadcastAsymmetricFlag, broadcastCmd)
 
 	rootCmd.AddCommand(broadcastCmd)
 }

cmd/callbacks.go

@@ -48,7 +48,7 @@ func (a *authCallbacks) Request(requestor contact.Contact,
 	if a.autoConfirm {
 		jww.INFO.Printf("Channel Request: %s",
 			requestor.ID)
-		if viper.GetBool("verify-sends") { // Verify message sends were successful
+		if viper.GetBool(verifySendFlag) { // Verify message sends were successful
 			acceptChannelVerified(messenger, requestor.ID, a.params)
 		} else {
 			acceptChannel(messenger, requestor.ID)

cmd/deployment.go

+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx network SEZC                                          //
+//                                                                           //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file                                                              //
+///////////////////////////////////////////////////////////////////////////////
+
+package cmd
+
+// Deployment environment constants for the download-ndf code path
+const (
+	mainnet = "mainnet"
+	release = "release"
+	dev     = "dev"
+	testnet = "testnet"
+)
+
+// URL constants pointing to the NDF of the associated deployment environment
+// requested for the download-ndf code path.
+const (
+	mainNetUrl = "https://elixxir-bins.s3.us-west-1.amazonaws.com/ndf/mainnet.json"
+	releaseUrl = "https://elixxir-bins.s3.us-west-1.amazonaws.com/ndf/release.json"
+	devUrl     = "https://elixxir-bins.s3.us-west-1.amazonaws.com/ndf/default.json"
+	testNetUrl = "https://elixxir-bins.s3.us-west-1.amazonaws.com/ndf/testnet.json"
+)
+
+// Certificates for deployment environments. Used to verify NDF signatures.
+const (
+	mainNetCert = `-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`
+	releaseCert = `-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`
+	devCert = `-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----`
+	testNetCert = ``
+)

cmd/fileTransfer.go

@@ -50,7 +50,7 @@ var ftCmd = &cobra.Command{
 		}
 
 		// Initialize the file transfer manager
-		maxThroughput := viper.GetInt("maxThroughput")
+		maxThroughput := viper.GetInt(fileMaxThroughputFlag)
 		m, receiveChan := initFileTransferManager(client, maxThroughput)
 
 		// Wait until connected or crash on timeout
@@ -81,13 +81,13 @@ var ftCmd = &cobra.Command{
 
 		// If set, send the file to the recipient
 		sendDone := make(chan struct{})
-		if viper.IsSet("sendFile") {
-			recipientContactPath := viper.GetString("sendFile")
-			filePath := viper.GetString("filePath")
-			fileType := viper.GetString("fileType")
-			filePreviewPath := viper.GetString("filePreviewPath")
-			filePreviewString := viper.GetString("filePreviewString")
-			retry := float32(viper.GetFloat64("retry"))
+		if viper.IsSet(fileSendFlag) {
+			recipientContactPath := viper.GetString(fileSendFlag)
+			filePath := viper.GetString(filePathFlag)
+			fileType := viper.GetString(fileTypeFlag)
+			filePreviewPath := viper.GetString(filePreviewPathFlag)
+			filePreviewString := viper.GetString(filePreviewStringFlag)
+			retry := float32(viper.GetFloat64(fileRetry))
 
 			sendFile(filePath, fileType, filePreviewPath, filePreviewString,
 				recipientContactPath, retry, m, sendDone)
@@ -348,43 +348,34 @@ func getContactFromFile(path string) contact.Contact {
 
 // init initializes commands and flags for Cobra.
 func init() {
-	ftCmd.Flags().String("sendFile", "",
+	ftCmd.Flags().String(fileSendFlag, "",
 		"Sends a file to a recipient with the contact file at this path.")
-	bindPFlagCheckErr("sendFile")
+	bindFlagHelper(fileSendFlag, ftCmd)
 
-	ftCmd.Flags().String("filePath", "",
+	ftCmd.Flags().String(filePathFlag, "",
 		"The path to the file to send. Also used as the file name.")
-	bindPFlagCheckErr("filePath")
+	bindFlagHelper(filePathFlag, ftCmd)
 
-	ftCmd.Flags().String("fileType", "txt",
+	ftCmd.Flags().String(fileTypeFlag, "txt",
 		"8-byte file type.")
-	bindPFlagCheckErr("fileType")
+	bindFlagHelper(fileTypeFlag, ftCmd)
 
-	ftCmd.Flags().String("filePreviewPath", "",
+	ftCmd.Flags().String(filePreviewPathFlag, "",
 		"The path to the file preview to send. Set either this flag or "+
 			"filePreviewString.")
-	bindPFlagCheckErr("filePreviewPath")
+	bindFlagHelper(filePreviewPathFlag, ftCmd)
 
-	ftCmd.Flags().String("filePreviewString", "",
+	ftCmd.Flags().String(filePreviewStringFlag, "",
 		"File preview data. Set either this flag or filePreviewPath.")
-	bindPFlagCheckErr("filePreviewString")
+	bindFlagHelper(filePreviewStringFlag, ftCmd)
 
-	ftCmd.Flags().Int("maxThroughput", 1000,
+	ftCmd.Flags().Int(fileMaxThroughputFlag, 1000,
 		"Maximum data transfer speed to send file parts (in bytes per second)")
-	bindPFlagCheckErr("maxThroughput")
+	bindFlagHelper(fileMaxThroughputFlag, ftCmd)
 
-	ftCmd.Flags().Float64("retry", 0.5,
+	ftCmd.Flags().Float64(fileRetry, 0.5,
 		"Retry rate.")
-	bindPFlagCheckErr("retry")
+	bindFlagHelper(fileRetry, ftCmd)
 
 	rootCmd.AddCommand(ftCmd)
 }
-
-// bindPFlagCheckErr binds the key to a pflag.Flag used by Cobra and prints an
-// error if one occurs.
-func bindPFlagCheckErr(key string) {
-	err := viper.BindPFlag(key, ftCmd.Flags().Lookup(key))
-	if err != nil {
-		jww.ERROR.Printf("viper.BindPFlag failed for %q: %+v", key, err)
-	}
-}

cmd/flags.go

+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx network SEZC                                          //
+//                                                                           //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file                                                              //
+///////////////////////////////////////////////////////////////////////////////
+
+package cmd
+
+// This is a comprehensive list of CLI flag name constants. Organized by
+// subcommand, with root level CLI flags at the top of the list. Newly added
+// flags for any existing or new subcommands should be listed and organized
+// here. Pulling flags using Viper should use the constants defined here.
+// todo: fill this with all existing flags, replace hardcoded references with
+//  these constants. This makes renaming them easier, as well as having
+//  a consolidated place in code for these flags.
+const (
+	//////////////// Root flags ///////////////////////////////////////////////
+
+	// Send/receive flags
+	verifySendFlag   = "verify-sends"
+	messageFlag      = "message"
+	destIdFlag       = "destid"
+	sendCountFlag    = "sendCount"
+	sendDelayFlag    = "sendDelay"
+	splitSendsFlag   = "splitSends"
+	receiveCountFlag = "receiveCount"
+	waitTimeoutFlag  = "waitTimeout"
+	unsafeFlag       = "unsafe"
+
+	// Channel flags
+	unsafeChannelCreationFlag = "unsafe-channel-creation"
+	acceptChannelFlag         = "accept-channel"
+	deleteChannelFlag         = "delete-channel"
+
+	// Request flags
+	deleteReceiveRequestsFlag = "delete-receive-requests"
+	deleteSentRequestsFlag    = "delete-sent-requests"
+	deleteAllRequestsFlag     = "delete-all-requests"
+	deleteRequestFlag         = "delete-request"
+	sendAuthRequestFlag       = "send-auth-request"
+	authTimeoutFlag           = "auth-timeout"
+
+	// Contact file flags
+	writeContactFlag = "writeContact"
+	destFileFlag     = "destfile"
+
+	// Log flags
+	logLevelFlag = "logLevel"
+	logFlag      = "log"
+
+	// Loading/establishing xxdk.E2E
+	sessionFlag       = "session"
+	passwordFlag      = "password"
+	ndfFlag           = "ndf"
+	regCodeFlag       = "regcode"
+	protoUserPathFlag = "protoUserPath"
+	protoUserOutFlag  = "protoUserOut"
+	forceLegacyFlag   = "force-legacy"
+
+	// Backup flags
+	backupOutFlag     = "backupOut"
+	backupJsonOutFlag = "backupJsonOut"
+	backupInFlag      = "backupIn"
+	backupPassFlag    = "backupPass"
+	backupIdListFlag  = "backupIdList"
+
+	// Network following/logging flags
+	verboseRoundTrackingFlag    = "verboseRoundTracking"
+	forceHistoricalRoundsFlag   = "forceHistoricalRounds"
+	slowPollingFlag             = "slowPolling"
+	forceMessagePickupRetryFlag = "forceMessagePickupRetry"
+
+	// E2E Params
+	e2eMinKeysFlag        = "e2eMinKeys"
+	e2eMaxKeysFlag        = "e2eMaxKeys"
+	e2eNumReKeysFlag      = "e2eNumReKeys"
+	e2eRekeyThresholdFlag = "e2eRekeyThreshold"
+
+	// Misc
+	sendIdFlag       = "sendid"
+	profileCpuFlag   = "profile-cpu"
+	userIdPrefixFlag = "userid-prefix"
+
+	///////////////// Broadcast subcommand flags //////////////////////////////
+	broadcastNameFlag        = "name"
+	broadcastRsaPubFlag      = "rsaPub"
+	broadcastSaltFlag        = "salt"
+	broadcastDescriptionFlag = "description"
+	broadcastChanPathFlag    = "chanPath"
+	broadcastKeyPathFlag     = "keyPath"
+	broadcastNewFlag         = "new"
+	broadcastFlag            = "broadcast"
+	broadcastSymmetricFlag   = "symmetric"
+	broadcastAsymmetricFlag  = "asymmetric"
+
+	///////////////// Connection subcommand flags /////////////////////////////
+	connectionFlag              = "connect"
+	connectionStartServerFlag   = "startServer"
+	connectionServerTimeoutFlag = "serverTimeout"
+	connectionDisconnectFlag    = "disconnect"
+	connectionAuthenticatedFlag = "authenticated"
+
+	///////////////// File Transfer subcommand flags //////////////////////////
+	fileSendFlag          = "sendFile"
+	filePathFlag          = "filePath"
+	fileTypeFlag          = "fileType"
+	filePreviewPathFlag   = "filePreviewPath"
+	filePreviewStringFlag = "filePreviewString"
+	fileMaxThroughputFlag = "maxThroughput"
+	fileRetry             = "retry"
+
+	///////////////// GetNdf subcommand flags //////////////////////////////
+	ndfGwHostFlag   = "gwhost"
+	ndfPermHostFlag = "permhost"
+	ndfCertFlag     = "cert"
+	ndfEnvFlag      = "env"
+
+	///////////////// Group subcommand flags //////////////////////////////////
+	groupCreateFlag         = "create"
+	groupNameFlag           = "name"
+	groupResendFlag         = "resend"
+	groupJoinFlag           = "join"
+	groupLeaveFlag          = "leave"
+	groupSendMessageFlag    = "sendMessage"
+	groupWaitFlag           = "wait"
+	groupReceiveTimeoutFlag = "receiveTimeout"
+	groupListFlag           = "list"
+	groupShowFlag           = "show"
+
+	///////////////// Single subcommand flags /////////////////////////////////
+	singleSendFlag        = "send"
+	singleReplyFlag       = "reply"
+	singleContactFlag     = "contact"
+	singleTagFlag         = "tag"
+	singleMaxMessagesFlag = "maxMessages"
+	singleTimeoutFlag     = "timeout"
+
+	///////////////// User Discovery subcommand flags /////////////////////////
+	udRegisterFlag       = "register"
+	udRemoveFlag         = "remove"
+	udAddPhoneFlag       = "addphone"
+	udAddEmailFlag       = "addemail"
+	udConfirmFlag        = "confirm"
+	udLookupFlag         = "lookup"
+	udSearchUsernameFlag = "searchusername"
+	udSearchEmailFlag    = "searchemail"
+	udSearchPhoneFlag    = "searchphone"
+	udBatchAddFlag       = "batchadd"
+)

cmd/getndf.go

@@ -42,10 +42,10 @@ var getNDFCmd = &cobra.Command{
 		"and print it.",
 	Args: cobra.NoArgs,
 	Run: func(cmd *cobra.Command, args []string) {
-		if viper.GetString("env") != "" {
+		if viper.IsSet(ndfEnvFlag) {
 			var ndfJSON []byte
 			var err error
-			switch viper.GetString("env") {
+			switch viper.GetString(ndfEnvFlag) {
 			case mainnet:
 				ndfJSON, err = xxdk.DownloadAndVerifySignedNdfWithUrl(mainNetUrl, mainNetCert)
 				if err != nil {
@@ -69,23 +69,23 @@ var getNDFCmd = &cobra.Command{
 				}
 			default:
 				jww.FATAL.Panicf("env flag with unknown flag (%s)",
-					viper.GetString("env"))
+					viper.GetString(ndfEnvFlag))
 			}
 			// Print to stdout
 			fmt.Printf("%s", ndfJSON)
 		} else {
 
 			// Note: getndf prints to stdout, so we default to not do that
-			logLevel := viper.GetUint("logLevel")
-			logPath := viper.GetString("log")
+			logLevel := viper.GetUint(logLevelFlag)
+			logPath := viper.GetString(logFlag)
 			if logPath == "-" || logPath == "" {
 				logPath = "getndf.log"
 			}
 			initLog(logLevel, logPath)
 			jww.INFO.Printf(Version())
-			gwHost := viper.GetString("gwhost")
-			permHost := viper.GetString("permhost")
-			certPath := viper.GetString("cert")
+			gwHost := viper.GetString(ndfGwHostFlag)
+			permHost := viper.GetString(ndfPermHostFlag)
+			certPath := viper.GetString(ndfCertFlag)
 
 			// Load the certificate
 			var cert []byte
@@ -147,25 +147,22 @@ var getNDFCmd = &cobra.Command{
 }
 
 func init() {
-	getNDFCmd.Flags().StringP("gwhost", "", "",
+	getNDFCmd.Flags().StringP(ndfGwHostFlag, "", "",
 		"Poll this gateway host:port for the NDF")
-	viper.BindPFlag("gwhost",
-		getNDFCmd.Flags().Lookup("gwhost"))
-	getNDFCmd.Flags().StringP("permhost", "", "",
+	bindFlagHelper(ndfGwHostFlag, getNDFCmd)
+
+	getNDFCmd.Flags().StringP(ndfPermHostFlag, "", "",
 		"Poll this registration host:port for the NDF")
-	viper.BindPFlag("permhost",
-		getNDFCmd.Flags().Lookup("permhost"))
+	bindFlagHelper(ndfPermHostFlag, getNDFCmd)
 
-	getNDFCmd.Flags().StringP("cert", "", "",
+	getNDFCmd.Flags().StringP(ndfCertFlag, "", "",
 		"Check with the TLS certificate at this path")
-	viper.BindPFlag("cert",
-		getNDFCmd.Flags().Lookup("cert"))
+	bindFlagHelper(ndfCertFlag, getNDFCmd)
 
-	getNDFCmd.Flags().StringP("env", "", "",
+	getNDFCmd.Flags().StringP(ndfEnvFlag, "", "",
 		"Downloads and verifies a signed NDF from a specified environment. "+
 			"Accepted environment flags include mainnet, release, testnet, and dev")
-	viper.BindPFlag("env",
-		getNDFCmd.Flags().Lookup("env"))
+	bindFlagHelper(ndfEnvFlag, getNDFCmd)
 
 	rootCmd.AddCommand(getNDFCmd)
 }

cmd/group.go

@@ -70,45 +70,45 @@ var groupCmd = &cobra.Command{
 		}
 
 		// Get group message and name
-		msgBody := []byte(viper.GetString("message"))
-		name := []byte(viper.GetString("name"))
-		timeout := viper.GetDuration("receiveTimeout")
+		msgBody := []byte(viper.GetString(messageFlag))
+		name := []byte(viper.GetString(groupNameFlag))
+		timeout := viper.GetDuration(groupReceiveTimeoutFlag)
 
-		if viper.IsSet("create") {
-			filePath := viper.GetString("create")
+		if viper.IsSet(groupCreateFlag) {
+			filePath := viper.GetString(groupCreateFlag)
 			createGroup(name, msgBody, filePath, groupManager)
 		}
 
-		if viper.IsSet("resend") {
-			groupIdString := viper.GetString("resend")
+		if viper.IsSet(groupResendFlag) {
+			groupIdString := viper.GetString(groupResendFlag)
 			resendRequests(groupIdString, groupManager)
 		}
 
-		if viper.GetBool("join") {
+		if viper.GetBool(groupJoinFlag) {
 			joinGroup(reqChan, timeout, groupManager)
 		}
 
-		if viper.IsSet("leave") {
-			groupIdString := viper.GetString("leave")
+		if viper.IsSet(groupLeaveFlag) {
+			groupIdString := viper.GetString(groupLeaveFlag)
 			leaveGroup(groupIdString, groupManager)
 		}
 
-		if viper.IsSet("sendMessage") {
-			groupIdString := viper.GetString("sendMessage")
+		if viper.IsSet(groupSendMessageFlag) {
+			groupIdString := viper.GetString(groupSendMessageFlag)
 			sendGroup(groupIdString, msgBody, groupManager)
 		}
 
-		if viper.IsSet("wait") {
-			numMessages := viper.GetUint("wait")
+		if viper.IsSet(groupWaitFlag) {
+			numMessages := viper.GetUint(groupWaitFlag)
 			messageWait(numMessages, timeout, recChan)
 		}
 
-		if viper.GetBool("list") {
+		if viper.GetBool(groupListFlag) {
 			listGroups(groupManager)
 		}
 
-		if viper.IsSet("show") {
-			groupIdString := viper.GetString("show")
+		if viper.IsSet(groupShowFlag) {
+			groupIdString := viper.GetString(groupShowFlag)
 			showGroup(groupIdString, groupManager)
 		}
 	},
@@ -312,61 +312,45 @@ func ReadLines(fileName string) []string {
 }
 
 func init() {
-	groupCmd.Flags().String("create", "",
+	groupCmd.Flags().String(groupCreateFlag, "",
 		"Create a group with from the list of contact file paths.")
-	err := viper.BindPFlag("create", groupCmd.Flags().Lookup("create"))
-	checkBindErr(err, "create")
+	bindFlagHelper(groupCreateFlag, groupCmd)
 
-	groupCmd.Flags().String("name", "Group Name",
+	groupCmd.Flags().String(groupNameFlag, "Group Name",
 		"The name of the new group to create.")
-	err = viper.BindPFlag("name", groupCmd.Flags().Lookup("name"))
-	checkBindErr(err, "name")
+	bindFlagHelper(groupNameFlag, groupCmd)
 
-	groupCmd.Flags().String("resend", "",
+	groupCmd.Flags().String(groupResendFlag, "",
 		"Resend invites for all users in this group ID.")
-	err = viper.BindPFlag("resend", groupCmd.Flags().Lookup("resend"))
-	checkBindErr(err, "resend")
+	bindFlagHelper(groupResendFlag, groupCmd)
 
-	groupCmd.Flags().Bool("join", false,
+	groupCmd.Flags().Bool(groupJoinFlag, false,
 		"Waits for group request joins the group.")
-	err = viper.BindPFlag("join", groupCmd.Flags().Lookup("join"))
-	checkBindErr(err, "join")
+	bindFlagHelper(groupJoinFlag, groupCmd)
 
-	groupCmd.Flags().String("leave", "",
+	groupCmd.Flags().String(groupLeaveFlag, "",
 		"Leave this group ID.")
-	err = viper.BindPFlag("leave", groupCmd.Flags().Lookup("leave"))
-	checkBindErr(err, "leave")
+	bindFlagHelper(groupLeaveFlag, groupCmd)
 
-	groupCmd.Flags().String("sendMessage", "",
+	groupCmd.Flags().String(groupSendMessageFlag, "",
 		"Send message to this group ID.")
-	err = viper.BindPFlag("sendMessage", groupCmd.Flags().Lookup("sendMessage"))
-	checkBindErr(err, "sendMessage")
+	bindFlagHelper(groupSendMessageFlag, groupCmd)
 
-	groupCmd.Flags().Uint("wait", 0,
+	groupCmd.Flags().Uint(groupWaitFlag, 0,
 		"Waits for number of messages to be received.")
-	err = viper.BindPFlag("wait", groupCmd.Flags().Lookup("wait"))
-	checkBindErr(err, "wait")
+	bindFlagHelper(groupWaitFlag, groupCmd)
 
-	groupCmd.Flags().Duration("receiveTimeout", time.Minute,
+	groupCmd.Flags().Duration(groupReceiveTimeoutFlag, time.Minute,
 		"Amount of time to wait for a group request or message before timing out.")
-	err = viper.BindPFlag("receiveTimeout", groupCmd.Flags().Lookup("receiveTimeout"))
-	checkBindErr(err, "receiveTimeout")
+	bindFlagHelper(groupReceiveTimeoutFlag, groupCmd)
 
-	groupCmd.Flags().Bool("list", false,
+	groupCmd.Flags().Bool(groupListFlag, false,
 		"Prints list all groups to which this client belongs.")
-	err = viper.BindPFlag("list", groupCmd.Flags().Lookup("list"))
-	checkBindErr(err, "list")
+	bindFlagHelper(groupListFlag, groupCmd)
 
-	groupCmd.Flags().String("show", "",
+	groupCmd.Flags().String(groupShowFlag, "",
 		"Prints the members of this group ID.")
-	err = viper.BindPFlag("show", groupCmd.Flags().Lookup("show"))
-	checkBindErr(err, "show")
+	bindFlagHelper(groupShowFlag, groupCmd)
 
 	rootCmd.AddCommand(groupCmd)
 }
-
-func checkBindErr(err error, key string) {
-	if err != nil {
-		jww.ERROR.Printf("viper.BindPFlag failed for %s: %+v", key, err)
-	}
-}

cmd/init.go

@@ -64,9 +64,9 @@ var initCmd = &cobra.Command{
 }
 
 func init() {
-	initCmd.Flags().StringP("userid-prefix", "", "",
+	initCmd.Flags().StringP(userIdPrefixFlag, "", "",
 		"Desired prefix of userID to brute force when running init command. Prepend (?i) for case-insensitive. Only Base64 characters are valid.")
-	_ = viper.BindPFlag("userid-prefix", initCmd.Flags().Lookup("userid-prefix"))
+	bindFlagHelper(userIdPrefixFlag, initCmd)
 
 	rootCmd.AddCommand(initCmd)
 }

cmd/precan.go

@@ -30,7 +30,7 @@ func loadOrInitPrecan(precanId uint, password []byte, storeDir string,
 	// create a new client if none exist
 	if _, err := os.Stat(storeDir); errors.Is(err, fs.ErrNotExist) {
 		// Initialize from scratch
-		ndfJson, err := ioutil.ReadFile(viper.GetString("ndf"))
+		ndfJson, err := ioutil.ReadFile(viper.GetString(ndfFlag))
 		if err != nil {
 			jww.FATAL.Panicf("%+v", err)
 		}

cmd/proto.go

@@ -28,7 +28,7 @@ func loadOrInitProto(protoUserPath string, password []byte, storeDir string,
 	// create a new client if none exist
 	if _, err := os.Stat(storeDir); errors.Is(err, fs.ErrNotExist) {
 		// Initialize from scratch
-		ndfJson, err := ioutil.ReadFile(viper.GetString("ndf"))
+		ndfJson, err := ioutil.ReadFile(viper.GetString(ndfFlag))
 		if err != nil {
 			jww.FATAL.Panicf("%+v", err)
 		}

cmd/single.go

@@ -55,7 +55,7 @@ var singleCmd = &cobra.Command{
 		waitUntilConnected(connected)
 
 		// get the tag
-		tag := viper.GetString("tag")
+		tag := viper.GetString(singleTagFlag)
 
 		// Register the callback
 		receiver := &Receiver{
@@ -88,14 +88,14 @@ var singleCmd = &cobra.Command{
 				numReg, total)
 		}
 
-		timeout := viper.GetDuration("timeout")
+		timeout := viper.GetDuration(singleTimeoutFlag)
 
 		// If the send flag is set, then send a message
-		if viper.GetBool("send") {
+		if viper.GetBool(singleSendFlag) {
 			// get message details
-			payload := []byte(viper.GetString("message"))
-			partner := readSingleUseContact("contact")
-			maxMessages := uint8(viper.GetUint("maxMessages"))
+			payload := []byte(viper.GetString(messageFlag))
+			partner := readSingleUseContact(singleContactFlag)
+			maxMessages := uint8(viper.GetUint(singleMaxMessagesFlag))
 
 			sendSingleUse(client.Cmix, partner, payload,
 				maxMessages, timeout, tag)
@@ -103,7 +103,7 @@ var singleCmd = &cobra.Command{
 
 		// If the reply flag is set, then start waiting for a
 		// message and reply when it is received
-		if viper.GetBool("reply") {
+		if viper.GetBool(singleReplyFlag) {
 			replySingleUse(timeout, receiver)
 		}
 		listener.Stop()
@@ -113,28 +113,28 @@ var singleCmd = &cobra.Command{
 func init() {
 	// Single-use subcommand options
 
-	singleCmd.Flags().Bool("send", false, "Sends a single-use message.")
-	_ = viper.BindPFlag("send", singleCmd.Flags().Lookup("send"))
+	singleCmd.Flags().Bool(singleSendFlag, false, "Sends a single-use message.")
+	bindFlagHelper(singleSendFlag, singleCmd)
 
-	singleCmd.Flags().Bool("reply", false,
+	singleCmd.Flags().Bool(singleReplyFlag, false,
 		"Listens for a single-use message and sends a reply.")
-	_ = viper.BindPFlag("reply", singleCmd.Flags().Lookup("reply"))
+	bindFlagHelper(singleReplyFlag, singleCmd)
 
-	singleCmd.Flags().StringP("contact", "c", "",
+	singleCmd.Flags().StringP(singleContactFlag, "c", "",
 		"Path to contact file to send message to.")
-	_ = viper.BindPFlag("contact", singleCmd.Flags().Lookup("contact"))
+	bindFlagHelper(singleContactFlag, singleCmd)
 
-	singleCmd.Flags().StringP("tag", "", "testTag",
+	singleCmd.Flags().StringP(singleTagFlag, "", "testTag",
 		"The tag that specifies the callback to trigger on reception.")
-	_ = viper.BindPFlag("tag", singleCmd.Flags().Lookup("tag"))
+	bindFlagHelper(singleTagFlag, singleCmd)
 
-	singleCmd.Flags().Uint8("maxMessages", 1,
+	singleCmd.Flags().Uint8(singleMaxMessagesFlag, 1,
 		"The max number of single-use response messages.")
-	_ = viper.BindPFlag("maxMessages", singleCmd.Flags().Lookup("maxMessages"))
+	bindFlagHelper(singleMaxMessagesFlag, singleCmd)
 
-	singleCmd.Flags().DurationP("timeout", "t", 30*time.Second,
+	singleCmd.Flags().DurationP(singleTimeoutFlag, "t", 30*time.Second,
 		"Duration before stopping to wait for single-use message.")
-	_ = viper.BindPFlag("timeout", singleCmd.Flags().Lookup("timeout"))
+	bindFlagHelper(singleTimeoutFlag, singleCmd)
 
 	rootCmd.AddCommand(singleCmd)
 }

cmd/ud.go

@@ -79,7 +79,7 @@ var udCmd = &cobra.Command{
 		jww.INFO.Printf("[UD] Registered user %v", userToRegister)
 
 		var newFacts fact.FactList
-		phone := viper.GetString("addphone")
+		phone := viper.GetString(udAddPhoneFlag)
 		if phone != "" {
 			f, err := fact.NewFact(fact.Phone, phone)
 			if err != nil {
@@ -88,7 +88,7 @@ var udCmd = &cobra.Command{
 			newFacts = append(newFacts, f)
 		}
 
-		email := viper.GetString("addemail")
+		email := viper.GetString(udAddEmailFlag)
 		if email != "" {
 			f, err := fact.NewFact(fact.Email, email)
 			if err != nil {
@@ -110,7 +110,7 @@ var udCmd = &cobra.Command{
 			jww.INFO.Printf("[UD] Fact Add Response: %+v", r)
 		}
 
-		confirmID := viper.GetString("confirm")
+		confirmID := viper.GetString(udConfirmFlag)
 		if confirmID != "" {
 			jww.INFO.Printf("[UD] Confirming fact: %v", confirmID)
 			err = userDiscoveryMgr.ConfirmFact(confirmID, confirmID)
@@ -131,7 +131,7 @@ var udCmd = &cobra.Command{
 
 		// Handle lookup (verification) process
 		// Note: Cryptographic verification occurs above the bindings layer
-		lookupIDStr := viper.GetString("lookup")
+		lookupIDStr := viper.GetString(udLookupFlag)
 		if lookupIDStr != "" {
 			lookupID := parseRecipient(lookupIDStr)
 			jww.INFO.Printf("[UD] Looking up %v", lookupID)
@@ -155,8 +155,8 @@ var udCmd = &cobra.Command{
 			time.Sleep(31 * time.Second)
 		}
 
-		if viper.GetString("batchadd") != "" {
-			idListFile, err := utils.ReadFile(viper.GetString("batchadd"))
+		if viper.IsSet(udBatchAddFlag) {
+			idListFile, err := utils.ReadFile(viper.GetString(udBatchAddFlag))
 			if err != nil {
 				fmt.Printf("BATCHADD: Couldn't read file: %s\n",
 					err.Error())
@@ -176,9 +176,9 @@ var udCmd = &cobra.Command{
 				jww.INFO.Printf("[UD] Authenticated channel established for %s", uid)
 			}
 		}
-		usernameSearchStr := viper.GetString("searchusername")
-		emailSearchStr := viper.GetString("searchemail")
-		phoneSearchStr := viper.GetString("searchphone")
+		usernameSearchStr := viper.GetString(udSearchUsernameFlag)
+		emailSearchStr := viper.GetString(udSearchEmailFlag)
+		phoneSearchStr := viper.GetString(udSearchPhoneFlag)
 
 		var facts fact.FactList
 		if usernameSearchStr != "" {
@@ -203,7 +203,7 @@ var udCmd = &cobra.Command{
 			facts = append(facts, f)
 		}
 
-		userToRemove := viper.GetString("remove")
+		userToRemove := viper.GetString(udRemoveFlag)
 		if userToRemove != "" {
 			f, err := fact.NewFact(fact.Username, userToRemove)
 			if err != nil {
@@ -260,44 +260,49 @@ var udCmd = &cobra.Command{
 
 func init() {
 	// User Discovery subcommand Options
-	udCmd.Flags().StringP("register", "r", "",
+	udCmd.Flags().StringP(udRegisterFlag, "r", "",
 		"Register this user with user discovery.")
-	_ = viper.BindPFlag("register", udCmd.Flags().Lookup("register"))
+	bindFlagHelper(udRegisterFlag, udCmd)
 
-	udCmd.Flags().StringP("remove", "", "",
+	udCmd.Flags().StringP(udRemoveFlag, "", "",
 		"Remove this user with user discovery.")
-	_ = viper.BindPFlag("remove", udCmd.Flags().Lookup("remove"))
+	bindFlagHelper(udRemoveFlag, udCmd)
 
-	udCmd.Flags().String("addphone", "",
+	udCmd.Flags().String(udAddPhoneFlag, "",
 		"Add phone number to existing user registration.")
-	_ = viper.BindPFlag("addphone", udCmd.Flags().Lookup("addphone"))
+	bindFlagHelper(udAddPhoneFlag, udCmd)
 
-	udCmd.Flags().StringP("addemail", "e", "",
+	udCmd.Flags().StringP(udAddEmailFlag, "e", "",
 		"Add email to existing user registration.")
-	_ = viper.BindPFlag("addemail", udCmd.Flags().Lookup("addemail"))
+	bindFlagHelper(udAddEmailFlag, udCmd)
 
-	udCmd.Flags().String("confirm", "", "Confirm fact with confirmation ID.")
-	_ = viper.BindPFlag("confirm", udCmd.Flags().Lookup("confirm"))
+	udCmd.Flags().String(udConfirmFlag, "", "Confirm fact with confirmation ID.")
+	bindFlagHelper(udConfirmFlag, udCmd)
 
-	udCmd.Flags().StringP("lookup", "u", "",
+	udCmd.Flags().StringP(udLookupFlag, "u", "",
 		"Look up user ID. Use '0x' or 'b64:' for hex and base64 representations.")
-	_ = viper.BindPFlag("lookup", udCmd.Flags().Lookup("lookup"))
+	bindFlagHelper(udLookupFlag, udCmd)
 
-	udCmd.Flags().String("searchusername", "",
+	udCmd.Flags().String(udSearchUsernameFlag, "",
 		"Search for users with this username.")
-	_ = viper.BindPFlag("searchusername", udCmd.Flags().Lookup("searchusername"))
+	bindFlagHelper(udSearchUsernameFlag, udCmd)
 
-	udCmd.Flags().String("searchemail", "",
+	udCmd.Flags().String(udSearchEmailFlag, "",
 		"Search for users with this email address.")
-	_ = viper.BindPFlag("searchemail", udCmd.Flags().Lookup("searchemail"))
+	bindFlagHelper(udSearchEmailFlag, udCmd)
 
-	udCmd.Flags().String("searchphone", "",
+	udCmd.Flags().String(udSearchPhoneFlag, "",
 		"Search for users with this email address.")
-	_ = viper.BindPFlag("searchphone", udCmd.Flags().Lookup("searchphone"))
+	bindFlagHelper(udSearchPhoneFlag, udCmd)
 
-	udCmd.Flags().String("batchadd", "",
+	udCmd.Flags().String("udBatch", "",
 		"Path to JSON marshalled slice of partner IDs that will be looked up on UD.")
-	_ = viper.BindPFlag("batchadd", udCmd.Flags().Lookup("batchadd"))
+	err := viper.BindPFlag("udBatch", udCmd.Flags().Lookup("udBatch"))
+	if err != nil {
+		jww.ERROR.Printf("viper.BindPFlag failed for %q: %+v", "udBatch", err)
+	}
+
+	bindFlagHelper(udBatchAddFlag, udCmd)
 
 	rootCmd.AddCommand(udCmd)
 }

cmd/utils.go

 package cmd
 
 import (
+	"github.com/spf13/cobra"
+	"gitlab.com/elixxir/client/e2e"
+	"gitlab.com/elixxir/client/xxdk"
 	"io/ioutil"
 	"strconv"
 	"strings"
@@ -14,6 +17,56 @@ import (
 
 // todo: go through cmd package and organize utility functions
 
+// bindFlagHelper binds the key to a pflag.Flag used by Cobra and prints an
+// error if one occurs.
+func bindFlagHelper(key string, command *cobra.Command) {
+	err := viper.BindPFlag(key, command.Flags().Lookup(key))
+	if err != nil {
+		jww.ERROR.Printf("viper.BindPFlag failed for %q: %+v", key, err)
+	}
+}
+
+func verifySendSuccess(client *xxdk.E2e, paramsE2E e2e.Params,
+	roundIDs []id.Round, partnerId *id.ID, payload []byte) bool {
+	retryChan := make(chan struct{})
+	done := make(chan struct{}, 1)
+
+	// Construct the callback function which
+	// verifies successful message send or retries
+	f := func(allRoundsSucceeded, timedOut bool,
+		rounds map[id.Round]cmix.RoundResult) {
+		printRoundResults(
+			rounds, roundIDs, payload, partnerId)
+		if !allRoundsSucceeded {
+			retryChan <- struct{}{}
+		} else {
+			done <- struct{}{}
+		}
+	}
+
+	// Monitor rounds for results
+	err := client.GetCmix().GetRoundResults(
+		paramsE2E.CMIXParams.Timeout, f, roundIDs...)
+	if err != nil {
+		jww.DEBUG.Printf("Could not verify messages were sent " +
+			"successfully, resending messages...")
+		return false
+	}
+
+	select {
+	case <-retryChan:
+		// On a retry, go to the top of the loop
+		jww.DEBUG.Printf("Messages were not sent successfully," +
+			" resending messages...")
+		return false
+	case <-done:
+		// Close channels on verification success
+		close(done)
+		close(retryChan)
+		return true
+	}
+}
+
 func parsePassword(pwStr string) []byte {
 	if strings.HasPrefix(pwStr, "0x") {
 		return getPWFromHexString(pwStr[2:])
@@ -68,7 +121,7 @@ func printRoundResults(rounds map[id.Round]cmix.RoundResult, roundIDs []id.Round
 }
 
 func writeContact(c contact.Contact) {
-	outfilePath := viper.GetString("writeContact")
+	outfilePath := viper.GetString(writeContactFlag)
 	if outfilePath == "" {
 		return
 	}
@@ -83,6 +136,7 @@ func readContact(inputFilePath string) contact.Contact {
 	if inputFilePath == "" {
 		return contact.Contact{}
 	}
+
 	data, err := ioutil.ReadFile(inputFilePath)
 	jww.INFO.Printf("Contact file size read in: %d", len(data))
 	if err != nil {