executor

type ActivateTaskCommand struct {
}

type ActivityBranchStatus struct {
	Max    int
	Done   int
	Output [][]byte
}

type ActivityContext struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}
	ID string

	ExecutionID string

	StateName string
	Input     []byte

	ParentBranchID    *string
	ParentIterationID *string

	BranchStatus    *ActivityBranchStatus
	IterationStatus *ActivityIterationStatus
}

type ActivityIterationStatus struct {
	Max    int
	Done   int
	Output [][]byte
}

type BranchCompletedEvent struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}/branch/{id}
	BranchID string
}

type BranchContext struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}/branch/{id}
	BranchID string

	Index int

	//
	ActivityID string

	Input []byte
}

type BranchStartedEvent struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}/branch/{id}
	BranchID string
}

type CompleteBranchCommand struct {
	// BranchID is the identify of branch.
	BranchID string

	// Output is the results of this branch. it MUST be an valid JSON-Object.
	Output []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type CompleteExecutionCommand struct {
	// ID is the identify of this execution.
	ID string

	// Output is the results of this execution. it MUST be an valid JSON-Object.
	Output []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type CompleteIterationCommand struct {
	// IterationID is the identify of iteration.
	IterationID string

	// Output is the results of this iteration. it MUST be an valid JSON-Object.
	Output []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type CompleteStateCommand struct {
	// ActivityID is the identify of this state's context.
	ActivityID string

	// Output is the results of this state. it MUST be an valid JSON-Object.
	Output []byte

	// Status is the result of this state, which could be one of
	// 1. `Succeeded`: the state is executed successful.
	// 2. `Failed`: the state is executed failed, it always will be caused by workflow interpreter.
	Status string

	// Reason is the errcode string when `Status` is `Failed`.
	// It's a brief CamelCase message.
	Reason string

	// Message is the err message string when `Status` is `Failed`.
	// It's a human readable message indicating details.
	Message string

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type CompleteTaskCommand struct {
	// TaskID is the identify of this task.
	TaskID string

	// Output is the results of this task. it MUST be an valid JSON-Object.
	Output []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type CreateTaskCommand struct {
	// ID is the identify of this task, it formated as
	// `/{tenant}/{namespace}/t{xxxxxxx}/{id}`
	//  1. {tenant}: is the tenant name of current execution
	//  2. {namespace}: is the namespace name of current execution
	//  3. {xxxxxxx}: is 7-length hex string, it the hash of task's type.
	//  4. {id}: is the 8-length hex string of current `hybrid logical clock` value.
	ID string

	// ActivityID is the identify of activity which this task belongs.
	ActivityID string

	// ExecutionID is the identify of execution which this task belong to.
	ExecutionID string

	// Resource is the task's reference resource definitions.
	Resource string

	// Input is the arguments of this task. It MUST be an valid JSON-Object.
	Input []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type ExecutionCompletedEvent struct {
	// /{tenant}/{namespace}/execution/{id}
	ID string
}

type ExecutionContext struct {
	ID string

	WorkflowID string

	Input []byte

	Timestamp uint64

	Status string
}

type ExecutionStartedEvent struct {
	// ID is the identify of this execution.
	ID string

	// WorkflowID is the identify of workflow definition which this execution belongs.
	WorkflowID string

	// Input is the arguments of this execution. It MUST be an valid JSON-Object.
	Input []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64

	// Status is current state of execution, which could be one of
	// 1. `Pending`: is waiting to start the first `State`, current it always
	//   transition to `Running` right now; but when we support `delay execution`
	//   there will be an observed `Pending` state.
	// 2. `Running`: is running with an state、task and so on.
	// 3. `Completing`: had reach an `End` state, and all running state、task is reclaiming.
	// 4. `Succeeded`: execution is done as `Succeed`.
	// 5. `Failed`: execution is done as `Fail`.
	// 6. `Deleting`: execution record is `Deleting`, all persistent data will been deleted.
	// 7. `Canceling`: user commant to stopping exeuciton, or it's timeout reached.
	// 8. `Canceled`: execution is done as `Cancel`.
	//
	// State transition flow:
	//                                 +-------------+
	//                                 |   Pending   |
	//                                 +------|------+
	//                                        |
	//                                        |
	//                                        |
	//            +-------------+      +------|------+       +-------------+
	//        +----  Completing --------   Running   ---------  Canceling  |
	//        |   +------|------+      +-------------+       +------|------+
	//        |          |                                          |
	//        |          |                                          |
	//        |          |                                          |
	// +------|------+   |  +------+------+                  +------|------+
	// |  Succeeded  |   +---   Failed    ----+              |   Canceled  |
	// +------|------+      +-------------+   |              +------|------+
	//        |                               |                     |
	//        |                               |                     |
	//        |                               |                     |
	//        |                        +------|------+              |
	//        +-------------------------   Deleting  ---------------+
	//                                 +-------------+
	Status string
}

type Executor struct {
	// contains filtered or unexported fields
}

type IterationCompletedEvent struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}/iteration/{id}
	IterationID string
}

type IterationContext struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}/iteration/{id}
	IterationID string

	Index int
	//
	ActivityID string
}

type IterationStartedEvent struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}/iteration/{id}
	IterationID string
}

type LogStream struct {
	// contains filtered or unexported fields
}

type StartBranchCommand struct {
	// BranchID is the identify of this branch, it formated as
	// `/{ActivityID}/b{id}`
	// in which:
	//  1. {ActivityID}: is the referenced activity
	//  2. {id}: is the branch index of current branch, begin with 0
	BranchID string

	ExecutionID string

	// Index is serial of this branch in ParallelState.
	Index int

	// ActivityID is the identify of activity which this branch belongs.
	ActivityID string

	// Input is the arguments of this branch. It MUST be an valid JSON-Object.
	Input []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type StartExecutionCommand struct {
	// ID is the identify of this execution, it formated as
	// `/{tenant}/{namespace}/e{xxxxxxx}/{id}`
	// in which:
	//  1. {tenant}: is the tenant name of current execution
	//  2. {namespace}: is the namespace name of current execution
	//  3. {xxxxxxx}: is 7-length hex string, when start with idempotent,
	//     it was the hash of idempotent key; when without idempotent, it's
	//     the hash of last id.
	//  4. {id}: is the 16-length hex string of current `hybrid logical clock` value.
	//
	// All execution will partitioned within namespace, the partition prefix is
	// without last {id} to support idempotent without cross-partition transaction.
	// So there maybe large partition.
	ID string

	// WorkflowID is the identify of workflow definition which this execution belongs.
	WorkflowID string

	// Input is the arguments of this execution. It MUST be an valid JSON-Object.
	Input []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type StartIterationCommand struct {
	// IterationID is the identify of this iteration, it formated as
	// `/{ActivityID}/i{id}`
	// in which:
	//  1. {ActivityID}: is the referenced activity
	//  2. {id}: is the iteration index of current iteration, begin with 0
	IterationID string

	ExecutionID string

	// Index is serial of this iteration in MapState.
	Index int

	// ActivityID is the identify of activity which this branch belongs.
	ActivityID string

	// Input is the arguments of this iteration. It MUST be an valid JSON-Object.
	Input []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type StartStateCommand struct {
	// ActivityID is the identify of this state's context, it formated as
	// `/{ExecutionID}/{id}`
	// in which:
	//  1. {ExecutionID}: is the referenced execution of current state's context
	//  2. {id}: is the 8-length hex string of current `hybrid logical clock` value.
	//
	// An execution's all activity have the same prefix, and will in same partition.
	ActivityID string

	// ExecutionID is the identify of execution which this state belong to.
	ExecutionID string

	// StateName is current state's name which ready for execution, and because all state's
	// name must be unique (include in each nest state), so only name is enough.
	StateName string

	// ParentBranchID is exists when this state is invoked in ParallelState.
	ParentBranchID *string

	// ParentIterationID is exists when this state is invoked in MapState.
	ParentIterationID *string

	// Input is the arguments of this state. It MUST be an valid JSON-Object.
	Input []byte

	// Timestamp is `HLC` value of this command request time.
	Timestamp uint64
}

type StateCompletedEvent struct {
	// /{tenant}/{namespace}/execution/{id}/activity/{id}
	ActivityID string
}

type StateStartedEvent struct {
	ActivityID string
}

type Storage struct {
	// contains filtered or unexported fields
}

type TaskActivatedEvent struct {
}

type TaskCompletedEvent struct {
	TaskID string
}

type TaskContext struct {
	ActivityID string
}

type TaskCreatedEvent struct {
	// /{tenant}/{namespace}/task/{id}
	ID string
}

type Timestamp struct {
	// WallTime is the physical unix epoch time expressed in
	// seconds.
	WallTime uint32

	// Logical is an sequential clock to captures causality for events
	// whose wall times are equal.
	Logical uint32
}