github.com/fabiokung/docker@v0.11.2-0.20170222101415-4534dcd49497/daemon/cluster/tasks.go (about)

     1  package cluster
     2  
     3  import (
     4  	apitypes "github.com/docker/docker/api/types"
     5  	"github.com/docker/docker/api/types/filters"
     6  	types "github.com/docker/docker/api/types/swarm"
     7  	"github.com/docker/docker/daemon/cluster/convert"
     8  	swarmapi "github.com/docker/swarmkit/api"
     9  )
    10  
    11  // GetTasks returns a list of tasks matching the filter options.
    12  func (c *Cluster) GetTasks(options apitypes.TaskListOptions) ([]types.Task, error) {
    13  	c.mu.RLock()
    14  	defer c.mu.RUnlock()
    15  
    16  	state := c.currentNodeState()
    17  	if !state.IsActiveManager() {
    18  		return nil, c.errNoManager(state)
    19  	}
    20  
    21  	byName := func(filter filters.Args) error {
    22  		if filter.Include("service") {
    23  			serviceFilters := filter.Get("service")
    24  			for _, serviceFilter := range serviceFilters {
    25  				service, err := c.GetService(serviceFilter)
    26  				if err != nil {
    27  					return err
    28  				}
    29  				filter.Del("service", serviceFilter)
    30  				filter.Add("service", service.ID)
    31  			}
    32  		}
    33  		if filter.Include("node") {
    34  			nodeFilters := filter.Get("node")
    35  			for _, nodeFilter := range nodeFilters {
    36  				node, err := c.GetNode(nodeFilter)
    37  				if err != nil {
    38  					return err
    39  				}
    40  				filter.Del("node", nodeFilter)
    41  				filter.Add("node", node.ID)
    42  			}
    43  		}
    44  		return nil
    45  	}
    46  
    47  	filters, err := newListTasksFilters(options.Filters, byName)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  
    52  	ctx, cancel := c.getRequestContext()
    53  	defer cancel()
    54  
    55  	r, err := state.controlClient.ListTasks(
    56  		ctx,
    57  		&swarmapi.ListTasksRequest{Filters: filters})
    58  	if err != nil {
    59  		return nil, err
    60  	}
    61  
    62  	tasks := []types.Task{}
    63  
    64  	for _, task := range r.Tasks {
    65  		if task.Spec.GetContainer() != nil {
    66  			tasks = append(tasks, convert.TaskFromGRPC(*task))
    67  		}
    68  	}
    69  	return tasks, nil
    70  }
    71  
    72  // GetTask returns a task by an ID.
    73  func (c *Cluster) GetTask(input string) (types.Task, error) {
    74  	c.mu.RLock()
    75  	defer c.mu.RUnlock()
    76  
    77  	state := c.currentNodeState()
    78  	if !state.IsActiveManager() {
    79  		return types.Task{}, c.errNoManager(state)
    80  	}
    81  
    82  	ctx, cancel := c.getRequestContext()
    83  	defer cancel()
    84  
    85  	task, err := getTask(ctx, state.controlClient, input)
    86  	if err != nil {
    87  		return types.Task{}, err
    88  	}
    89  	return convert.TaskFromGRPC(*task), nil
    90  }