docker/swarmkit

Similar blocks of code found in 10 locations. Consider refactoring.

Open

func (m *SelectBy_NamePrefix) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    i -= len(m.NamePrefix)
    copy(dAtA[i:], m.NamePrefix)
    i = encodeVarintWatch(dAtA, i, uint64(len(m.NamePrefix)))

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

func (m *ReplicatedService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
    i := len(dAtA)
    _ = i
    var l int
    _ = l

• Read up
  Read up

Function updateNode has 8 return statements (exceeds 4 allowed).

Open

func updateNode(cmd *cobra.Command, args []string) error {
    if len(args) == 0 {
        return errors.New("node ID missing")
    }

Method controller.Prepare has 8 return statements (exceeds 4 allowed).

Open

func (r *controller) Prepare(ctx context.Context) error {
    if err := r.checkClosed(); err != nil {
        return err
    }

Function reconcileTaskState has 8 return statements (exceeds 4 allowed).

Open

func reconcileTaskState(ctx context.Context, w *worker, assignments []*api.AssignmentChange, fullSnapshot bool) error {
    var (
        updatedTasks []*api.Task
        removedTasks []*api.Task
    )

Method worker.Subscribe has 8 return statements (exceeds 4 allowed).

Open

func (w *worker) Subscribe(ctx context.Context, subscription *api.SubscriptionMessage) error {
    log.G(ctx).Debugf("Received subscription %s (selector: %v)", subscription.ID, subscription.Selector)

    publisher, cancel, err := w.publisherProvider.Publisher(ctx, subscription.ID)
    if err != nil {

Method Resolver.get has 8 return statements (exceeds 4 allowed).

Open

func (r *Resolver) get(t interface{}, id string) string {
    switch t.(type) {
    case api.Node:
        res, err := r.c.GetNode(r.ctx, &api.GetNodeRequest{NodeID: id})
        if err != nil {

Function processIPAMOptions has 8 return statements (exceeds 4 allowed).

Open

func processIPAMOptions(cmd *cobra.Command) (*api.IPAMOptions, error) {
    flags := cmd.Flags()

    var ipamOpts *api.IPAMOptions
    if flags.Changed("ipam-driver") {

Function ConvertResourceWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertResourceWatch(action WatchActionKind, filters []*SelectBy, kind string) ([]Event, error) {
    var (
        m          Resource
        checkFuncs []ResourceCheckFunc
    )

Function ConvertExtensionWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertExtensionWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Extension
        checkFuncs []ExtensionCheckFunc
    )

Function ConvertSecretWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertSecretWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Secret
        checkFuncs []SecretCheckFunc
    )

Function ConvertClusterWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertClusterWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Cluster
        checkFuncs []ClusterCheckFunc
    )

Function ConvertServiceWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertServiceWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Service
        checkFuncs []ServiceCheckFunc
    )

Function ConvertConfigWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertConfigWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Config
        checkFuncs []ConfigCheckFunc
    )

Function ConvertVolumeWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertVolumeWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Volume
        checkFuncs []VolumeCheckFunc
    )

Function ConvertNetworkWatch has 8 return statements (exceeds 4 allowed).

Open

func ConvertNetworkWatch(action WatchActionKind, filters []*SelectBy) ([]Event, error) {
    var (
        m          Network
        checkFuncs []NetworkCheckFunc
    )

Method raftProxyDispatcherServer.Tasks has 8 return statements (exceeds 4 allowed).

Open

func (p *raftProxyDispatcherServer) Tasks(r *TasksRequest, stream Dispatcher_TasksServer) error {
    ctx := stream.Context()
    conn, err := p.connSelector.LeaderConn(ctx)
    if err != nil {
        if err == raftselector.ErrIsLeader {

Method raftProxyLogBrokerServer.ListenSubscriptions has 8 return statements (exceeds 4 allowed).

Open

func (p *raftProxyLogBrokerServer) ListenSubscriptions(r *ListenSubscriptionsRequest, stream LogBroker_ListenSubscriptionsServer) error {
    ctx := stream.Context()
    conn, err := p.connSelector.LeaderConn(ctx)
    if err != nil {
        if err == raftselector.ErrIsLeader {

Method raftProxyDispatcherServer.Session has 8 return statements (exceeds 4 allowed).

Open

func (p *raftProxyDispatcherServer) Session(r *SessionRequest, stream Dispatcher_SessionServer) error {
    ctx := stream.Context()
    conn, err := p.connSelector.LeaderConn(ctx)
    if err != nil {
        if err == raftselector.ErrIsLeader {

Function sanitizeResource has 8 return statements (exceeds 4 allowed).

Open

func sanitizeResource(nodeRes []*api.GenericResource, res *api.GenericResource) (ok bool, nrs []*api.GenericResource) {
    switch na := res.Resource.(type) {
    case *api.GenericResource_DiscreteResourceSpec:
        nrs := GetResource(na.DiscreteResourceSpec.Kind, nodeRes)