Rename domain to namespace.

Author: alexshtin

common/decision.pb.go

@@ -103,8 +103,8 @@ func FromStatus(st *status.Status) error {
 		}
 	case codes.AlreadyExists:
 		switch f := f.(type) {
-		case *failure.DomainAlreadyExists:
-			return newDomainAlreadyExists(st)
+		case *failure.NamespaceAlreadyExists:
+			return newNamespaceAlreadyExists(st)
 		case *failure.WorkflowExecutionAlreadyStarted:
 			return newWorkflowExecutionAlreadyStarted(st, f)
 		case *failure.CancellationAlreadyRequested:
@@ -114,8 +114,8 @@ func FromStatus(st *status.Status) error {
 		}
 	case codes.FailedPrecondition:
 		switch f := f.(type) {
-		case *failure.DomainNotActive:
-			return newDomainNotActive(st, f)
+		case *failure.NamespaceNotActive:
+			return newNamespaceNotActive(st, f)
 		case *failure.ClientVersionNotSupported:
 			return newClientVersionNotSupported(st, f)
 		case *failure.FeatureVersionNotSupported:

common/history.pb.go

@@ -30,39 +30,39 @@ import (
 )
 
 type (
-	// DomainAlreadyExists represents domain already exists error.
-	DomainAlreadyExists struct {
+	// NamespaceAlreadyExists represents namespace already exists error.
+	NamespaceAlreadyExists struct {
 		Message        string
 		st             *status.Status
 	}
 )
 
-// NewDomainAlreadyExists returns new DomainAlreadyExists error.
-func NewDomainAlreadyExists(message string) *DomainAlreadyExists {
-	return &DomainAlreadyExists{
+// NewNamespaceAlreadyExists returns new NamespaceAlreadyExists error.
+func NewNamespaceAlreadyExists(message string) *NamespaceAlreadyExists {
+	return &NamespaceAlreadyExists{
 		Message:        message,
 	}
 }
 
 // Error returns string message.
-func (e *DomainAlreadyExists) Error() string {
+func (e *NamespaceAlreadyExists) Error() string {
 	return e.Message
 }
 
-func (e *DomainAlreadyExists) status() *status.Status {
+func (e *NamespaceAlreadyExists) status() *status.Status {
 	if e.st != nil {
 		return e.st
 	}
 
 	st := status.New(codes.AlreadyExists, e.Message)
 	st, _ = st.WithDetails(
-		&failure.DomainAlreadyExists{},
+		&failure.NamespaceAlreadyExists{},
 	)
 	return st
 }
 
-func newDomainAlreadyExists(st *status.Status) *DomainAlreadyExists {
-	return &DomainAlreadyExists{
+func newNamespaceAlreadyExists(st *status.Status) *NamespaceAlreadyExists {
+	return &NamespaceAlreadyExists{
 		Message: st.Message(),
 		st:      st,
 	}

common/domain.pb.go common/namespace.pb.gocommon/domain.pb.go renamed to common/namespace.pb.go

@@ -32,56 +32,56 @@ import (
 )
 
 type (
-	// DomainNotActive represents domain not active error.
-	DomainNotActive struct {
+	// NamespaceNotActive represents namespace not active error.
+	NamespaceNotActive struct {
 		Message        string
-		DomainName     string
+		Namespace     string
 		CurrentCluster string
 		ActiveCluster  string
 		st             *status.Status
 	}
 )
 
-// NewDomainNotActive returns new DomainNotActive error.
-func NewDomainNotActive(domainName, currentCluster, activeCluster string) *DomainNotActive {
-	return &DomainNotActive{
+// NewNamespaceNotActive returns new NamespaceNotActive error.
+func NewNamespaceNotActive(namespace, currentCluster, activeCluster string) *NamespaceNotActive {
+	return &NamespaceNotActive{
 		Message:        fmt.Sprintf(
-			"Domain: %s is active in cluster: %s, while current cluster %s is a standby cluster.",
-			domainName,
+			"Namespace: %s is active in cluster: %s, while current cluster %s is a standby cluster.",
+			namespace,
 			activeCluster,
 			currentCluster,
 		),
-		DomainName:     domainName,
+		Namespace:     namespace,
 		CurrentCluster: currentCluster,
 		ActiveCluster:  activeCluster,
 	}
 }
 
 // Error returns string message.
-func (e *DomainNotActive) Error() string {
+func (e *NamespaceNotActive) Error() string {
 	return e.Message
 }
 
-func (e *DomainNotActive) status() *status.Status {
+func (e *NamespaceNotActive) status() *status.Status {
 	if e.st != nil {
 		return e.st
 	}
 
 	st := status.New(codes.FailedPrecondition, e.Message)
 	st, _ = st.WithDetails(
-		&failure.DomainNotActive{
-			DomainName:     e.DomainName,
+		&failure.NamespaceNotActive{
+			Namespace:     e.Namespace,
 			CurrentCluster: e.CurrentCluster,
 			ActiveCluster:  e.ActiveCluster,
 		},
 	)
 	return st
 }
 
-func newDomainNotActive(st *status.Status, failure *failure.DomainNotActive) *DomainNotActive {
-	return &DomainNotActive{
+func newNamespaceNotActive(st *status.Status, failure *failure.NamespaceNotActive) *NamespaceNotActive {
+	return &NamespaceNotActive{
 		Message:        st.Message(),
-		DomainName:     failure.DomainName,
+		Namespace:     failure.Namespace,
 		CurrentCluster: failure.CurrentCluster,
 		ActiveCluster:  failure.ActiveCluster,
 		st:             st,

common/workflow_execution.pb.go

@@ -33,7 +33,7 @@ type (
 	// RetryTask represents retry task error.
 	RetryTask struct {
 		Message     string
-		DomainId    string
+		NamespaceId    string
 		WorkflowId  string
 		RunId       string
 		NextEventId int64
@@ -42,10 +42,10 @@ type (
 )
 
 // NewRetryTask returns new RetryTask error.
-func NewRetryTask(message, domainId, workflowId, runId string, nextEventId int64) *RetryTask {
+func NewRetryTask(message, namespaceId, workflowId, runId string, nextEventId int64) *RetryTask {
 	return &RetryTask{
 		Message:     message,
-		DomainId:    domainId,
+		NamespaceId:    namespaceId,
 		WorkflowId:  workflowId,
 		RunId:       runId,
 		NextEventId: nextEventId,
@@ -65,7 +65,7 @@ func (e *RetryTask) status() *status.Status {
 	st := status.New(codes.Aborted, e.Message)
 	st, _ = st.WithDetails(
 		&failure.RetryTask{
-			DomainId:    e.DomainId,
+			NamespaceId:    e.NamespaceId,
 			WorkflowId:  e.WorkflowId,
 			RunId:       e.RunId,
 			NextEventId: e.NextEventId,
@@ -77,7 +77,7 @@ func (e *RetryTask) status() *status.Status {
 func newRetryTask(st *status.Status, failure *failure.RetryTask) *RetryTask {
 	return &RetryTask{
 		Message:     st.Message(),
-		DomainId:    failure.DomainId,
+		NamespaceId:    failure.NamespaceId,
 		WorkflowId:  failure.WorkflowId,
 		RunId:       failure.RunId,
 		NextEventId: failure.NextEventId,