javax.websocket.HandshakeResponse Java Examples

@Override
public void afterRequest(final HttpHeaders headers) {
    ClientEndpointConfig.Configurator configurator = config.getConfigurator();
    if (configurator != null) {
        final Map<String, List<String>> newHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        for (Map.Entry<String, String> entry : headers) {
            ArrayList<String> arrayList = new ArrayList<>(headers.getAll(entry.getKey()));
            newHeaders.put(entry.getKey(), arrayList);
        }
        configurator.afterResponse(new HandshakeResponse() {
            @Override
            public Map<String, List<String>> getHeaders() {
                return newHeaders;
            }
        });
    }
    headers.remove(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL);
    super.afterRequest(headers);
}
 

@Override
public void modifyHandshake(final ServerEndpointConfig config,
        final HandshakeRequest request, final HandshakeResponse response) {
    final HttpSession httpSession = (HttpSession) request.getHttpSession();

    config.getUserProperties().put(HttpSession.class.getName(), httpSession);
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
	HttpSession httpSession = (HttpSession) request.getHttpSession();
	if (null != httpSession) {
		config.getUserProperties().put(HttpSession.class.getName(), httpSession);
	}
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
    HttpSession httpSession = (HttpSession) request.getHttpSession();
    config.getUserProperties().put(MCRServlet.ATTR_MYCORE_SESSION,
        httpSession.getAttribute(MCRServlet.ATTR_MYCORE_SESSION));
    config.getUserProperties().put(HTTP_SESSION, httpSession);
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
	try {
		EffectivePerson effectivePerson = this.getEffectivePerson(request);
		config.getUserProperties().put(HttpToken.X_Person, effectivePerson);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
	try {
		EffectivePerson effectivePerson = this.getEffectivePerson(request);
		config.getUserProperties().put(HttpToken.X_Person, effectivePerson);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config,
        HandshakeRequest request, HandshakeResponse response) {

    super.modifyHandshake(config, request, response);
    
    // Store tunnel request and tunnel request service for retrieval
    // upon WebSocket open
    Map<String, Object> userProperties = config.getUserProperties();
    userProperties.clear();
    userProperties.put(TUNNEL_REQUEST_PROPERTY, new WebSocketTunnelRequest(request));
    userProperties.put(TUNNEL_REQUEST_SERVICE_PROPERTY, tunnelRequestServiceProvider.get());

}
 

@Override
public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
    super.modifyHandshake(sec, request, response);
    
    sec.getUserProperties().put(WebsocketSecurityInterceptor.SESSION_PRINCIPAL, request.getUserPrincipal());
    sec.getUserProperties().put(WebsocketSecurityInterceptor.SESSION_SUBJECT, SecurityContextAssociation.getSubject());
    sec.getUserProperties().put(WebsocketSecurityInterceptor.SESSION_CREDENTIAL, SecurityContextAssociation.getPrincipal());
    Map<String,List<String>> headers = request.getHeaders();
    if (headers != null) {
        List<String> loginHeader = headers.get(REQUEST_LOGIN_TIME_HEADER);
        if (loginHeader != null && !loginHeader.isEmpty()) {
            sec.getUserProperties().put(REQUEST_LOGIN_TIME_HEADER, loginHeader.get(0));
        }
    }
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config,
        HandshakeRequest request,
        HandshakeResponse response) {
    HttpSession httpSession = (HttpSession)request.getHttpSession();
    config.getUserProperties().put("webUserID", httpSession.getAttribute("webUserID"));
}
 

@Override
public void modifyHandshake(
    ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
  HttpSession httpSession = (HttpSession) request.getHttpSession();
  if (httpSession != null) {
    Object sessionSubject = httpSession.getAttribute("che_subject");
    if (sessionSubject != null) {
      sec.getUserProperties().put("che_subject", sessionSubject);
    }
  }
}
 

private ServerEndpointConfig.Configurator configuratorFor(final String prefix, final boolean isRaw) {
	return new ServerEndpointConfig.Configurator() {

		@Override
		public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
			try {
				return endpointClass.getConstructor(SockJsServer.class, String.class, String.class)
						.newInstance(sockJsServer, context.getContextPath(), prefix);
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}

		@Override
		public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request,
				HandshakeResponse response) {
			if (isRaw) {
				// We have no reliable key (like session id) to save
				// headers with for raw websocket requests
				return;
			}
			String path = request.getRequestURI().getPath();
			Matcher matcher = SESSION_PATTERN.matcher(path);
			if (matcher.matches()) {
				String sessionId = matcher.group(1);
				saveHeaders(sessionId, request.getHeaders());
			}
		}
	};
}
 

@Override
public void afterResponse(HandshakeResponse response) {
  List<String> cookie = response.getHeaders().get("set-cookie");
  if (cookie != null) {
    cookieHolder.set(cookie);
  }
}
 

@Override
public void afterResponse( HandshakeResponse hr ) {
  try {
    if ( loginContext != null ) {
      loginContext.logout();
    }
  } catch ( LoginException e ) {
    e.printStackTrace();
    //work is done just ignore
  }
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config,
        HandshakeRequest request, HandshakeResponse response) {

    super.modifyHandshake(config, request, response);
    
    // Store tunnel request and tunnel request service for retrieval
    // upon WebSocket open
    Map<String, Object> userProperties = config.getUserProperties();
    userProperties.clear();
    userProperties.put(TUNNEL_REQUEST_PROPERTY, new WebSocketTunnelRequest(request));
    userProperties.put(TUNNEL_REQUEST_SERVICE_PROPERTY, tunnelRequestServiceProvider.get());

}
 

@Override
public void modifyHandshake(ServerEndpointConfig config,
		HandshakeRequest request, HandshakeResponse response) {
	HttpSession httpSession = (HttpSession) request.getHttpSession();
	config.getUserProperties()
			.put(HttpSession.class.getName(), httpSession);
}
 

private Configurator createConfigurator() {
    return new Configurator() {
        @Override
        public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
            super.modifyHandshake(sec, request, response);
            final HttpSession httpSession = (HttpSession)request.getHttpSession();
            if (httpSession != null) {
                sec.getUserProperties().put(HTTP_SESSION_ATTRIBUTE, httpSession);
            }
            final SecurityContext securityContext = createSecurityContext(request);
            sec.getUserProperties().put(SECURITY_CONTEXT, securityContext);
        }
    };
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config, 
                            HandshakeRequest request, 
                            HandshakeResponse response)
{
    HttpSession httpSession = (HttpSession)request.getHttpSession();
    if (httpSession == null) {
    	return;
    }
    config.getUserProperties().put(HttpSession.class.getName(), httpSession);
}
 

private ServerEndpointConfig.Configurator configuratorFor(final String prefix, final boolean isRaw) {
	return new ServerEndpointConfig.Configurator() {

		@Override
		public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
			try {
				return endpointClass.getConstructor(SockJsServer.class, String.class, String.class)
						.newInstance(sockJsServer, getServletContext().getContextPath(), prefix);
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}

		@Override
		public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request,
				HandshakeResponse response) {

			if (isRaw) {
				// We have no reliable key (like session id) to save
				// headers with for raw websocket requests
				return;
			}

			String path = request.getRequestURI().getPath();
			Matcher matcher = SESSION_PATTERN.matcher(path);
			if (matcher.matches()) {
				String sessionId = matcher.group(1);
				saveHeaders(sessionId, request.getHeaders());
			}
		}
	};
}
 

@Override
public void afterResponse(HandshakeResponse hr) {
    Map<String, List<String>> headers = hr.getHeaders();
    if (headers.containsKey(SEC_WEB_SOCKET_PROTOCOL.toLowerCase(Locale.ENGLISH))) {
        receivedSubProtocol = headers.get(SEC_WEB_SOCKET_PROTOCOL.toLowerCase(Locale.ENGLISH)).get(0);
    } else {
        receivedSubProtocol = null;
    }
    receiveLatch.countDown();
}
 

/**
 * <p>Constructor for DefaultServerEndpointConfig.</p>
 *
 * @param manager a manager
 * @param endpointClass  a {@link java.lang.Class} endpoint class.
 * @param webSocketConf  a {@link ameba.websocket.WebSocket} object.
 */
public DefaultServerEndpointConfig(final InjectionManager manager,
                                   Class endpointClass,
                                   final WebSocket webSocketConf) {
    path = webSocketConf.path();
    subprotocols = Arrays.asList(webSocketConf.subprotocols());
    encoders = Lists.newArrayList(webSocketConf.encoders());
    decoders = Lists.newArrayList(webSocketConf.decoders());
    for (Class<? extends Extension> extensionClass : webSocketConf.extensions()) {
        extensions.add(Injections.getOrCreate(manager, extensionClass));
    }
    final WebSocketEndpointProvider provider = manager.getInstance(WebSocketEndpointProvider.class);

    final EndpointMeta endpointMeta = provider.parseMeta(endpointClass, webSocketConf);

    final ServerEndpointConfig.Configurator cfgr =
            Injections.getOrCreate(manager, webSocketConf.configurator());
    serverEndpointConfigurator = new ServerEndpointConfig.Configurator() {

        @Override
        public String getNegotiatedSubprotocol(List<String> supported, List<String> requested) {
            return cfgr.getNegotiatedSubprotocol(supported, requested);
        }

        @Override
        public List<Extension> getNegotiatedExtensions(List<Extension> installed, List<Extension> requested) {
            return cfgr.getNegotiatedExtensions(installed, requested);
        }

        @Override
        public boolean checkOrigin(String originHeaderValue) {
            return cfgr.checkOrigin(originHeaderValue);
        }

        @Override
        public void modifyHandshake(ServerEndpointConfig sec,
                                    HandshakeRequest request, HandshakeResponse response) {
            cfgr.modifyHandshake(sec, request, response);
        }

        @Override
        public <T> T getEndpointInstance(Class<T> eClass) throws InstantiationException {
            if (EndpointDelegate.class.equals(eClass)) {
                return eClass.cast(new EndpointDelegate(endpointMeta));
            }
            return cfgr.getEndpointInstance(eClass);
        }
    };
}
 

public void modifyHandshake(ServerEndpointConfig sec,
        HandshakeRequest request, HandshakeResponse response) {
    fetchContainerDefaultConfigurator().modifyHandshake(sec, request, response);
}
 

@Override
public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
    List<String> header = new ArrayList<>();
    header.add(ApplicationContext.getHostname());
    response.getHeaders().put("mdw-hostname", header);
}
 

public void modifyHandshake(ServerEndpointConfig sec,
        HandshakeRequest request, HandshakeResponse response) {
    fetchContainerDefaultConfigurator().modifyHandshake(sec, request, response);
}
 

@Override
public void modifyHandshake(ServerEndpointConfig sec,
        HandshakeRequest request, HandshakeResponse response) {
    // NO-OP
}
 

public HandshakeResponse getHandshakeResponse() {
    return handshakeResponse;
}
 

public HttpResponse(int status, HandshakeResponse handshakeResponse) {
    this.status = status;
    this.handshakeResponse = handshakeResponse;
}
 

@Override
public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
	super.modifyHandshake(this, request, response);
}
 

@Override
public void afterResponse(HandshakeResponse response) {
	if (logger.isTraceEnabled()) {
		logger.trace("Handshake response headers: " + response.getHeaders());
	}
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config,
                            HandshakeRequest request,
                            HandshakeResponse response) {
    config.getUserProperties().put("session",request.getHttpSession());
}
 

@Override
public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
    WebSocketUtil.saveHttpSession(config, request);
}