Backwards compatible activity type names (#994)

* Backwards compatible activity type names

Previously merged shortened activity type names of form {Method} is not
compatible with current users of this client, since multiple activities
in different packages with the same name results in naming conflicts.

This change reverts shortening when no activity alias (prefix) is provided.
The use of prefix shortens the name, assuming the users responsiblity to
choose proper prefix.

* Add EnableShortName option for workflow registration

Author: vytautas-karpavicius

evictiontest/workflow_cache_eviction_test.go

@@ -130,7 +130,7 @@ func (s *CacheEvictionSuite) TestResetStickyOnEviction() {
 		ret := &m.PollForDecisionTaskResponse{
 			TaskToken:              make([]byte, 5),
 			WorkflowExecution:      &m.WorkflowExecution{WorkflowId: workflowID, RunId: runID},
-			WorkflowType:           &m.WorkflowType{Name: common.StringPtr("testReplayWorkflow")},
+			WorkflowType:           &m.WorkflowType{Name: common.StringPtr("go.uber.org/cadence/evictiontest.testReplayWorkflow")},
 			History:                &m.History{Events: testEvents},
 			PreviousStartedEventId: common.Int64Ptr(5)}
 		return ret, nil

internal/activity.go

@@ -61,6 +61,10 @@ type (
 		// When an activity is part of a structure then each member of the structure becomes an activity with
 		// this Name as a prefix + activity function name.
 		Name                          string
+		// Activity type name is equal to function name instead of fully qualified
+		// name including function package (and struct type if used).
+		// This option has no effect when explicit Name is provided.
+		EnableShortName               bool
 		DisableAlreadyRegisteredCheck bool
 	}
 

internal/internal_worker.go

@@ -1091,8 +1091,6 @@ func getFunctionName(i interface{}) string {
 		return fullName
 	}
 	fullName := runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
-	elements := strings.Split(fullName, ".")
-	shortName := elements[len(elements)-1]
 	// This allows to call activities by method pointer
 	// Compiler adds -fm suffix to a function name which has a receiver
 	// Note that this works even if struct pointer used to get the function is nil
@@ -1101,7 +1099,7 @@ func getFunctionName(i interface{}) string {
 	// var a *Activities
 	// ExecuteActivity(ctx, a.Foo)
 	// will call this function which is going to return "Foo"
-	return strings.TrimSuffix(shortName, "-fm")
+	return strings.TrimSuffix(fullName, "-fm")
 }
 
 func getActivityFunctionName(r *registry, i interface{}) string {

internal/internal_worker_test.go

@@ -219,7 +219,7 @@ func (s *internalWorkerTestSuite) TestReplayWorkflowHistory() {
 	taskList := "taskList1"
 	testEvents := []*shared.HistoryEvent{
 		createTestEventWorkflowExecutionStarted(1, &shared.WorkflowExecutionStartedEventAttributes{
-			WorkflowType: &shared.WorkflowType{Name: common.StringPtr("testReplayWorkflow")},
+			WorkflowType: &shared.WorkflowType{Name: common.StringPtr("go.uber.org/cadence/internal.testReplayWorkflow")},
 			TaskList:     &shared.TaskList{Name: common.StringPtr(taskList)},
 			Input:        testEncodeFunctionArgs(getDefaultDataConverter()),
 		}),
@@ -261,7 +261,7 @@ func (s *internalWorkerTestSuite) TestReplayWorkflowHistory_LocalActivity() {
 	taskList := "taskList1"
 	testEvents := []*shared.HistoryEvent{
 		createTestEventWorkflowExecutionStarted(1, &shared.WorkflowExecutionStartedEventAttributes{
-			WorkflowType: &shared.WorkflowType{Name: common.StringPtr("testReplayWorkflowLocalActivity")},
+			WorkflowType: &shared.WorkflowType{Name: common.StringPtr("go.uber.org/cadence/internal.testReplayWorkflowLocalActivity")},
 			TaskList:     &shared.TaskList{Name: common.StringPtr(taskList)},
 			Input:        testEncodeFunctionArgs(getDefaultDataConverter()),
 		}),
@@ -379,7 +379,7 @@ func (s *internalWorkerTestSuite) testDecisionTaskHandlerHelper(params workerExe
 		createTestEventDecisionTaskStarted(3),
 	}
 
-	workflowType := "testReplayWorkflow"
+	workflowType := "go.uber.org/cadence/internal.testReplayWorkflow"
 	workflowID := "testID"
 	runID := "testRunID"
 
@@ -799,30 +799,30 @@ func (w activitiesCallingOptionsWorkflow) Execute(ctx Context, input []byte) (re
 	require.True(w.t, **rStruct2Ptr == testActivityResult{Index: 10})
 
 	// By names.
-	err = ExecuteActivity(ctx, "testActivityByteArgs", input).Get(ctx, nil)
+	err = ExecuteActivity(ctx, "go.uber.org/cadence/internal.testActivityByteArgs", input).Get(ctx, nil)
 	require.NoError(w.t, err, err)
 
 	err = ExecuteActivity(ctx, "testActivityMultipleArgs", 2, []string{"test"}, true).Get(ctx, nil)
 	require.NoError(w.t, err, err)
 
-	err = ExecuteActivity(ctx, "testActivityNoResult", 2, "test").Get(ctx, nil)
+	err = ExecuteActivity(ctx, "go.uber.org/cadence/internal.testActivityNoResult", 2, "test").Get(ctx, nil)
 	require.NoError(w.t, err, err)
 
-	err = ExecuteActivity(ctx, "testActivityNoContextArg", 2, "test").Get(ctx, nil)
+	err = ExecuteActivity(ctx, "go.uber.org/cadence/internal.testActivityNoContextArg", 2, "test").Get(ctx, nil)
 	require.NoError(w.t, err, err)
 
-	f = ExecuteActivity(ctx, "testActivityReturnString")
+	f = ExecuteActivity(ctx, "go.uber.org/cadence/internal.testActivityReturnString")
 	err = f.Get(ctx, &rString)
 	require.NoError(w.t, err, err)
 	require.Equal(w.t, "testActivity", rString, rString)
 
-	f = ExecuteActivity(ctx, "testActivityReturnEmptyString")
+	f = ExecuteActivity(ctx, "go.uber.org/cadence/internal.testActivityReturnEmptyString")
 	var r2sString string
 	err = f.Get(ctx, &r2String)
 	require.NoError(w.t, err, err)
 	require.Equal(w.t, "", r2sString)
 
-	f = ExecuteActivity(ctx, "testActivityReturnEmptyStruct")
+	f = ExecuteActivity(ctx, "go.uber.org/cadence/internal.testActivityReturnEmptyStruct")
 	err = f.Get(ctx, &r2Struct)
 	require.NoError(w.t, err, err)
 	require.Equal(w.t, testActivityResult{}, r2Struct)

internal/internal_workflow_test.go

@@ -166,6 +166,7 @@ func returnPanicWorkflow(ctx Context) (err error) {
 
 func (s *WorkflowUnitTest) Test_SplitJoinActivityWorkflow() {
 	env := s.NewTestWorkflowEnvironment()
+	env.RegisterWorkflowWithOptions(splitJoinActivityWorkflow, RegisterWorkflowOptions{Name: "splitJoinActivityWorkflow"})
 	env.RegisterActivityWithOptions(testAct, RegisterActivityOptions{Name: "testActivityWithOptions"})
 	env.OnActivity(testAct, mock.Anything).Return(func(ctx context.Context) (string, error) {
 		activityID := GetActivityInfo(ctx).ActivityID

internal/internal_workflow_testsuite_test.go

@@ -163,7 +163,7 @@ func (s *WorkflowTestSuiteUnitTest) Test_OnActivityStartedListener() {
 
 	env := s.NewTestWorkflowEnvironment()
 	env.RegisterWorkflow(workflowFn)
-	env.RegisterActivity(testActivityHello)
+	env.RegisterActivityWithOptions(testActivityHello, RegisterActivityOptions{Name: "testActivityHello"})
 
 	var activityCalls []string
 	env.SetOnActivityStartedListener(func(activityInfo *ActivityInfo, ctx context.Context, args Values) {
@@ -745,7 +745,7 @@ func (s *WorkflowTestSuiteUnitTest) Test_ChildWorkflow_Mock_Panic_GetChildWorkfl
 	}
 
 	env := s.NewTestWorkflowEnvironment()
-	env.RegisterWorkflow(testWorkflowHello)
+	env.RegisterWorkflowWithOptions(testWorkflowHello, RegisterWorkflowOptions{Name: "testWorkflowHello"})
 	env.RegisterWorkflow(workflowFn)
 	env.OnWorkflow(testWorkflowHello, mock.Anything, mock.Anything, mock.Anything).
 		Return("mock_result", nil, "extra_argument") // extra arg causes panic
@@ -803,7 +803,7 @@ func (s *WorkflowTestSuiteUnitTest) Test_ChildWorkflow_Listener() {
 
 	env := s.NewTestWorkflowEnvironment()
 	env.RegisterWorkflow(workflowFn)
-	env.RegisterWorkflow(testWorkflowHello)
+	env.RegisterWorkflowWithOptions(testWorkflowHello, RegisterWorkflowOptions{Name: "testWorkflowHello"})
 	env.RegisterActivity(testActivityHello)
 
 	var childWorkflowName, childWorkflowResult string
@@ -1524,7 +1524,7 @@ func (s *WorkflowTestSuiteUnitTest) Test_WorkflowFriendlyName() {
 
 	env := s.NewTestWorkflowEnvironment()
 	env.RegisterWorkflow(workflowFn)
-	env.RegisterWorkflow(testWorkflowHello)
+	env.RegisterWorkflowWithOptions(testWorkflowHello, RegisterWorkflowOptions{Name: "testWorkflowHello"})
 	env.RegisterActivity(testActivityHello)
 	var called []string
 	env.SetOnChildWorkflowStartedListener(func(workflowInfo *WorkflowInfo, ctx Context, args Values) {

internal/registry.go

@@ -80,6 +80,10 @@ func (r *registry) RegisterWorkflowWithOptions(
 	fnName := getFunctionName(wf)
 	alias := options.Name
 	registerName := fnName
+
+	if options.EnableShortName {
+		registerName = getShortFunctionName(fnName)
+	}
 	if len(alias) > 0 {
 		registerName = alias
 	}
@@ -93,8 +97,8 @@ func (r *registry) RegisterWorkflowWithOptions(
 		}
 	}
 	r.workflowFuncMap[registerName] = wf
-	if len(alias) > 0 {
-		r.workflowAliasMap[fnName] = alias
+	if len(alias) > 0 || options.EnableShortName {
+		r.workflowAliasMap[fnName] = registerName
 	}
 }
 
@@ -125,6 +129,10 @@ func (r *registry) registerActivityFunction(af interface{}, options RegisterActi
 	fnName := getFunctionName(af)
 	alias := options.Name
 	registerName := fnName
+
+	if options.EnableShortName {
+		registerName = getShortFunctionName(fnName)
+	}
 	if len(alias) > 0 {
 		registerName = alias
 	}
@@ -138,8 +146,8 @@ func (r *registry) registerActivityFunction(af interface{}, options RegisterActi
 		}
 	}
 	r.activityFuncMap[registerName] = &activityExecutor{registerName, af}
-	if len(alias) > 0 {
-		r.activityAliasMap[fnName] = alias
+	if len(alias) > 0 || options.EnableShortName {
+		r.activityAliasMap[fnName] = registerName
 	}
 
 	return nil
@@ -159,19 +167,28 @@ func (r *registry) registerActivityStruct(aStruct interface{}, options RegisterA
 		if method.PkgPath != "" {
 			continue
 		}
-		methodName := method.Name
-		structPrefix := options.Name
+		methodName := getFunctionName(method.Func.Interface())
 		if err := validateFnFormat(method.Type, false); err != nil {
 			return fmt.Errorf("failed to register activity method %v of %v: %e", methodName, structType.Name(), err)
 		}
-		registerName := structPrefix + methodName
+
+		structPrefix := options.Name
+		registerName := methodName
+
+		if options.EnableShortName {
+			registerName = getShortFunctionName(methodName)
+		}
+		if len(structPrefix) > 0 {
+			registerName = structPrefix + getShortFunctionName(methodName)
+		}
+
 		if !options.DisableAlreadyRegisteredCheck {
 			if _, ok := r.getActivityNoLock(registerName); ok {
 				return fmt.Errorf("activity type \"%v\" is already registered", registerName)
 			}
 		}
 		r.activityFuncMap[registerName] = &activityExecutor{registerName, methodValue.Interface()}
-		if len(structPrefix) > 0 {
+		if len(structPrefix) > 0 || options.EnableShortName {
 			r.activityAliasMap[methodName] = registerName
 		}
 		count++
@@ -184,6 +201,11 @@ func (r *registry) registerActivityStruct(aStruct interface{}, options RegisterA
 	return nil
 }
 
+func getShortFunctionName(fnName string) string {
+	elements := strings.Split(fnName, ".")
+	return elements[len(elements)-1]
+}
+
 func (r *registry) getWorkflowAlias(fnName string) (string, bool) {
 	r.Lock() // do not defer for Unlock to call next.getWorkflowAlias without lock
 	alias, ok := r.workflowAliasMap[fnName]