go-vitess.v1: gopkg.in/src-d/go-vitess.v1/vt/workflow Index | Files | Directories

package workflow

import "gopkg.in/src-d/go-vitess.v1/vt/workflow"

Index

Package Files

checkpoint.go long_polling.go manager.go node.go parallel_runner.go sleep_workflow.go websocket.go

Constants

const (
    // Sequential means that the tasks will run sequentially.
    Sequential level = iota
    //Parallel means that the tasks will run in parallel.
    Parallel
)

func AvailableFactories Uses

func AvailableFactories() map[string]bool

AvailableFactories returns a map with the names of the available factories as keys and 'true' as value.

func Register Uses

func Register(factoryName string, factory Factory)

Register lets implementations register Factory objects. Typically called at init() time.

func StartManager Uses

func StartManager(m *Manager) (*sync.WaitGroup, context.Context, context.CancelFunc)

StartManager starts a manager. This function should only be used for tests purposes.

func Unregister Uses

func Unregister(name string)

Unregister removes a factory object. Typically called from a flag to remove dangerous workflows.

func VerifyAllTasksDone Uses

func VerifyAllTasksDone(ctx context.Context, ts *topo.Server, uuid string) error

VerifyAllTasksDone checks that all tasks are done in a workflow. This should only be used for test purposes.

type Action Uses

type Action struct {
    Name    string      `json:"name"`
    State   ActionState `json:"state,omitempty"`
    Style   ActionStyle `json:"style,omitempty"`
    Message string      `json:"message"`
}

Action must match node.ts Action.

type ActionListener Uses

type ActionListener interface {
    // Action is called when the user requests an action on a node.
    // 'path' is the node's Path value and 'name' is the invoked action's name.
    Action(ctx context.Context, path, name string) error
}

ActionListener is an interface for receiving notifications about actions triggered from workflow UI.

type ActionParameters Uses

type ActionParameters struct {
    // Path is the path of the Node the action was performed on.
    Path string `json:"path"`

    // Name is the Name of the Action.
    Name string `json:"name"`
}

ActionParameters describe an action initiated by the user.

type ActionState Uses

type ActionState int

ActionState constants need to match node.ts.ActionState.

const (
    // ActionStateUnknown is an unknown value and should never be set.
    ActionStateUnknown ActionState = 0

    // ActionStateEnabled is for when the action is enabled.
    ActionStateEnabled ActionState = 1

    // ActionStateDisabled is for when the action is disabled.
    ActionStateDisabled ActionState = 2
)

type ActionStyle Uses

type ActionStyle int

ActionStyle constants need to match node.ts.ActionStyle.

const (
    // ActionStyleUnknown is an unknown value and should never be set.
    ActionStyleUnknown ActionStyle = 0

    // ActionStyleNormal will just trigger the action.
    ActionStyleNormal ActionStyle = 1

    // ActionStyleWarning will display a warning dialog to confirm
    // action with Action.Message.
    ActionStyleWarning ActionStyle = 2

    // ActionStyleWaiting highlights to the user that the process
    // is waiting on the execution of the action.
    ActionStyleWaiting ActionStyle = 3

    // ActionStyleTriggered is a state where the button is greyed
    // out and cannot be pressed.
    ActionStyleTriggered ActionStyle = 4
)

type CheckpointWriter Uses

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

CheckpointWriter saves the checkpoint data into topology server.

func NewCheckpointWriter Uses

func NewCheckpointWriter(ts *topo.Server, checkpoint *workflowpb.WorkflowCheckpoint, wi *topo.WorkflowInfo) *CheckpointWriter

NewCheckpointWriter creates a CheckpointWriter.

func (*CheckpointWriter) UpdateTask Uses

func (c *CheckpointWriter) UpdateTask(taskID string, status workflowpb.TaskState, err error) error

UpdateTask updates the task status in the checkpointing copy and saves the full checkpoint to the topology server.

type Factory Uses

type Factory interface {
    // Init initializes the private parts of the workflow object.
    // The passed in workflow will have its Uuid, FactoryName and State
    // variable filled it. This Init method should fill in the
    // Name and Data attributes, based on the provided args.
    // This is called during the Manager.Create phase and will initially
    // checkpoint the workflow in the topology.
    // The Manager object is passed to Init method since the resharding workflow
    // will use the topology server in Manager.
    Init(m *Manager, w *workflowpb.Workflow, args []string) error

    // Instantiate loads a workflow from the proto representation
    // into an in-memory Workflow object. rootNode is the root UI node
    // representing the workflow.
    Instantiate(m *Manager, w *workflowpb.Workflow, rootNode *Node) (Workflow, error)
}

Factory can create the initial version of a Workflow, or instantiate them from a serialized version.

type Manager Uses

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

Manager is the main Workflow manager object. Its management API allows it to create, start and stop workflows.

func NewManager Uses

func NewManager(ts *topo.Server) *Manager

NewManager creates an initialized Manager.

func (*Manager) Create Uses

func (m *Manager) Create(ctx context.Context, factoryName string, args []string) (string, error)

Create creates a workflow from the given factory name with the provided args. Returns the unique UUID of the workflow. The workflowpb.Workflow object is saved in the topo server after creation.

func (*Manager) Delete Uses

func (m *Manager) Delete(ctx context.Context, uuid string) error

Delete deletes the finished or not started workflow.

func (*Manager) HandleHTTPLongPolling Uses

func (m *Manager) HandleHTTPLongPolling(pattern string)

HandleHTTPLongPolling registers the streaming-over-HTTP APIs.

func (*Manager) HandleHTTPWebSocket Uses

func (m *Manager) HandleHTTPWebSocket(pattern string)

HandleHTTPWebSocket registers the WebSocket handler.

func (*Manager) NodeManager Uses

func (m *Manager) NodeManager() *NodeManager

NodeManager returns the NodeManager used by the Manager. It is meant to be used by the running workflows.

func (*Manager) Run Uses

func (m *Manager) Run(ctx context.Context)

Run is the main entry point for the Manager. It will read each checkpoint from the topo Server, and for the ones that are in the Running state, will load them in memory and run them. It will not return until ctx is canceled.

func (*Manager) SetRedirectFunc Uses

func (m *Manager) SetRedirectFunc(rf func() (string, error))

SetRedirectFunc sets the redirect function to use.

func (*Manager) Start Uses

func (m *Manager) Start(ctx context.Context, uuid string) error

Start will start a Workflow. It will load it in memory, update its status to Running, and call its Run() method.

func (*Manager) Stop Uses

func (m *Manager) Stop(ctx context.Context, uuid string) error

Stop stops the running workflow. It will cancel its context and wait for it to exit.

func (*Manager) TopoServer Uses

func (m *Manager) TopoServer() *topo.Server

TopoServer returns the topo.Server used by the Manager. It is meant to be used by the running workflows.

func (*Manager) Wait Uses

func (m *Manager) Wait(ctx context.Context, uuid string) error

Wait waits for the provided workflow to end.

func (*Manager) WaitUntilRunning Uses

func (m *Manager) WaitUntilRunning()

WaitUntilRunning blocks until Run() has progressed to a state where the manager can start workflows. It is mainly used by tests.

func (*Manager) WorkflowForTesting Uses

func (m *Manager) WorkflowForTesting(uuid string) (Workflow, error)

WorkflowForTesting returns the Workflow object of the running workflow identified by uuid. The method is used in unit tests to inject mocks.

func (*Manager) WorkflowInfoForTesting Uses

func (m *Manager) WorkflowInfoForTesting(uuid string) (*topo.WorkflowInfo, error)

WorkflowInfoForTesting returns the WorkflowInfo object of the running workflow identified by uuid. The method is used in unit tests to manipulate checkpoint.

type Node Uses

type Node struct {

    // Listener will be notified about actions invoked on this node.
    Listener ActionListener `json:"-"`

    Name            string                   `json:"name"`
    PathName        string                   `json:"pathName"`
    Path            string                   `json:"path"`
    Children        []*Node                  `json:"children,omitempty"`
    LastChanged     int64                    `json:"lastChanged"`
    CreateTime      int64                    `json:"createTime"`
    Progress        int                      `json:"progress"`
    ProgressMessage string                   `json:"progressMsg"`
    State           workflowpb.WorkflowState `json:"state"`
    Display         NodeDisplay              `json:"display,omitempty"`
    Message         string                   `json:"message"`
    Log             string                   `json:"log"`
    Disabled        bool                     `json:"disabled"`
    Actions         []*Action                `json:"actions"`
    // contains filtered or unexported fields
}

Node is the UI representation of a Workflow toplevel object, or of a Workflow task. It is just meant to be a tree, and the various Workflow implementations can expose a tree of Nodes that represent what they are doing.

Actions are meant to be buttons, that will trigger the Action callback of a workflow.

In order for the web UIs to be notified when changing this structure, any change to this Node has to be done inside a Modify() function.

It should match the Node object described in web/vtctld2/src/app/workflows/node.ts as it is exposed as JSON to the Angular 2 web app.

func NewNode Uses

func NewNode() *Node

NewNode is a helper function to create new UI Node struct.

func (*Node) BroadcastChanges Uses

func (n *Node) BroadcastChanges(updateChildren bool) error

BroadcastChanges sends the new contents of the node to the watchers.

func (*Node) GetChildByPath Uses

func (n *Node) GetChildByPath(subPath string) (*Node, error)

GetChildByPath returns the child node given the relative path to this node. The caller must ensure that the node tree is not modified during the call.

type NodeDisplay Uses

type NodeDisplay int

NodeDisplay constants need to match node.ts.Display.

const (
    // NodeDisplayUnknown is an unknown value and should never be set.
    NodeDisplayUnknown NodeDisplay = 0

    // NodeDisplayIndeterminate is a progress bar that doesn't have
    // a current value, but just shows movement.
    NodeDisplayIndeterminate NodeDisplay = 1

    // NodeDisplayDeterminate is a progress bar driven by the
    // Progress field.
    NodeDisplayDeterminate NodeDisplay = 2

    // NodeDisplayNone shows no progress bar or status.
    NodeDisplayNone NodeDisplay = 3
)

type NodeManager Uses

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

NodeManager manages the Node tree.

func NewNodeManager Uses

func NewNodeManager() *NodeManager

NewNodeManager returns a new NodeManager.

func (*NodeManager) Action Uses

func (m *NodeManager) Action(ctx context.Context, ap *ActionParameters) error

Action is called by the UI agents to trigger actions.

func (*NodeManager) AddRootNode Uses

func (m *NodeManager) AddRootNode(n *Node) error

AddRootNode adds a toplevel Node to the NodeManager, and broadcasts the Node to the listeners.

func (*NodeManager) CloseWatcher Uses

func (m *NodeManager) CloseWatcher(i int)

CloseWatcher unregisters the watcher from this Manager.

func (*NodeManager) GetAndWatchFullTree Uses

func (m *NodeManager) GetAndWatchFullTree(notifications chan []byte) ([]byte, int, error)

GetAndWatchFullTree returns the JSON representation of the entire Node tree, and registers a watcher to monitor changes to the tree.

func (*NodeManager) GetFullTree Uses

func (m *NodeManager) GetFullTree() ([]byte, error)

GetFullTree returns the JSON representation of the entire Node tree.

func (*NodeManager) RemoveRootNode Uses

func (m *NodeManager) RemoveRootNode(n *Node)

RemoveRootNode removes a toplevel Node from the NodeManager, and broadcasts the change to the listeners.

type ParallelRunner Uses

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

ParallelRunner is used to control executing tasks concurrently. Each phase has its own ParallelRunner object.

func NewParallelRunner Uses

func NewParallelRunner(ctx context.Context, rootUINode *Node, cp *CheckpointWriter, tasks []*workflowpb.Task, executeFunc func(context.Context, *workflowpb.Task) error, concurrencyLevel level, enableApprovals bool) *ParallelRunner

NewParallelRunner returns a new ParallelRunner.

func (*ParallelRunner) Action Uses

func (p *ParallelRunner) Action(ctx context.Context, path, name string) error

Action handles retrying, approval of the first task and approval of the remaining tasks actions. It implements the interface ActionListener.

func (*ParallelRunner) Run Uses

func (p *ParallelRunner) Run() error

Run is the entry point for controlling task executions.

type PhaseType Uses

type PhaseType string

PhaseType is used to store the phase name in a workflow.

type SleepWorkflow Uses

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

SleepWorkflow implements the Workflow interface. It is a test Workflow that only sleeps for a provided interval. It is meant to test all the plumbing and corner cases of the workflow library.

func (*SleepWorkflow) Action Uses

func (sw *SleepWorkflow) Action(ctx context.Context, path, name string) error

Action is part of the workflow.ActionListener interface.

func (*SleepWorkflow) Run Uses

func (sw *SleepWorkflow) Run(ctx context.Context, manager *Manager, wi *topo.WorkflowInfo) error

Run is part of the workflow.Workflow interface. It updates the UI every second, and checkpoints every 5 seconds.

type SleepWorkflowData Uses

type SleepWorkflowData struct {
    // Duration is how long we need to sleep total.
    Duration int

    // Slept is how long we've already slept.
    Slept int

    // Paused is true if we should not be making any progress.
    Paused bool
}

SleepWorkflowData is the data structure serialized as JSON in Workflow.Data.

type SleepWorkflowFactory Uses

type SleepWorkflowFactory struct{}

SleepWorkflowFactory is the factory to register the Sleep workflows.

func (*SleepWorkflowFactory) Init Uses

func (f *SleepWorkflowFactory) Init(_ *Manager, w *workflowpb.Workflow, args []string) error

Init is part of the workflow.Factory interface.

func (*SleepWorkflowFactory) Instantiate Uses

func (f *SleepWorkflowFactory) Instantiate(_ *Manager, w *workflowpb.Workflow, rootNode *Node) (Workflow, error)

Instantiate is part of the workflow.Factory interface.

type Update Uses

type Update struct {
    // Redirect is set to the URL to go to if we are not the
    // master.  It is only set in the initial response, and if set
    // then no other field in this structure is set.
    Redirect string `json:"redirect,omitempty"`

    // Index is the watcher index. It is only set in the initial
    // tree.
    Index int `json:"index,omitempty"`

    // Nodes is a list of nodes to update.
    Nodes []*Node `json:"nodes,omitempty"`

    // Deletes is a list of toplevel paths to delete.
    Deletes []string `json:"deletes,omitempty"`

    // FullUpdate is set to true if this is a full refresh of the data.
    FullUpdate bool `json:"fullUpdate,omitempty"`
}

Update is the data structure we send on the websocket or on the long-polling HTTP connection to the clients.

type Workflow Uses

type Workflow interface {
    // Run runs the Workflow within the provided WorkflowManager.
    // It should return ctx.Err() if ctx.Done() is closed.  The
    // Run method can alter the provided WorkflowInfo to save its
    // state (and it can checkpoint that new value by saving it
    // into the manager's topo Server).
    Run(ctx context.Context, manager *Manager, wi *topo.WorkflowInfo) error
}

Workflow is a running instance of a job.

Directories

PathSynopsis
resharding
reshardingworkflowgen
topovalidatorPackage topovalidator contains a workflow that validates the topology data.

Package workflow imports 22 packages (graph) and is imported by 12 packages. Updated 2019-06-13. Refresh now. Tools for package owners.