Examples with Action org.atmosphere.cpr.Action used on opensource projects

Example 1 with Action

use of org.atmosphere.cpr.Action in project atmosphere-play by Atmosphere.

the class AtmosphereCoordinator method route.

public boolean route(AtmosphereRequest request, AtmosphereResponse response) throws IOException {
    boolean resumeOnBroadcast = false;
    boolean keptOpen = true;
    boolean skipClose = false;
    final PlayAsyncIOWriter w = PlayAsyncIOWriter.class.cast(response.getAsyncIOWriter());
    try {
        Action a = framework.doCometSupport(request, response);
        final AtmosphereResourceImpl impl = (AtmosphereResourceImpl) request.getAttribute(FrameworkConfig.ATMOSPHERE_RESOURCE);
        String transport = (String) request.getAttribute(FrameworkConfig.TRANSPORT_IN_USE);
        if (transport == null) {
            transport = request.getHeader(X_ATMOSPHERE_TRANSPORT);
        }
        if (a.type() == Action.TYPE.SUSPEND) {
            if (transport.equalsIgnoreCase(HeaderConfig.LONG_POLLING_TRANSPORT) || transport.equalsIgnoreCase(HeaderConfig.JSONP_TRANSPORT)) {
                resumeOnBroadcast = true;
            }
        } else {
            keptOpen = false;
        }
        logger.trace("Transport {} resumeOnBroadcast {}", transport, resumeOnBroadcast);
        final Action action = (Action) request.getAttribute(NettyCometSupport.SUSPEND);
        if (action != null && action.type() == Action.TYPE.SUSPEND && action.timeout() != -1) {
            final AtomicReference<Future<?>> f = new AtomicReference<Future<?>>();
            f.set(suspendTimer.scheduleAtFixedRate(new Runnable() {

                @Override
                public void run() {
                    if (!w.isClosed() && (System.currentTimeMillis() - w.lastTick()) > action.timeout()) {
                        asynchronousProcessor.endRequest(impl, false);
                        f.get().cancel(true);
                    }
                }
            }, action.timeout(), action.timeout(), TimeUnit.MILLISECONDS));
        } else if (action != null && action.type() == Action.TYPE.RESUME) {
            resumeOnBroadcast = false;
        }
        w.resumeOnBroadcast(resumeOnBroadcast);
    } catch (Throwable e) {
        logger.error("Unable to process request", e);
        keptOpen = false;
    } finally {
        if (w != null && !resumeOnBroadcast && !keptOpen) {
            if (!skipClose) {
                w.close((AtmosphereResponse) null);
            }
        }
    }
    return keptOpen;
}

Example 2 with Action

use of org.atmosphere.cpr.Action in project atmosphere by Atmosphere.

the class BlockingIOCometSupport method cancelled.

@Override
public Action cancelled(AtmosphereRequest req, AtmosphereResponse res) throws IOException, ServletException {
    Action a = super.cancelled(req, res);
    if (req.getAttribute(LATCH) != null) {
        CountDownLatch latch = (CountDownLatch) req.getAttribute(LATCH);
        latch.countDown();
    }
    return a;
}

Example 3 with Action

use of org.atmosphere.cpr.Action in project atmosphere by Atmosphere.

the class NettyCometSupport method service.

@Override
public Action service(AtmosphereRequest req, AtmosphereResponse res) throws IOException, ServletException {
    Action action;
    action = suspended(req, res);
    if (action.type() == Action.TYPE.SUSPEND) {
        req.setAttribute(SUSPEND, action);
    } else if (action.type() == Action.TYPE.RESUME) {
        req.setAttribute(SUSPEND, action);
        // If resume occurs during a suspend operation, stop processing.
        Boolean resumeOnBroadcast = (Boolean) req.getAttribute(ApplicationConfig.RESUME_ON_BROADCAST);
        if (resumeOnBroadcast != null && resumeOnBroadcast) {
            return action;
        }
        Action nextAction = resumed(req, res);
        if (nextAction.type() == Action.TYPE.SUSPEND) {
            req.setAttribute(SUSPEND, action);
        }
    }
    return action;
}

Example 4 with Action

use of org.atmosphere.cpr.Action in project atmosphere by Atmosphere.

the class DefaultWebSocketProcessor method open.

@Override
public final void open(final WebSocket webSocket, final AtmosphereRequest request, final AtmosphereResponse response) throws IOException {
    if (framework.isDestroyed())
        return;
    // TODO: Fix this. Instead add an Interceptor.
    if (framework.getAtmosphereConfig().handlers().isEmpty()) {
        synchronized (framework) {
            if (handlers.isEmpty()) {
                logger.warn("No AtmosphereHandler or WebSocketHandler installed. Adding a default one.");
            }
            framework.addAtmosphereHandler(ROOT_MASTER, REFLECTOR_ATMOSPHEREHANDLER);
        }
    }
    request.headers(configureHeader(request)).setAttribute(WebSocket.WEBSOCKET_SUSPEND, true);
    AtmosphereResource r = framework.atmosphereFactory().create(framework.getAtmosphereConfig(), response, framework.getAsyncSupport());
    boolean cleanUpAfterDisconnect = false;
    try {
        request.setAttribute(INJECTED_ATMOSPHERE_RESOURCE, r);
        request.setAttribute(SUSPENDED_ATMOSPHERE_RESOURCE_UUID, r.uuid());
        if (Utils.firefoxWebSocketEnabled(request)) {
            request.setAttribute("firefox", "true");
        }
        AtmosphereResourceImpl.class.cast(r).webSocket(webSocket);
        webSocket.resource(r);
        webSocketProtocol.onOpen(webSocket);
        WebSocketHandler proxy = null;
        if (!handlers.isEmpty()) {
            WebSocketHandlerProxy handler = mapper.map(request, handlers);
            if (handler == null) {
                logger.debug("No WebSocketHandler maps request for {} with mapping {}", request.getRequestURI(), handlers);
                throw new AtmosphereMappingException("No AtmosphereHandler maps request for " + request.getRequestURI());
            }
            proxy = postProcessMapping(webSocket, request, handler);
        }
        dispatch(webSocket, request, response);
        if (proxy != null) {
            webSocket.webSocketHandler(proxy).resource().suspend(-1);
            proxy.onOpen(webSocket);
        }
        request.removeAttribute(INJECTED_ATMOSPHERE_RESOURCE);
        // Resource can be null if the client disconnect.
        if (webSocket.resource() != null) {
            final Action action = ((AtmosphereResourceImpl) webSocket.resource()).action();
            if (action.timeout() != -1 && !framework.getAsyncSupport().getContainerName().contains("Netty")) {
                final AtomicReference<Future<?>> f = new AtomicReference();
                f.set(scheduler.scheduleAtFixedRate(new Runnable() {

                    @Override
                    public void run() {
                        if (WebSocket.class.isAssignableFrom(webSocket.getClass()) && System.currentTimeMillis() - WebSocket.class.cast(webSocket).lastWriteTimeStampInMilliseconds() > action.timeout()) {
                            asynchronousProcessor.endRequest(((AtmosphereResourceImpl) webSocket.resource()), false);
                            f.get().cancel(true);
                        }
                    }
                }, action.timeout(), action.timeout(), TimeUnit.MILLISECONDS));
            }
        } else {
            logger.warn("AtmosphereResource was null");
            cleanUpAfterDisconnect = true;
        }
        notifyListener(webSocket, new WebSocketEventListener.WebSocketEvent("", CONNECT, webSocket));
    } catch (AtmosphereMappingException ex) {
        cleanUpAfterDisconnect = true;
        throw ex;
    } catch (IOException ex) {
        cleanUpAfterDisconnect = true;
        throw ex;
    } catch (Exception ex) {
        logger.trace("onOpen exception", ex);
        cleanUpAfterDisconnect = true;
    } finally {
        if (cleanUpAfterDisconnect) {
            logger.warn("Problem opening websocket for {}", r.uuid());
            framework.atmosphereFactory().remove(r.uuid());
            AtmosphereResourceEventImpl.class.cast(r.getAtmosphereResourceEvent()).setCancelled(true);
            AsynchronousProcessor.class.cast(framework.getAsyncSupport()).completeLifecycle(r, true);
        }
        webSocket.shiftAttributes();
    }
}

Example 5 with Action

use of org.atmosphere.cpr.Action in project atmosphere by Atmosphere.

the class AnnotationScanningTest method create.

@BeforeMethod
public void create() throws Throwable {
    framework = new AtmosphereFramework();
    framework.setDefaultBroadcasterClassName(SimpleBroadcaster.class.getName());
    framework.addAnnotationPackage(AnnotationScanningTest.class);
    framework.setAsyncSupport(new AsynchronousProcessor(framework.getAtmosphereConfig()) {

        @Override
        public Action service(AtmosphereRequest req, AtmosphereResponse res) throws IOException, ServletException {
            return suspended(req, res);
        }

        public void action(AtmosphereResourceImpl r) {
            try {
                resumed(r.getRequest(), r.getResponse());
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ServletException e) {
                e.printStackTrace();
            }
        }
    }).init().addAtmosphereHandler("/a", new AtmosphereHandlerAdapter() {

        @Override
        public void onRequest(AtmosphereResource resource) throws IOException {
            resource.suspend();
        }
    });
}