org.eclipse.jetty.websocket.servlet.WebSocketServletFactory Java Examples

@Signature
public void addWebSocket(Environment env, String path, ArrayMemory _handlers) {
    WebSocketParam param = _handlers.toBean(env, WebSocketParam.class);

    ContextHandler contextHandler = new ContextHandler(path);
    contextHandler.setHandler(new WebSocketHandler() {
        @Override
        public void configure(WebSocketServletFactory factory) {
            factory.setCreator(new WebSocketCreator() {
                @Override
                public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
                    return new WebSocket(env, param);
                }
            });
        }
    });

    handlers.addHandler(contextHandler);
}
 

@SuppressWarnings("cast")
@Override
public void configure(WebSocketServletFactory factory) {
  if (websocketMaxIdleTime == 0) {
    // Jetty does not allow to set infinite timeout.
    factory.getPolicy().setIdleTimeout(Integer.MAX_VALUE);
  } else {
    factory.getPolicy().setIdleTimeout(websocketMaxIdleTime);
  }
  factory.getPolicy().setMaxTextMessageSize(websocketMaxMessageSize * 1024 * 1024);
  factory.setCreator(new WebSocketCreator() {
    @Override
    public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
      ParticipantId loggedInUser =
          provider.sessionManager.getLoggedInUser(req.getSession());

      return new WebSocketConnection(loggedInUser, provider).getWebSocketServerChannel();
    }
  });
}
 

public synchronized WebSocketServletFactory getWebSocketFactory(Server server) {
    if (webSocketFactory == null) {
        webSockethandler = new WebSocketHandler() {
            @Override
            public void configure(WebSocketServletFactory factory) {
            }
        };
        try {
            webSockethandler.setServer(server);
            webSockethandler.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        webSocketFactory = webSockethandler.getWebSocketFactory();
        webSocketFactory.setCreator(new Creator());
    }
    return webSocketFactory;
}
 

@Override
public void configure(final WebSocketServletFactory factory) {
  factory.setCreator(this);
  factory.getPolicy()
      .setMaxTextMessageSize(config.getWebsocketMaxTextMessageSize());
  factory.getPolicy()
      .setMaxBinaryMessageSize(config.getWebsocketMaxBinaryMessageSize());

  factory.getPolicy().setMaxBinaryMessageBufferSize(
      config.getWebsocketMaxBinaryMessageBufferSize());
  factory.getPolicy().setMaxTextMessageBufferSize(
      config.getWebsocketMaxTextMessageBufferSize());

  factory.getPolicy()
      .setInputBufferSize(config.getWebsocketInputBufferSize());

  factory.getPolicy()
      .setAsyncWriteTimeout(config.getWebsocketAsyncWriteTimeout());
  factory.getPolicy().setIdleTimeout(config.getWebsocketIdleTimeout());

}
 

@Override
public void configure(final WebSocketServletFactory factory) {
  
  final EgressInteractiveHandler self = this;

  final WebSocketCreator oldcreator = factory.getCreator();
  
  WebSocketCreator creator = new WebSocketCreator() {
    @Override
    public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
      InteractiveWebSocket ws = (InteractiveWebSocket) oldcreator.createWebSocket(req, resp);
      ws.setHandler(self);
      try {
        ws.setProcessor(new InteractiveProcessor(self, null, null, null, null));
      } catch (IOException ioe) {
        throw new RuntimeException(ioe);
      }
      return ws;
    }
  };

  factory.setCreator(creator);
  super.configure(factory);
}
 

@Override
public void configure(final WebSocketServletFactory factory) {
  
  final EgressMobiusHandler self = this;

  final WebSocketCreator oldcreator = factory.getCreator();
  
  WebSocketCreator creator = new WebSocketCreator() {
    @Override
    public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
      MobiusWebSocket ws = (MobiusWebSocket) oldcreator.createWebSocket(req, resp);
      ws.setMobiusHandler(self);
      return ws;
    }
  };

  factory.setCreator(creator);
  super.configure(factory);
}
 

public TestJettyWebSocketServer(int port, final WebSocketHandler webSocketHandler) {

			this.server = new Server();
			ServerConnector connector = new ServerConnector(this.server);
			connector.setPort(port);

			this.server.addConnector(connector);
			this.server.setHandler(new org.eclipse.jetty.websocket.server.WebSocketHandler() {
				@Override
				public void configure(WebSocketServletFactory factory) {
					factory.setCreator(new WebSocketCreator() {
						@Override
						public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
							if (!CollectionUtils.isEmpty(req.getSubProtocols())) {
								resp.setAcceptedSubProtocol(req.getSubProtocols().get(0));
							}
							JettyWebSocketSession session = new JettyWebSocketSession(null, null);
							return new JettyWebSocketHandlerAdapter(webSocketHandler, session);
						}
					});
				}
			});
		}
 

public TestJettyWebSocketServer(final WebSocketHandler webSocketHandler) {

			this.server = new Server();
			ServerConnector connector = new ServerConnector(this.server);
			connector.setPort(0);

			this.server.addConnector(connector);
			this.server.setHandler(new org.eclipse.jetty.websocket.server.WebSocketHandler() {
				@Override
				public void configure(WebSocketServletFactory factory) {
					factory.setCreator(new WebSocketCreator() {
						@Override
						public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
							if (!CollectionUtils.isEmpty(req.getSubProtocols())) {
								resp.setAcceptedSubProtocol(req.getSubProtocols().get(0));
							}
							JettyWebSocketSession session = new JettyWebSocketSession(null, null);
							return new JettyWebSocketHandlerAdapter(webSocketHandler, session);
						}
					});
				}
			});
		}
 

public void runServer() {
  if (server.isStarted()) {
    return;
  }

  System.out.println("server port: " + port);
  WebSocketHandler wsHandler =
      new WebSocketHandler() {
        @Override
        public void configure(WebSocketServletFactory factory) {
          factory.register(MinicapWebSocketHandler.class);
        }
      };
  server.setHandler(wsHandler);

  try {
    server.start();
    server.join();
  } catch (Exception e) {
    logger.warning(e.getMessage());
  }
}
 

public TestJettyWebSocketServer(final WebSocketHandler webSocketHandler) {

			this.server = new Server();
			ServerConnector connector = new ServerConnector(this.server);
			connector.setPort(0);

			this.server.addConnector(connector);
			this.server.setHandler(new org.eclipse.jetty.websocket.server.WebSocketHandler() {
				@Override
				public void configure(WebSocketServletFactory factory) {
					factory.setCreator(new WebSocketCreator() {
						@Override
						public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
							if (!CollectionUtils.isEmpty(req.getSubProtocols())) {
								resp.setAcceptedSubProtocol(req.getSubProtocols().get(0));
							}
							JettyWebSocketSession session = new JettyWebSocketSession(null, null);
							return new JettyWebSocketHandlerAdapter(webSocketHandler, session);
						}
					});
				}
			});
		}
 

@Override
public void configure(WebSocketServletFactory factory) {

    //TODO run when server has connection
    factory.getPolicy().setIdleTimeout(idleTimeout);
    applicationContext =
            new AnnotationConfigApplicationContext(ConfigServer.class);
    serverMessageSystem = applicationContext.getBean(ServerMessageSystem.class);
    serverMessageSystem.runMessagesSystem();
    AriaddnaWebSocketCreator socket = applicationContext
            .getBean(AriaddnaWebSocketCreator.class);
    factory.setCreator(socket);
}
 

@Override
public void configure(final WebSocketServletFactory factory) {
    factory.register(CookiesWebSocket.class);
    factory.setCreator(new WebSocketCreator() {
        @Override
        public Object createWebSocket(final ServletUpgradeRequest servletUpgradeRequest,
                final ServletUpgradeResponse servletUpgradeResponse) {
            return new CookiesWebSocket();
        }
    });
}
 

private WebSocketServletFactory getWebSocketFactory(ServletConfig config, ServletContext context) {
    if (webSocketFactory == null) {
        Server server = getServer(config, context);
        return getWebSocketFactory(server);
    }
    return webSocketFactory;
}
 

@Override
public void configure(final WebSocketServletFactory factory) {
  
  final IngressStreamUpdateHandler self = this;

  final WebSocketCreator oldcreator = factory.getCreator();

  WebSocketCreator creator = new WebSocketCreator() {
          
    @Override
    public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
      StandaloneStreamUpdateWebSocket ws = (StandaloneStreamUpdateWebSocket) oldcreator.createWebSocket(req, resp);
      ws.setHandler(self);
      return ws;
    }
  };

  factory.setCreator(creator);
  
  //
  // Update the maxMessageSize if need be
  //
  if (this.ingress.properties.containsKey(Configuration.INGRESS_WEBSOCKET_MAXMESSAGESIZE)) {
    factory.getPolicy().setMaxTextMessageSize((int) Long.parseLong(this.ingress.properties.getProperty(Configuration.INGRESS_WEBSOCKET_MAXMESSAGESIZE)));
    factory.getPolicy().setMaxBinaryMessageSize((int) Long.parseLong(this.ingress.properties.getProperty(Configuration.INGRESS_WEBSOCKET_MAXMESSAGESIZE)));
  }
  super.configure(factory);
}
 

@Override
public void configure(final WebSocketServletFactory factory) {
      
  final StandalonePlasmaHandler self = this;

  final WebSocketCreator oldcreator = factory.getCreator();
  
  WebSocketCreator creator = new WebSocketCreator() {
    @Override
    public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
      StandalonePlasmaWebSocket ws = (StandalonePlasmaWebSocket) oldcreator.createWebSocket(req, resp);
      ws.setHandler(self);
      return ws;
    }
  };

  factory.setCreator(creator);
  
  //
  // Update the maxMessageSize if need be
  //
  if (this.properties.containsKey(Configuration.PLASMA_FRONTEND_WEBSOCKET_MAXMESSAGESIZE)) {
    factory.getPolicy().setMaxTextMessageSize((int) Long.parseLong(this.properties.getProperty(Configuration.PLASMA_FRONTEND_WEBSOCKET_MAXMESSAGESIZE)));
    factory.getPolicy().setMaxBinaryMessageSize((int) Long.parseLong(this.properties.getProperty(Configuration.PLASMA_FRONTEND_WEBSOCKET_MAXMESSAGESIZE)));
  }

  super.configure(factory);
}
 

private void initLogServer() {
  if (logServerThread != null && logServerThread.isAlive()) {
    logServerThread.interrupt();
  }

  if (logServer != null && logServer.isStarted()) {
    try {
      logServer.stop();
    } catch (Exception e) {
      logger.warning(e.getMessage());
    }
  }

  logServerThread =
      new Thread(
          () -> {
            logServer = new Server(8888);

            WebSocketHandler wsHandler =
                new WebSocketHandler() {
                  @Override
                  public void configure(WebSocketServletFactory factory) {
                    factory.register(LogWebSocketHandler.class);
                  }
                };
            logServer.setHandler(wsHandler);

            try {
              logServer.start();
              logServer.join();
            } catch (Exception e) {
              logger.warning(e.getMessage());
            }
          });
  logServerThread.start();
}
 

@Override
public void configure(WebSocketServletFactory factory) {
	factory.getPolicy().setMaxTextMessageSize(MAX_MESSAGE_SIZE);
	factory.getPolicy().setMaxTextMessageBufferSize(MAX_MESSAGE_SIZE);
	factory.getPolicy().setMaxBinaryMessageSize(MAX_MESSAGE_SIZE);
	factory.getPolicy().setMaxBinaryMessageBufferSize(MAX_MESSAGE_SIZE);

	Map<String,WebSocketInvocation> methods = new HashMap<>();
	scanBeanMethods(this.kmehrWsFacade, methods);
	factory.setCreator((req, resp) ->
			new WebSocket(sessionLogic.getCurrentSessionContext(), prefix, gsonMapper, sessionLogic, wsExecutor, methods));
}
 

@Override
public void configure(WebSocketServletFactory factory) {
  // Most implementations of this method simply invoke factory.register(DispatchSocket.class);
  // however, that requires DispatchSocket to have a no-arg constructor. That does not work for
  // us because we would like all WebSockets created by this factory to have a reference to this
  // parent class. This is why we override the default WebSocketCreator for the factory.
  WebSocketCreator wrapperCreator = (req, resp) -> new MyWebSocket();
  factory.setCreator(wrapperCreator);
}
 

@Override
public void configure(WebSocketServletFactory factory) {
  factory.setCreator((req, resp) -> {

    // remove all compressions extensions that might be requested by the browser...
    resp.setExtensions(Collections.<ExtensionConfig>emptyList());

    return new EventSocket(events);
  });
}
 

public void invoke(final ServletConfig config,
                   final ServletContext context,
                   final HttpServletRequest request,
                   final HttpServletResponse response) throws IOException {

    WebSocketServletFactory wsf = getWebSocketFactory(config, context);

    if (wsf.isUpgradeRequest(request, response)
        && wsf.acceptWebSocket(request, response)) {
        ((Request)request).setHandled(true);
        return;
    }
    super.invoke(config, context, request, response);
}
 

@Override
public void configure(WebSocketServletFactory factory) {
    factory.getPolicy().setMaxTextMessageSize(service.getConfig().getWebSocketMaxTextFrameSize());
    if (service.getConfig().getWebSocketSessionIdleTimeoutMillis() > 0) {
        factory.getPolicy().setIdleTimeout(service.getConfig().getWebSocketSessionIdleTimeoutMillis());
    }
    factory.setCreator((request, response) -> new ProducerHandler(service, request.getHttpServletRequest(), response));
}
 

@Override
public void configure(WebSocketServletFactory factory) {
    factory.getPolicy().setMaxTextMessageSize(service.getConfig().getWebSocketMaxTextFrameSize());
    if (service.getConfig().getWebSocketSessionIdleTimeoutMillis() > 0) {
        factory.getPolicy().setIdleTimeout(service.getConfig().getWebSocketSessionIdleTimeoutMillis());
    }
    factory.setCreator(
            (request, response) -> new ConsumerHandler(service, request.getHttpServletRequest(), response));
}
 

@Override
public void configure(WebSocketServletFactory webSocketServletFactory) {
    webSocketServletFactory.setCreator(new WebSocketCreator() {
        @Override
        public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {
            return new JettyWebSocketListener(channelProcessor);
        }
    });
}
 

@Test
public void testFactoryConfiguration() {

	RoboconfWebSocketServlet servlet = new RoboconfWebSocketServlet();
	WebSocketServletFactory factory = Mockito.mock( WebSocketServletFactory.class );

	servlet.configure( factory );
	Mockito.verify( factory ).register( RoboconfWebSocket.class );
}
 

@Override
public void configure(final WebSocketServletFactory factory) {
    factory.register(EventsWebSocket.class);
    factory.setCreator(new WebSocketCreator() {
        @Override
        public EventsWebSocket createWebSocket(final ServletUpgradeRequest servletUpgradeRequest,
                final ServletUpgradeResponse servletUpgradeResponse) {
            return new EventsWebSocket();
        }
    });
}
 

@Override
public void configure(WebSocketServletFactory webSocketServletFactory) {
    PlayerSocketCreator creator =
            new PlayerSocketCreator(transport,
                    authentication,
                    PlayerSocket.SERVER_SEND_FIRST);

    webSocketServletFactory.setCreator(creator);

    timer.resume();
}
 

@Override
public void configure(WebSocketServletFactory webSocketServletFactory) {
    PlayerSocketCreator creator =
            new PlayerSocketCreator(transport,
                    authentication,
                    PlayerSocket.CLIENT_SEND_FIRST);

    webSocketServletFactory.setCreator(creator);
}
 

@Override
public void startHttpServer() {
    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            Server server = new Server(23333);
            try {
                ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
                context.setContextPath("/");
                ServletHolder wsHolder = new ServletHolder("echo", new WebSocketServlet() {
                    @Override
                    public void configure(WebSocketServletFactory factory) {
                        factory.register(WebSocketHandler.class);
                    }
                });
                context.addServlet(wsHolder, "/w");

                URI uri = OmniOcular.class.getResource("/assets/omniocular/static/").toURI();
                context.setBaseResource(Resource.newResource(uri));
                context.setWelcomeFiles(new String[]{"index.html"});
                ServletHolder holderPwd = new ServletHolder("default", DefaultServlet.class);
                holderPwd.setInitParameter("cacheControl", "max-age=0,public");
                holderPwd.setInitParameter("useFileMappedBuffer", "false");
                context.addServlet(holderPwd, "/");

                server.setHandler(context);
                server.start();
                server.join();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    t.start();

}
 

@Override
public void configure(WebSocketServletFactory factory)
{
    if (XmppWebSocket.isCompressionEnabled()) {
        factory.getExtensionFactory().register("permessage-deflate", PerMessageDeflateExtension.class);
    }
    final int messageSize = JiveGlobals.getIntProperty("xmpp.parser.buffer.size", 1048576);
    factory.getPolicy().setMaxTextMessageBufferSize(messageSize * 5);
    factory.getPolicy().setMaxTextMessageSize(messageSize);
    factory.setCreator(new WebSocketCreator() {
        @Override
        public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp)
        {
            try {
                for (String subprotocol : req.getSubProtocols())
                {
                    if ("xmpp".equals(subprotocol))
                    {
                        resp.setAcceptedSubProtocol(subprotocol);
                        return new XmppWebSocket();
                    }
                }
            } catch (Exception e) {
                Log.warn(MessageFormat.format("Unable to load websocket factory: {0} ({1})", e.getClass().getName(), e.getMessage()));
            }
            Log.warn("Failed to create websocket for {}:{} make a request at {}", req.getRemoteAddress(), req.getRemotePort(), req.getRequestPath() );
            return null;
        }
    });
}
 

@Override
public void configure(WebSocketServletFactory factory) {
    factory.getPolicy().setMaxTextMessageSize(service.getConfig().getWebSocketMaxTextFrameSize());
    if (service.getConfig().getWebSocketSessionIdleTimeoutMillis() > 0) {
        factory.getPolicy().setIdleTimeout(service.getConfig().getWebSocketSessionIdleTimeoutMillis());
    }
    factory.setCreator(
            (request, response) -> new ReaderHandler(service, request.getHttpServletRequest(), response));
}