if (message.getDelivery() == InterHubMessage.Delivery.Stateful) {
            initializer.onStatefulMessage(message);
        }
        if (message instanceof Routable) {
            Routable routableMessage = (Routable) message;
            getChannel(routableMessage.getChannel()).dispatch(message);

    }

    def unicast() {
        InterHubMessage message = Stub() {
            getDelivery() >> InterHubMessage.Delivery.SingleHandler
        }
        return message
    }

    def stateful() {
        InterHubMessage message = Stub() {
            getDelivery() >> InterHubMessage.Delivery.Stateful
        }
        return message
    }

    def broadcast() {
        InterHubMessage message = Stub() {

public class EndOfStream extends InterHubMessage {
    @Override
    public String toString() {
        return "[" + getClass().getSimpleName() + "]";
    }

    @Override
    public Delivery getDelivery() {
        return Delivery.Stateful;
    }

    }

    @Override
    public String toString() {
        return String.format("[%s channel:%s, payload:%s]", getClass().getSimpleName(), channel, payload);
    }

    @Override
    public Delivery getDelivery() {
        return Delivery.AllHandlers;
    }

    @Override
    public ChannelIdentifier getChannel() {
        return channel;
    }

    public Object getPayload() {
        return payload;
    }

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub.protocol;

public abstract class InterHubMessage {
    /**
     * Specifies the delivery constraints for this message.
     */
    public enum Delivery {
        /**
         * Message should be delivered to a single handler, and queued until a handler is available.
         */
        SingleHandler,
        /**

    public ChannelMessage(ChannelIdentifier channel, Object payload) {
        this.channel = channel;
        this.payload = payload;
    }

    @Override
    public Delivery getDelivery() {
        return Delivery.SingleHandler;
    }

    @Override
    public String toString() {
        return String.format("[%s channel: %s, payload: %s]", getClass().getSimpleName(), channel, payload);
    }

        this.failure = failure;
    }

    @Override
    public Delivery getDelivery() {
        // TODO: This should actually be a Routable message with a single handler,
        // but we need some way to correlate a given request with a specific response channel
        return Delivery.AllHandlers;
    }

    public Throwable getFailure() {
        return failure;
    }

		for _, path := range logPaths {
			conn, err := net.Dial(network, path)
			if err == nil {
				return &netConn{conn: conn, local: true}, nil
			}
		}
	}
	return nil, errors.New("Unix syslog delivery error")

			sig.recv[i] = atomic.Xchg(&sig.mask[i], 0)
		}
	}
}

// signalWaitUntilIdle waits until the signal delivery mechanism is idle.
// This is used to ensure that we do not drop a signal notification due
// to a race between disabling a signal and receiving a signal.
// This assumes that signal delivery has already been disabled for
// the signal(s) in question, and here we are just waiting to make sure

		unlock(&sig.lock)
		notetsleepg(&sig.note, -1)
	}
}

// signalWaitUntilIdle waits until the signal delivery mechanism is idle.
// This is used to ensure that we do not drop a signal notification due
// to a race between disabling a signal and receiving a signal.
// This assumes that signal delivery has already been disabled for
// the signal(s) in question, and here we are just waiting to make sure