source: profileconnection/src/main/java/geniusweb/profileconnection/WebsocketProfileConnector.java@ 33

package geniusweb.profileconnection;

import java.io.IOException;
import java.net.URI;
import java.util.logging.Level;

import javax.websocket.ClientEndpoint;
import javax.websocket.DeploymentException;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;

import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.profile.Profile;
import tudelft.utilities.listener.DefaultListenable;
import tudelft.utilities.logging.Reporter;

/**
 * Container for the latest available profile on the profiles server
 */
@ClientEndpoint
public class WebsocketProfileConnector extends DefaultListenable<Profile>
                implements ProfileInterface {
        private final static ObjectMapper jackson = new ObjectMapper();
        private static final int TIMEOUT_MS = 2000;
        private final Reporter logger;
        private final URI uri; // to log possible errors
        private Profile profile = null;
        private Session session;

        /**
         * 
         * @param uri         the URI that will provide the {@link Profile}
         * @param reporter    the {@link Reporter} for logging issues
         * @param wscontainer the {@link WebSocketContainer} that can provide new
         *                    websockets. Typically ContainerProvider
         *                    .getWebSocketContainer()
         * @throws DeploymentException if the annotated endpoint instance is not
         *                             valid
         * @throws IOException         if there was a network or protocol problem
         *                             that prevented the client endpoint being
         *                             connected to its server.
         * 
         */
        public WebsocketProfileConnector(URI uri, Reporter reporter,
                        WebSocketContainer wscontainer)
                        throws DeploymentException, IOException {
                if (uri == null || reporter == null || wscontainer == null) {
                        throw new IllegalArgumentException(
                                        "uri, reporter and wsconnector must be not null");
                }
                this.uri = uri;
                this.logger = reporter;
                // see #1763 expected max size of profiles.
                wscontainer.setDefaultMaxTextMessageBufferSize(200000);
                wscontainer.connectToServer(this, uri);
        }

        @OnOpen
        public void onOpen(Session session) {
                this.session = session;
                logger.log(Level.FINE, "Connected: " + session.getBasicRemote());
        }

        @OnClose
        public void onClose() {
                if (session != null) {
                        logger.log(Level.FINE,
                                        "Closed websocket: " + session.getBasicRemote());
                        this.session = null;
                        // remove listeners seems not needed
                }
        }

        @OnMessage
        public void processMessage(String message) throws IOException {
                // this will be called every time the profile changes.
                logger.log(Level.FINE, "Received profile: " + message);
                profile = jackson.readValue(message, Profile.class);
                notifyListeners(profile);
        }

        @OnError
        public void processError(Throwable t) {
                logger.log(Level.SEVERE,
                                "Something went wrong while processing downloaded profile", t);
        }

        @Override
        public Profile getProfile() throws IOException {
                int remaining_wait = TIMEOUT_MS;
                try {
                        while (profile == null && remaining_wait > 0) {
                                remaining_wait -= 100;
                                Thread.sleep(100);
                        }
                } catch (InterruptedException e) {
                        logger.log(Level.SEVERE, "interrupted while waiting for profile",
                                        e);
                }
                if (profile == null) {
                        throw new IOException("Failed to fetch profile from " + uri);
                }
                return profile;
        }

        @Override
        public void close() {
                if (session != null) {
                        try {
                                session.close();
                        } catch (IOException e) {
                                logger.log(Level.WARNING,
                                                "Falled to close websocket connection: "
                                                                + session.getBasicRemote());
                        }
                }
        }

}