org.eclipse.jetty.io.AbstractConnection Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aem-sdk-api Show documentation
The Adobe Experience Manager SDK
There is a newer version: 2024.11.18751.20241128T090041Z-241100
// 
// ========================================================================
// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// 
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// 
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// 
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
// 
package org.eclipse.jetty.io;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeoutException;
import org.eclipse.jetty.util.Callback;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.thread.Invocable;

/**
 *  A convenience base implementation of {@link Connection}.
 *  This class uses the capabilities of the {@link EndPoint} API to provide a
 *  more traditional style of async reading.  A call to {@link #fillInterested()}
 *  will schedule a callback to {@link #onFillable()} or {@link #onFillInterestedFailed(Throwable)}
 *  as appropriate.
 *
 * @deprecated The Eclipse Jetty and Apache Felix Http Jetty packages are no longer supported.
 */
@Deprecated(since = "2021-05-27")
public abstract class AbstractConnection implements Connection {

    private static final Logger LOG = Log.getLogger(AbstractConnection.class);

    private final List _listeners = new CopyOnWriteArrayList<>();

    private final long _created = System.currentTimeMillis();

    private final EndPoint _endPoint;

    private final Executor _executor;

    private final Callback _readCallback;

    private int _inputBufferSize = 2048;

    protected AbstractConnection(EndPoint endp, Executor executor) {
        if (executor == null)
            throw new IllegalArgumentException("Executor must not be null!");
        _endPoint = endp;
        _executor = executor;
        _readCallback = new ReadCallback();
    }

    @Override
    public void addListener(Listener listener) {
        _listeners.add(listener);
    }

    @Override
    public void removeListener(Listener listener) {
        _listeners.remove(listener);
    }

    public int getInputBufferSize() {
        return _inputBufferSize;
    }

    public void setInputBufferSize(int inputBufferSize) {
        _inputBufferSize = inputBufferSize;
    }

    protected Executor getExecutor() {
        return _executor;
    }

    protected void failedCallback(final Callback callback, final Throwable x) {
        Runnable failCallback = () -> {
            try {
                callback.failed(x);
            } catch (Exception e) {
                LOG.warn(e);
            }
        };
        switch(Invocable.getInvocationType(callback)) {
            case BLOCKING:
                try {
                    getExecutor().execute(failCallback);
                } catch (RejectedExecutionException e) {
                    LOG.debug(e);
                    callback.failed(x);
                }
                break;
            case NON_BLOCKING:
                failCallback.run();
                break;
            case EITHER:
                Invocable.invokeNonBlocking(failCallback);
        }
    }

    /**
     * Utility method to be called to register read interest.
     * After a call to this method, {@link #onFillable()} or {@link #onFillInterestedFailed(Throwable)}
     * will be called back as appropriate.
     *
     * @see #onFillable()
     */
    public void fillInterested() {
        if (LOG.isDebugEnabled())
            LOG.debug("fillInterested {}", this);
        getEndPoint().fillInterested(_readCallback);
    }

    public void tryFillInterested() {
        tryFillInterested(_readCallback);
    }

    public void tryFillInterested(Callback callback) {
        getEndPoint().tryFillInterested(callback);
    }

    public boolean isFillInterested() {
        return getEndPoint().isFillInterested();
    }

    /**
     * Callback method invoked when the endpoint is ready to be read.
     *
     * @see #fillInterested()
     */
    public abstract void onFillable();

    /**
     * Callback method invoked when the endpoint failed to be ready to be read.
     *
     * @param cause the exception that caused the failure
     */
    protected void onFillInterestedFailed(Throwable cause) {
        if (LOG.isDebugEnabled())
            LOG.debug("{} onFillInterestedFailed {}", this, cause);
        if (_endPoint.isOpen()) {
            boolean close = true;
            if (cause instanceof TimeoutException)
                close = onReadTimeout(cause);
            if (close) {
                if (_endPoint.isOutputShutdown())
                    _endPoint.close();
                else {
                    _endPoint.shutdownOutput();
                    fillInterested();
                }
            }
        }
    }

    /**
     * Callback method invoked when the endpoint failed to be ready to be read after a timeout
     *
     * @param timeout the cause of the read timeout
     * @return true to signal that the endpoint must be closed, false to keep the endpoint open
     */
    protected boolean onReadTimeout(Throwable timeout) {
        return true;
    }

    @Override
    public void onOpen() {
        if (LOG.isDebugEnabled())
            LOG.debug("onOpen {}", this);
        for (Listener listener : _listeners) {
            onOpened(listener);
        }
    }

    private void onOpened(Listener listener) {
        try {
            listener.onOpened(this);
        } catch (Throwable x) {
            LOG.info("Failure while notifying listener " + listener, x);
        }
    }

    @Override
    public void onClose() {
        if (LOG.isDebugEnabled())
            LOG.debug("onClose {}", this);
        for (Listener listener : _listeners) {
            onClosed(listener);
        }
    }

    private void onClosed(Listener listener) {
        try {
            listener.onClosed(this);
        } catch (Throwable x) {
            LOG.info("Failure while notifying listener " + listener, x);
        }
    }

    @Override
    public EndPoint getEndPoint() {
        return _endPoint;
    }

    @Override
    public void close() {
        getEndPoint().close();
    }

    @Override
    public boolean onIdleExpired() {
        return true;
    }

    @Override
    public long getMessagesIn() {
        return -1;
    }

    @Override
    public long getMessagesOut() {
        return -1;
    }

    @Override
    public long getBytesIn() {
        return -1;
    }

    @Override
    public long getBytesOut() {
        return -1;
    }

    @Override
    public long getCreatedTimeStamp() {
        return _created;
    }

    @Override
    public final String toString() {
        return String.format("%s@%h::%s", getClass().getSimpleName(), this, getEndPoint());
    }

    public String toConnectionString() {
        return String.format("%s@%h", getClass().getSimpleName(), this);
    }

    // @deprecated The Eclipse Jetty and Apache Felix Http Jetty packages are no longer supported.
    @Deprecated(since = "2021-05-27")
    private class ReadCallback implements Callback {

        @Override
        public void succeeded() {
            onFillable();
        }

        @Override
        public void failed(final Throwable x) {
            onFillInterestedFailed(x);
        }

        @Override
        public String toString() {
            return String.format("AC.ReadCB@%h{%s}", AbstractConnection.this, AbstractConnection.this);
        }
    }
}