*/

package org.gradle.launcher.daemon.protocol;

/**
 * Returned when the daemon is busy running a different command.
 */
public class DaemonUnavailable extends Message {
    private final String reason;

    public DaemonUnavailable(String reason) {
        this.reason = reason;
    }

    public String getReason() {
        return reason;
    }

        } catch (DaemonUnavailableException e) {
            LOGGER.info("Daemon will not handle the command {} because is unavailable: {}", build, e.getMessage());
            execution.getConnection().daemonUnavailable(new DaemonUnavailable(e.getMessage()));
        } catch (DaemonStoppedException e) {
            execution.getConnection().completed(new Failure(e));
        }
    }

     */
    void onCancel(@Nullable Runnable handler);

    /**
     * Dispatches a daemon unavailable message to the client.
     */
    void daemonUnavailable(DaemonUnavailable unavailable);

    /**
     * Dispatches a build started message to the client.
     */
    void buildStarted(BuildStarted buildStarted);

    /**
     * Dispatches a log event message to the client.

        @Override
        public void write(Encoder encoder, DaemonUnavailable value) throws Exception {
            encoder.writeNullableString(value.getReason());
        }

        @Override
        public DaemonUnavailable read(Decoder decoder) throws Exception {
            return new DaemonUnavailable(decoder.readNullableString());
        }
    }

        connection.daemon >> Stub(DaemonConnectDetails)
        connection.receive() >> Mock(DaemonUnavailable)
        connection2.daemon >> Stub(DaemonConnectDetails)
        connection2.receive() >> Mock(DaemonUnavailable)

        when:
        client.execute(Stub(BuildAction), Stub(BuildActionParameters), Stub(ClientBuildRequestContext))

        then:

        result.action
        result.buildClientMetaData
        result.parameters
    }

    def "can serialize DaemonUnavailable message"() {
        expect:
        def message = new DaemonUnavailable("reason")
        def result = serialize(message, serializer)
        result instanceof DaemonUnavailable
        result.reason == "reason"
    }

    def "can serialize Cancel message"() {
        expect:

    }

    @Override
    public Object receive(long timeoutValue, TimeUnit timeoutUnits) {
        return receiveQueue.take(timeoutValue, timeoutUnits);
    }

    @Override
    public void daemonUnavailable(DaemonUnavailable unavailable) {
        connection.dispatchAndFlush(unavailable);
    }

    @Override
    public void buildStarted(BuildStarted buildStarted) {
        connection.dispatchAndFlush(buildStarted);

            }
            throw UncheckedException.throwAsUncheckedException(failure);
        } else if (result instanceof DaemonUnavailable) {
            throw new DaemonInitialConnectException("The daemon we connected to was unavailable: " + ((DaemonUnavailable) result).getReason());
        } else if (result instanceof Result) {
            return (BuildActionResult) ((Result) result).getValue();
        } else {

Class <org.gradle.launcher.daemon.protocol.DaemonUnavailable> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (DaemonUnavailable.java:0)
Class <org.gradle.launcher.daemon.protocol.Failure> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (Failure.java:0)