[CLI] upgrade urfave/cli to v2

tools/cli/admin_async_queue_commands.go

@@ -31,7 +31,7 @@
 	"github.com/uber/cadence/common/types"
 )
 
 func AdminGetAsyncWFConfig(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	domainName := getRequiredOption(c, FlagDomain)
@@ -45,20 +45,20 @@
 
 	resp, err := adminClient.GetDomainAsyncWorkflowConfiguraton(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Failed to get async wf queue config", err)
+		return PrintableError("Failed to get async wf queue config", err)
 	}
 
 	if resp == nil || resp.Configuration == nil {
 		fmt.Printf("Async workflow queue config not found for domain %s\n", domainName)
 		return nil
 	}
 
 	fmt.Printf("Async workflow queue config for domain %s:\n", domainName)
 	prettyPrintJSONObject(resp.Configuration)
 	return nil
 }
 
 func AdminUpdateAsyncWFConfig(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	domainName := getRequiredOption(c, FlagDomain)
@@ -67,7 +67,7 @@
 	var cfg types.AsyncWorkflowConfiguration
 	err := json.Unmarshal([]byte(asyncWFCfgJSON), &cfg)
 	if err != nil {
-		return ErrorAndPrint("Failed to parse async workflow config", err)
+		return PrintableError("Failed to parse async workflow config", err)
 	}
 
 	ctx, cancel := newContext(c)
@@ -80,9 +80,9 @@
 
 	_, err = adminClient.UpdateDomainAsyncWorkflowConfiguraton(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Failed to update async workflow queue config", err)
+		return PrintableError("Failed to update async workflow queue config", err)
 	}
 
 	fmt.Printf("Successfully updated async workflow queue config for domain %s\n", domainName)
 	return nil
 }

tools/cli/admin_cluster_commands.go

@@ -41,12 +41,12 @@
 func AdminAddSearchAttribute(c *cli.Context) error {
 	key := getRequiredOption(c, FlagSearchAttributesKey)
 	if err := visibility.ValidateSearchAttributeKey(key); err != nil {
-		return ErrorAndPrint("Invalid search-attribute key.", err)
+		return PrintableError("Invalid search-attribute key.", err)
 	}
 
 	valType := getRequiredIntOption(c, FlagSearchAttributesType)
 	if !isValueTypeValid(valType) {
-		return ErrorAndPrint("Unknown Search Attributes value type.", nil)
+		return PrintableError("Unknown Search Attributes value type.", nil)
 	}
 
 	// ask user for confirmation
@@ -66,28 +66,28 @@
 
 	err := adminClient.AddSearchAttribute(ctx, request)
 	if err != nil {
-		return ErrorAndPrint("Add search attribute failed.", err)
+		return PrintableError("Add search attribute failed.", err)
 	}
 	fmt.Println("Success. Note that for a multil-node Cadence cluster, DynamicConfig MUST be updated separately to whitelist the new attributes.")
 	return nil
 }
 
 // AdminDescribeCluster is used to dump information about the cluster
 func AdminDescribeCluster(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	ctx, cancel := newContext(c)
 	defer cancel()
 	response, err := adminClient.DescribeCluster(ctx)
 	if err != nil {
-		return ErrorAndPrint("Operation DescribeCluster failed.", err)
+		return PrintableError("Operation DescribeCluster failed.", err)
 	}
 
 	prettyPrintJSONObject(response)
 	return nil
 }
 
 func AdminRebalanceStart(c *cli.Context) error {
 	client := getCadenceClient(c)
 	tcCtx, cancel := newContext(c)
 	defer cancel()
@@ -99,13 +99,13 @@
 	}
 	input, err := json.Marshal(rbParams)
 	if err != nil {
-		return ErrorAndPrint("Failed to serialize params for failover workflow", err)
+		return PrintableError("Failed to serialize params for failover workflow", err)
 	}
 	memo, err := getWorkflowMemo(map[string]interface{}{
 		common.MemoKeyForOperator: getOperator(),
 	})
 	if err != nil {
-		return ErrorAndPrint("Failed to serialize memo", err)
+		return PrintableError("Failed to serialize memo", err)
 	}
 	request := &types.StartWorkflowExecutionRequest{
 		Domain:                              common.SystemLocalDomainName,
@@ -127,22 +127,22 @@
 
 	resp, err := client.StartWorkflowExecution(tcCtx, request)
 	if err != nil {
-		return ErrorAndPrint("Failed to start failover workflow", err)
+		return PrintableError("Failed to start failover workflow", err)
 	}
 	fmt.Println("Rebalance workflow started")
 	fmt.Println("wid: " + workflowID)
 	fmt.Println("rid: " + resp.GetRunID())
 	return nil
 }
 
 func AdminRebalanceList(c *cli.Context) error {
 	if err := c.Set(FlagWorkflowID, failovermanager.RebalanceWorkflowID); err != nil {
 		return err
 	}
 	if err := c.Set(FlagDomain, common.SystemLocalDomainName); err != nil {
 		return err
 	}
 	return ListWorkflow(c)
 }
 
 func intValTypeToString(valType int) string {

tools/cli/admin_commands.go

@@ -43,7 +43,7 @@
 )
 
 // AdminShowWorkflow shows history
 func AdminShowWorkflow(c *cli.Context) error {
 	tid := c.String(FlagTreeID)
 	bid := c.String(FlagBranchID)
 	sid := c.Int(FlagShardID)
@@ -63,7 +63,7 @@
 			BranchID: &bid,
 		})
 		if err != nil {
-			return ErrorAndPrint("encoding branch token err", err)
+			return PrintableError("encoding branch token err", err)
 		}
 		resp, err := histV2.ReadRawHistoryBranch(ctx, &persistence.ReadHistoryBranchRequest{
 			BranchToken: branchToken,
@@ -74,16 +74,16 @@
 			DomainName:  domainName,
 		})
 		if err != nil {
-			return ErrorAndPrint("ReadHistoryBranch err", err)
+			return PrintableError("ReadHistoryBranch err", err)
 		}
 
 		history = resp.HistoryEventBlobs
 	} else {
-		return ErrorAndPrint("need to specify TreeID/BranchID/ShardID", nil)
+		return PrintableError("need to specify TreeID/BranchID/ShardID", nil)
 	}
 
 	if len(history) == 0 {
-		return ErrorAndPrint("no events", nil)
+		return PrintableError("no events", nil)
 	}
 	allEvents := &shared.History{}
 	totalSize := 0
@@ -92,14 +92,14 @@
 		fmt.Printf("======== batch %v, blob len: %v ======\n", idx+1, len(b.Data))
 		internalHistoryBatch, err := serializer.DeserializeBatchEvents(b)
 		if err != nil {
-			return ErrorAndPrint("DeserializeBatchEvents err", err)
+			return PrintableError("DeserializeBatchEvents err", err)
 		}
 		historyBatch := thrift.FromHistoryEventArray(internalHistoryBatch)
 		allEvents.Events = append(allEvents.Events, historyBatch...)
 		for _, e := range historyBatch {
 			jsonstr, err := json.Marshal(e)
 			if err != nil {
-				return ErrorAndPrint("json.Marshal err", err)
+				return PrintableError("json.Marshal err", err)
 			}
 			fmt.Println(string(jsonstr))
 		}
@@ -109,13 +109,13 @@
 	if outputFileName != "" {
 		data, err := json.Marshal(allEvents.Events)
 		if err != nil {
-			return ErrorAndPrint("Failed to serialize history data.", err)
+			return PrintableError("Failed to serialize history data.", err)
 		}
 		if err := ioutil.WriteFile(outputFileName, data, 0666); err != nil {
-			return ErrorAndPrint("Failed to export history data file.", err)
+			return PrintableError("Failed to export history data file.", err)
 		}
 	}
 	return nil
 }
 
 // AdminDescribeWorkflow describe a new workflow execution for admin
@@ -132,14 +132,14 @@
 		ms := persistence.WorkflowMutableState{}
 		err := json.Unmarshal([]byte(msStr), &ms)
 		if err != nil {
-			return ErrorAndPrint("json.Unmarshal err", err)
+			return PrintableError("json.Unmarshal err", err)
 		}
 		currentBranchToken := ms.ExecutionInfo.BranchToken
 		if ms.VersionHistories != nil {
 			// if VersionHistories is set, then all branch infos are stored in VersionHistories
 			currentVersionHistory, err := ms.VersionHistories.GetCurrentVersionHistory()
 			if err != nil {
-				return ErrorAndPrint("ms.VersionHistories.GetCurrentVersionHistory err", err)
+				return PrintableError("ms.VersionHistories.GetCurrentVersionHistory err", err)
 			}
 			currentBranchToken = currentVersionHistory.GetBranchToken()
 		}
@@ -148,7 +148,7 @@
 		thriftrwEncoder := codec.NewThriftRWEncoder()
 		err = thriftrwEncoder.Decode(currentBranchToken, &branchInfo)
 		if err != nil {
-			return ErrorAndPrint("thriftrwEncoder.Decode err", err)
+			return PrintableError("thriftrwEncoder.Decode err", err)
 		}
 		prettyPrintJSONObject(branchInfo)
 		if ms.ExecutionInfo.AutoResetPoints != nil {
@@ -184,14 +184,14 @@
 		},
 	)
 	if err != nil {
-		return nil, ErrorAndPrint("Get workflow mutableState failed", err)
+		return nil, PrintableError("Get workflow mutableState failed", err)
 	}
 	return resp, nil
 }
 
 // AdminMaintainCorruptWorkflow deletes workflow from DB if it's corrupt
 func AdminMaintainCorruptWorkflow(c *cli.Context) error {
 	domainName := getRequiredOption(c, FlagDomain)
 	workflowID := c.String(FlagWorkflowID)
 	runID := c.String(FlagRunID)
 	skipErrors := c.Bool(FlagSkipErrorMode)
@@ -210,15 +210,15 @@
 	defer cancel()
 	_, err := adminClient.MaintainCorruptWorkflow(ctx, request)
 	if err != nil {
-		return ErrorAndPrint("Operation AdminMaintainCorruptWorkflow failed.", err)
+		return PrintableError("Operation AdminMaintainCorruptWorkflow failed.", err)
 	}
 
 	return err
 }
 
 // AdminDeleteWorkflow delete a workflow execution for admin
 func AdminDeleteWorkflow(c *cli.Context) error {
 	domain := getRequiredOption(c, FlagDomain)
 	wid := getRequiredOption(c, FlagWorkflowID)
 	rid := c.String(FlagRunID)
 	remote := c.Bool(FlagRemote)
@@ -243,27 +243,27 @@
 		}
 		_, err := adminClient.DeleteWorkflow(ctx, request)
 		if err != nil {
-			return ErrorAndPrint("Operation AdminMaintainCorruptWorkflow failed.", err)
+			return PrintableError("Operation AdminMaintainCorruptWorkflow failed.", err)
 		}
 		return nil
 	}
 
 	resp, err := describeMutableState(c)
 	if err != nil {
 		return err
 	}
 	msStr := resp.GetMutableStateInDatabase()
 	ms := persistence.WorkflowMutableState{}
 	err = json.Unmarshal([]byte(msStr), &ms)
 	if err != nil {
-		return ErrorAndPrint("json.Unmarshal err", err)
+		return PrintableError("json.Unmarshal err", err)
 	}
 	domainID := ms.ExecutionInfo.DomainID
 
 	shardID := resp.GetShardID()
 	shardIDInt, err := strconv.Atoi(shardID)
 	if err != nil {
-		return ErrorAndPrint("strconv.Atoi(shardID) err", err)
+		return PrintableError("strconv.Atoi(shardID) err", err)
 	}
 	histV2 := initializeHistoryManager(c)
 	defer histV2.Close()
@@ -283,7 +283,7 @@
 	for _, branchToken := range branchTokens {
 		err = thriftrwEncoder.Decode(branchToken, &branchInfo)
 		if err != nil {
-			return ErrorAndPrint("thriftrwEncoder.Decode err", err)
+			return PrintableError("thriftrwEncoder.Decode err", err)
 		}
 		fmt.Println("deleting history events for ...")
 		prettyPrintJSONObject(branchInfo)
@@ -296,7 +296,7 @@
 			if skipError {
 				fmt.Println("failed to delete history, ", err)
 			} else {
-				return ErrorAndPrint("DeleteHistoryBranch err", err)
+				return PrintableError("DeleteHistoryBranch err", err)
 			}
 		}
 	}
@@ -313,7 +313,7 @@
 		if skipError {
 			fmt.Println("delete mutableState row failed, ", err)
 		} else {
-			return ErrorAndPrint("delete mutableState row failed", err)
+			return PrintableError("delete mutableState row failed", err)
 		}
 	}
 	fmt.Println("delete mutableState row successfully")
@@ -329,19 +329,19 @@
 		if skipError {
 			fmt.Println("delete current row failed, ", err)
 		} else {
-			return ErrorAndPrint("delete current row failed", err)
+			return PrintableError("delete current row failed", err)
 		}
 	}
 	fmt.Println("delete current row successfully")
 	return nil
 }
 
 // AdminGetDomainIDOrName map domain
 func AdminGetDomainIDOrName(c *cli.Context) error {
 	domainID := c.String(FlagDomainID)
 	domainName := c.String(FlagDomain)
 	if len(domainID) == 0 && len(domainName) == 0 {
-		return ErrorAndPrint("Need either domainName or domainID", nil)
+		return PrintableError("Need either domainName or domainID", nil)
 	}
 
 	domainManager := initializeDomainManager(c)
@@ -351,34 +351,34 @@
 	if len(domainID) > 0 {
 		domain, err := domainManager.GetDomain(ctx, &persistence.GetDomainRequest{ID: domainID})
 		if err != nil {
-			return ErrorAndPrint("SelectDomain error", err)
+			return PrintableError("SelectDomain error", err)
 		}
 		fmt.Printf("domainName for domainID %v is %v \n", domainID, domain.Info.Name)
 	} else {
 		domain, err := domainManager.GetDomain(ctx, &persistence.GetDomainRequest{Name: domainName})
 		if err != nil {
-			return ErrorAndPrint("SelectDomain error", err)
+			return PrintableError("SelectDomain error", err)
 		}
 		fmt.Printf("domainID for domainName %v is %v \n", domain.Info.ID, domainID)
 	}
 	return nil
 }
 
 // AdminGetShardID get shardID
 func AdminGetShardID(c *cli.Context) error {
 	wid := getRequiredOption(c, FlagWorkflowID)
 	numberOfShards := c.Int(FlagNumberOfShards)
 
 	if numberOfShards <= 0 {
-		return ErrorAndPrint("numberOfShards is required", nil)
+		return PrintableError("numberOfShards is required", nil)
 	}
 	shardID := common.WorkflowIDToHistoryShard(wid, numberOfShards)
 	fmt.Printf("ShardID for workflowID: %v is %v \n", wid, shardID)
 	return nil
 }
 
 // AdminRemoveTask describes history host
 func AdminRemoveTask(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	shardID := getRequiredIntOption(c, FlagShardID)
@@ -403,13 +403,13 @@
 
 	err := adminClient.RemoveTask(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Remove task has failed", err)
+		return PrintableError("Remove task has failed", err)
 	}
 	return nil
 }
 
 // AdminDescribeShard describes shard by shard id
 func AdminDescribeShard(c *cli.Context) error {
 	sid := getRequiredIntOption(c, FlagShardID)
 
 	ctx, cancel := newContext(c)
@@ -419,15 +419,15 @@
 	getShardReq := &persistence.GetShardRequest{ShardID: sid}
 	shard, err := shardManager.GetShard(ctx, getShardReq)
 	if err != nil {
-		return ErrorAndPrint("Failed to describe shard.", err)
+		return PrintableError("Failed to describe shard.", err)
 	}
 
 	prettyPrintJSONObject(shard)
 	return nil
 }
 
 // AdminSetShardRangeID set shard rangeID by shard id
 func AdminSetShardRangeID(c *cli.Context) error {
 	sid := getRequiredIntOption(c, FlagShardID)
 	rid := getRequiredInt64Option(c, FlagRangeID)
 
@@ -437,7 +437,7 @@
 
 	getShardResp, err := shardManager.GetShard(ctx, &persistence.GetShardRequest{ShardID: sid})
 	if err != nil {
-		return ErrorAndPrint("Failed to get shardInfo.", err)
+		return PrintableError("Failed to get shardInfo.", err)
 	}
 
 	previousRangeID := getShardResp.ShardInfo.RangeID
@@ -451,15 +451,15 @@
 		PreviousRangeID: previousRangeID,
 		ShardInfo:       updatedShardInfo,
 	}); err != nil {
-		return ErrorAndPrint("Failed to reset shard rangeID.", err)
+		return PrintableError("Failed to reset shard rangeID.", err)
 	}
 
 	fmt.Printf("Successfully updated rangeID from %v to %v for shard %v.\n", previousRangeID, rid, sid)
 	return nil
 }
 
 // AdminCloseShard closes shard by shard id
 func AdminCloseShard(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 	sid := getRequiredIntOption(c, FlagShardID)
 
@@ -471,9 +471,9 @@
 
 	err := adminClient.CloseShard(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Close shard task has failed", err)
+		return PrintableError("Close shard task has failed", err)
 	}
 	return nil
 }
 
 type ShardRow struct {
@@ -482,7 +482,7 @@
 }
 
 // AdminDescribeShardDistribution describes shard distribution
 func AdminDescribeShardDistribution(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	ctx, cancel := newContext(c)
@@ -495,14 +495,14 @@
 
 	resp, err := adminClient.DescribeShardDistribution(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Shard list failed", err)
+		return PrintableError("Shard list failed", err)
 	}
 
 	fmt.Printf("Total Number of Shards: %d \n", resp.NumberOfShards)
 	fmt.Printf("Number of Shards Returned: %d \n", len(resp.Shards))
 
 	if len(resp.Shards) == 0 {
 		return nil
 	}
 
 	table := []ShardRow{}
@@ -510,8 +510,8 @@
 	outputPageSize := tableRenderSize
 	for shardID, identity := range resp.Shards {
 		if outputPageSize == 0 {
 			if err := Render(c, table, opts); err != nil {
 				return fmt.Errorf("error rendering: %w", err)
 			}
 			table = []ShardRow{}
 			if !showNextPage() {
@@ -523,11 +523,11 @@
 		outputPageSize--
 	}
 	// output the remaining rows
 	return Render(c, table, opts)
 }
 
 // AdminDescribeHistoryHost describes history host
 func AdminDescribeHistoryHost(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	wid := c.String(FlagWorkflowID)
@@ -536,7 +536,7 @@
 	printFully := c.Bool(FlagPrintFullyDetail)
 
 	if len(wid) == 0 && !c.IsSet(FlagShardID) && len(addr) == 0 {
-		return ErrorAndPrint("at least one of them is required to provide to lookup host: workflowID, shardID and host address", nil)
+		return PrintableError("at least one of them is required to provide to lookup host: workflowID, shardID and host address", nil)
 	}
 
 	ctx, cancel := newContext(c)
@@ -555,21 +555,21 @@
 
 	resp, err := adminClient.DescribeHistoryHost(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Describe history host failed", err)
+		return PrintableError("Describe history host failed", err)
 	}
 
 	if !printFully {
 		resp.ShardIDs = nil
 	}
 	prettyPrintJSONObject(resp)
 	return nil
 }
 
 // AdminRefreshWorkflowTasks refreshes all the tasks of a workflow
 func AdminRefreshWorkflowTasks(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	domain := getRequiredOption(c, FlagDomain)
 	wid := getRequiredOption(c, FlagWorkflowID)
 	rid := c.String(FlagRunID)
 
@@ -584,14 +584,14 @@
 		},
 	})
 	if err != nil {
-		return ErrorAndPrint("Refresh workflow task failed", err)
+		return PrintableError("Refresh workflow task failed", err)
 	}
 	fmt.Println("Refresh workflow task succeeded.")
 	return nil
 }
 
 // AdminResetQueue resets task processing queue states
 func AdminResetQueue(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	shardID := getRequiredIntOption(c, FlagShardID)
@@ -609,14 +609,14 @@
 
 	err := adminClient.ResetQueue(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Failed to reset queue", err)
+		return PrintableError("Failed to reset queue", err)
 	}
 	fmt.Println("Reset queue state succeeded")
 	return nil
 }
 
 // AdminDescribeQueue describes task processing queue states
 func AdminDescribeQueue(c *cli.Context) error {
 	adminClient := cFactory.ServerAdminClient(c)
 
 	shardID := getRequiredIntOption(c, FlagShardID)
@@ -634,11 +634,11 @@
 
 	resp, err := adminClient.DescribeQueue(ctx, req)
 	if err != nil {
-		return ErrorAndPrint("Failed to describe queue", err)
+		return PrintableError("Failed to describe queue", err)
 	}
 
 	for _, state := range resp.ProcessingQueueStates {
 		fmt.Println(state)
 	}
 	return nil
 }