Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2013 Jeanfrancois Arcand
   *
   * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package org.atmosphere.wasync.transport;
 
 
 import java.util.List;
 import java.util.Map;
 
 import static org.atmosphere.wasync.Event.CLOSE;
 import static org.atmosphere.wasync.Event.ERROR;
 import static org.atmosphere.wasync.Event.HEADERS;
 import static org.atmosphere.wasync.Event.MESSAGE;
 import static org.atmosphere.wasync.Event.OPEN;
 import static org.atmosphere.wasync.Event.REOPENED;
 import static org.atmosphere.wasync.Event.STATUS;
 import static org.atmosphere.wasync.Event.TRANSPORT;
 import static org.atmosphere.wasync.Socket.STATUS;

WebSocket org.atmosphere.wasync.Transport implementation

Author(s):
Jeanfrancois Arcand
 
 public class WebSocketTransport extends WebSocketUpgradeHandler implements Transport {
 
     private final Logger logger = LoggerFactory.getLogger(WebSocketTransport.class);
     private WebSocket webSocket;
     private final AtomicBoolean ok = new AtomicBoolean(false);
     private final List<FunctionWrapperfunctions;
     private final List<Decoder<?, ?>> decoders;
     private final FunctionResolver resolver;
     private final Options options;
     private final RequestBuilder requestBuilder;
     private final AtomicBoolean closed = new AtomicBoolean(false);
     private STATUS status = ..;
     private final AtomicBoolean errorHandled = new AtomicBoolean();
     private Future connectdFuture;
 
     public WebSocketTransport(RequestBuilder requestBuilderOptions optionsRequest requestList<FunctionWrapperfunctions) {
         super(new Builder());
         this. = request.decoders();
 
         if (.size() == 0) {
             .add(new Decoder<StringObject>() {
                 @Override
                 public Object decode(Event eString s) {
                     return s;
                 }
             });
         }
         this. = functions;
         this. = request.functionResolver();
         this. = options;
         this. = requestBuilder;
     }

    
 
     @Override
     public void onThrowable(Throwable t) {
         .debug(""t);
         = ..;
        .set(TransportsUtil.invokeFunction(.t.getClass(), t.name(), ));
    }

    
    @Override
    public void close() {
        if (.getAndSet(true)) return;
         = ..;
        TransportsUtil.invokeFunction(String.class.name(), .name(), );
        if ( != null && .isOpen())
            .close();
        if ( != null.done();
    }

    
    @Override
    public STATUS status() {
        return ;
    }

    
    @Override
    public boolean errorHandled() {
        return .get();
    }

    
    @Override
    public void error(Throwable t) {
        .warn(""t);
        TransportsUtil.invokeFunction(.t.getClass(), t.name(), );
    }

    
    @Override
    public void future(ListenableFuture f) {
        this. = f;
    }
    @Override
    public void connectedFuture(Future f) {
        this. = f;
    }

    
    @Override
    public STATE onBodyPartReceived(HttpResponseBodyPart bodyPartthrows Exception {
        return .;
    }

    
    @Override
    public STATE onStatusReceived(HttpResponseStatus responseStatusthrows Exception {
        if ( != null.done();
        TransportsUtil.invokeFunction(Integer.classnew Integer(responseStatus.getStatusCode()), .name(), );
        if (responseStatus.getStatusCode() == 101) {
            return .;
        } else {
            .debug("Invalid status code {} for WebSocket Handshake"responseStatus.getStatusCode());
             = ..;
            throw new TransportNotSupported(responseStatus.getStatusCode(), responseStatus.getStatusText());
        }
    }

    
    @Override
    public STATE onHeadersReceived(HttpResponseHeaders headersthrows Exception {
        TransportsUtil.invokeFunction(Map.classheaders.getHeaders(), .name(), );
        return .;
    }

    
    @Override
    public WebSocket onCompleted() throws Exception {
        if ( == null) {
            .error("WebSocket Handshake Failed");
             = ..;
            return null;
        }
        TransportsUtil.invokeFunction(Request.TRANSPORT.classname(), .name(), );
        return ;
    }

    
    @Override
    public void onSuccess(WebSocket webSocket) {
        this. = webSocket;
        .set(true);
        WebSocketTextListener l = new WebSocketTextListener() {
            @Override
            public void onMessage(String message) {
                message = message.trim();
                .trace("{} received {}"name(), message);
                if (message.length() > 0) {
                    TransportsUtil.invokeFunction(,
                            ,
                            ,
                            message.getClass(),
                            message,
                            .name(),
                            );
                }
            }
            @Override
            public void onFragment(String fragmentboolean last) {
            }
            @Override
            public void onOpen(WebSocket websocket) {
                // Could have been closed during the handshake.
                if (.equals(..)) return;
                .set(false);
                Event newStatus = .equals(..) ?  : ;
                TransportsUtil.invokeFunction(newStatus,
                        String.classnewStatus.name(), newStatus.name(), );
            }
            @Override
            public void onClose(WebSocket websocket) {
                if (.get()) return;
                close();
                if (.reconnect()) {
                     = ..;
                    if (.reconnectInSeconds() > 0) {
                        ScheduledExecutorService e = .runtime().getConfig().reaper();
                        e.schedule(new Runnable() {
                            public void run() {
                                reconnect();
                            }
                        }, .reconnectInSeconds(), .);
                    } else {
                        reconnect();
                    }
                }
            }
            @Override
            public void onError(Throwable t) {
                 = ..;
                .debug(""t);
                .set(TransportsUtil.invokeFunction(t.getClass(), t.name(), ));
            }
        };
        webSocket.addWebSocketListener(l);
        l.onOpen(webSocket);
    }
    void reconnect() {
        try {
        } catch (IOException e) {
            .error(""e);
        }
    }

    
    @Override
    public Request.TRANSPORT name() {
        return ..;
    }

    
    @Override
    public Transport registerF(FunctionWrapper function) {
        .add(function);
        return this;
    }

    
    @Override
    public final void onFailure(Throwable t) {
        .set(TransportsUtil.invokeFunction(t.getClass(), t.name(), ));
    }
    public WebSocket webSocket() {
        return ;
    }
New to GrepCode? Check out our FAQ X