/**
 *
 * @param context the context to add the web socket endpoints to
 * @param rtEventResource The instance of the websocket endpoint to return
 * @throws DeploymentException
 */
private static void setWebSocketEndpoints(ServletContextHandler context,EventsResource rtEventResource)
        throws DeploymentException,servletexception {

    ServerContainer wsContainer = WebSocketServerContainerInitializer.configureContext(context);

    ServerEndpointConfig serverConfig =
            ServerEndpointConfig.Builder
                                .create(EventsResource.class,EventsResource.RT_EVENT_ENDPOINT)
                                .configurator(new Configurator() {
                                    @Override
                                    public <T> T getEndpointInstance(Class<T> endpointClass)
                                            throws InstantiationException {
                                        return endpointClass.cast(rtEventResource);
                                    }
                                }).build();

    wsContainer.addEndpoint(serverConfig);
}

@Override
protected void startServer(int port,final Action<ServerWebSocket> websocketAction) throws
  Exception {
  server = new Server();
  ServerConnector connector = new ServerConnector(server);
  connector.setPort(port);
  server.addConnector(connector);
  ServletContextHandler handler = new ServletContextHandler();
  server.setHandler(handler);
  ServerContainer container = WebSocketServerContainerInitializer.configureContext(handler);
  ServerEndpointConfig config = ServerEndpointConfig.Builder.create(AsityServerEndpoint.class,TEST_URI)
  .configurator(new Configurator() {
    @Override
    public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
      return endpointClass.cast(new AsityServerEndpoint().onwebsocket(websocketAction));
    }
  })
  .build();
  container.addEndpoint(config);
  server.start();
}

@Override
protected void startServer() throws Exception {
    server = new Server();
    ServerConnector connector = new ServerConnector(server);
    connector.setPort(port);
    server.addConnector(connector);
    ServletContextHandler handler = new ServletContextHandler();
    server.setHandler(handler);
    ServerContainer container = WebSocketServerContainerInitializer.configureContext(handler);
    ServerEndpointConfig config = ServerEndpointConfig.Builder.create(VibeServerEndpoint.class,"/test")
    .configurator(new Configurator() {
        @Override
        public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
            return endpointClass.cast(new VibeServerEndpoint().onwebsocket(performer.serverAction()));
        }
    })
    .build();
    container.addEndpoint(config);
    server.start();
}

public static void init(final ServletContextHandler context,final MinijaxApplication application)
        throws servletexception,DeploymentException {

    final ServerContainer container = WebSocketServerContainerInitializer.configureContext(context);
    final Configurator configurator = new MinijaxWebSocketConfigurator(application);

    for (final Class<?> c : application.getWebSockets()) {
        final ServerEndpointConfig config = ServerEndpointConfig.Builder
                .create(c,c.getAnnotation(ServerEndpoint.class).value())
                .configurator(configurator)
                .build();
        container.addEndpoint(config);
    }
}

@Override
public HttpServer createHttpServerInstance(final int port) throws IOException {
    try {
        final HttpsServer server = HttpsServer.create(new InetSocketAddress(port),5);
        server.setHttpsConfigurator(new HttpsConfigurator(sslContext) {
            @Override
            public void configure(final HttpsParameters params) {
                final SSLContext c = getSSLContext();

                // get the default parameters
                final SSLParameters sslparams = c.getDefaultSSLParameters();

                params.setSSLParameters(sslparams);
                // statement above Could throw IAE if any params invalid.
                // eg. if app has a UI and parameters supplied by a user.
            }
        });

        s_logger.info("create HTTPS server instance on port: " + port);
        return server;
    } catch (final Exception ioe) {
        s_logger.error(ioe.toString(),ioe);
    }
    return null;
}

protected HttpsServer startHttpsServer(SSLContext ctx) throws Exception {
    InetSocketAddress localhost = new InetSocketAddress("127.0.0.59",59995);
    HttpsServer server = HttpsServer.create(localhost,0);
    server.setHttpsConfigurator(new HttpsConfigurator(ctx));

    server.createContext("/",(t) -> {
        byte[] data = "success".getBytes();
        t.sendResponseHeaders(HttpURLConnection.HTTP_OK,data.length);
        OutputStream o = t.getResponseBody();
        o.write(data);
        o.close();
    });
    server.setExecutor(null);
    server.start();

    return server;
}

/**
 * Internal method which creates and starts the server.
 *
 * @param httpsMode True if the server to be started is HTTPS,false otherwise.
 * @return Started server.
 */
private static GridEmbeddedHttpServer createAndStart(boolean httpsMode) throws Exception {
    HttpServer httpSrv;
    InetSocketAddress addrToBind = new InetSocketAddress(HOSTNAME_TO_BIND_SRV,getAvailablePort());

    if (httpsMode) {
        HttpsServer httpsSrv = HttpsServer.create(addrToBind,0);

        httpsSrv.setHttpsConfigurator(new HttpsConfigurator(GridTestUtils.sslContext()));

        httpSrv = httpsSrv;
    }
    else
        httpSrv = HttpServer.create(addrToBind,0);

    GridEmbeddedHttpServer embeddedHttpSrv = new GridEmbeddedHttpServer();

    embeddedHttpSrv.proto = httpsMode ? "https" : "http";
    embeddedHttpSrv.httpSrv = httpSrv;
    embeddedHttpSrv.httpSrv.start();

    return embeddedHttpSrv;
}

private static HttpServer initHttpsServer(InputStream keystoreInputSteam,char[] password) throws IOException {
        try {
            KeyStore ks = KeyStore.getInstance("JKS");
            ks.load(keystoreInputSteam,password);
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            kmf.init(ks,password);

            TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
            tmf.init(ks);

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(kmf.getKeyManagers(),tmf.getTrustManagers(),null);
            HttpsServer httpsServer = HttpsServer.create();
            httpsServer.setHttpsConfigurator(new HttpsConfigurator(sslContext));
            return httpsServer;
        } catch (NoSuchAlgorithmException | CertificateException | KeyStoreException | UnrecoverableKeyException
            | KeyManagementException e) {
            throw new RuntimeException(e);
        }
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,NoSuchAlgorithmException  {
    httpsServer = com.sun.net.httpserver.HttpsServer.create(new InetSocketAddress(0),0);
    httpsServer.createContext("/",new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,0);
    httpsServer.createContext("/test6614957/",new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

public static void initServer() throws IOException {

        Logger logger = Logger.getLogger("com.sun.net.httpserver");
        ConsoleHandler ch = new ConsoleHandler();
        logger.setLevel(Level.ALL);
        ch.setLevel(Level.ALL);
        logger.addHandler(ch);

        String root = System.getProperty("test.src") + "/docs";
        InetSocketAddress addr = new InetSocketAddress(0);
        httpServer = HttpServer.create(addr,0);
        if (httpServer instanceof HttpsServer) {
            throw new RuntimeException("should not be httpsserver");
        }
        httpsServer = HttpsServer.create(addr,0);
        HttpHandler h = new FileServerHandler(root);

        HttpContext c1 = httpServer.createContext("/files",h);
        HttpContext c2 = httpsServer.createContext("/files",h);
        HttpContext c3 = httpServer.createContext("/echo",new EchoHandler());
        redirectHandler = new RedirectHandler("/redirect");
        redirectHandlerSecure = new RedirectHandler("/redirect");
        HttpContext c4 = httpServer.createContext("/redirect",redirectHandler);
        HttpContext c41 = httpsServer.createContext("/redirect",redirectHandlerSecure);
        HttpContext c5 = httpsServer.createContext("/echo",new EchoHandler());
        HttpContext c6 = httpServer.createContext("/keepalive",new KeepAliveHandler());
        redirectErrorHandler = new RedirectErrorHandler("/redirecterror");
        redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror");
        HttpContext c7 = httpServer.createContext("/redirecterror",redirectErrorHandler);
        HttpContext c71 = httpsServer.createContext("/redirecterror",redirectErrorHandlerSecure);
        delayHandler = new DelayHandler();
        HttpContext c8 = httpServer.createContext("/delay",delayHandler);
        HttpContext c81 = httpsServer.createContext("/delay",delayHandler);

        executor = Executors.newCachedThreadPool();
        httpServer.setExecutor(executor);
        httpsServer.setExecutor(executor);
        ctx = new SimpleSSLContext().get();
        httpsServer.setHttpsConfigurator(new HttpsConfigurator(ctx));
        httpServer.start();
        httpsServer.start();

        port = httpServer.getAddress().getPort();
        System.out.println("HTTP server port = " + port);
        httpsport = httpsServer.getAddress().getPort();
        System.out.println("HTTPS server port = " + httpsport);
        httproot = "http://127.0.0.1:" + port + "/";
        httpsroot = "https://127.0.0.1:" + httpsport + "/";

        proxy = new ProxyServer(0,false);
        proxyPort = proxy.getPort();
        System.out.println("Proxy port = " + proxyPort);
    }

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

public static void initServer() throws IOException {

        Logger logger = Logger.getLogger("com.sun.net.httpserver");
        ConsoleHandler ch = new ConsoleHandler();
        logger.setLevel(Level.ALL);
        ch.setLevel(Level.ALL);
        logger.addHandler(ch);

        String root = System.getProperty("test.src") + "/docs";
        InetSocketAddress addr = new InetSocketAddress(0);
        httpServer = HttpServer.create(addr,false);
        proxyPort = proxy.getPort();
        System.out.println("Proxy port = " + proxyPort);
    }

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

private static HttpsServer createHttpsServer(int port) throws Exception {
    generateCertificate();
    HttpsServer httpsServer = HttpsServer.create(new InetSocketAddress(port),0);
    SSLContext sslContext = getSslContext();
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(sslContext));
    return httpsServer;
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

public static void startHttpsServer() throws CertificateException,IOException,KeyManagementException,KeyStoreException,NoSuchAlgorithmException,UnrecoverableKeyException {
    HttpsServer httpsServer = HttpsServer.create(new InetSocketAddress(443),0);
    char[] keystorePassword = "password".tochararray();
    SSLContext sslContext = SSLContext.getInstance("TLS");
    KeyStore keyStore = KeyStore.getInstance("JKS");
    keyStore.load(new FileInputStream("keystore.jks"),keystorePassword);
    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
    keyManagerFactory.init(keyStore,keystorePassword);
    sslContext.init(keyManagerFactory.getKeyManagers(),null,null);
    HttpsConfigurator configurator = new HttpsConfigurator(sslContext);
    httpsServer.createContext("/example",new ExampleHandler());
    httpsServer.setHttpsConfigurator(configurator);
    httpsServer.setExecutor(null);
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

protected void startHttpsServer() throws Exception {
  final InetSocketAddress addr = new InetSocketAddress(httpsServerPort);
  httpsServer = HttpsServer.create(addr,0);
  httpsServer.setExecutor(Executors.newCachedThreadPool());
  attachHttpHandlers(httpsServer);

  final char[] passphrase = KEYSTORE_PASSWORD.tochararray();
  final KeyStore ks = KeyStore.getInstance("JKS");
  ks.load(getKeyStore(),passphrase);

  final KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
  kmf.init(ks,passphrase);

  final TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
  tmf.init(ks);

  final SSLContext ssl = SSLContext.getInstance("TLS");
  ssl.init(kmf.getKeyManagers(),null);

  httpsServer.setHttpsConfigurator(new HttpsConfigurator(ssl) {
    @Override
    public void configure(final HttpsParameters params) {
      final SSLContext c = getSSLContext();
      final SSLParameters sslparams = c.getDefaultSSLParameters();
      params.setSSLParameters(sslparams);
    }
  });

  httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

@Override
public HttpServer createHttpServerInstance(int port) throws IOException {
    try {
        HttpsServer server = HttpsServer.create(new InetSocketAddress(port),5);
        server.setHttpsConfigurator(new HttpsConfigurator(sslContext) {
            @Override
            public void configure(HttpsParameters params) {

                // get the remote address if needed
                InetSocketAddress remote = params.getClientAddress();
                SSLContext c = getSSLContext();

                // get the default parameters
                SSLParameters sslparams = c.getDefaultSSLParameters();

                params.setSSLParameters(sslparams);
                params.setProtocols(SSLUtils.getRecommendedProtocols());
                params.setCipherSuites(SSLUtils.getRecommendedCiphers());
                // statement above Could throw IAE if any params invalid.
                // eg. if app has a UI and parameters supplied by a user.
            }
        });

        s_logger.info("create HTTPS server instance on port: " + port);
        return server;
    } catch (Exception ioe) {
        s_logger.error(ioe.toString(),ioe);
    }
    return null;
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

/**
 * Https Server
 */
public void startHttpsServer() throws IOException,new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}

@Test
public void shouldSetHttpsParametersOnEveryRequest() throws Exception {
    // setup
    final SSLParameters defaultSslParameters = mock(SSLParameters.class);
    final String[] cipherSuites = new String[0];
    final String[] protocols = new String[0];
    SSLEngine sslEngine = mock(SSLEngine.class);
    when(sslEngine.getEnabledCipherSuites()).thenReturn(cipherSuites);
    when(sslEngine.getEnabledProtocols()).thenReturn(protocols);

    when(sslContext.getDefaultSSLParameters()).thenReturn(defaultSslParameters);
    when(sslContext.createSSLEngine()).thenReturn(sslEngine);

    doAnswer(new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {

            HttpsParameters httpsParameters = mock(HttpsParameters.class);

            HttpsConfigurator httpsConfigurator = (HttpsConfigurator) invocation.getArguments()[0];
            httpsConfigurator.configure(httpsParameters);

            verify(httpsParameters).setSSLParameters(defaultSslParameters);
            verify(httpsParameters).setNeedClientAuth(false);
            verify(httpsParameters).setWantClientAuth(false);
            verify(httpsParameters).setCipherSuites(cipherSuites);
            verify(httpsParameters).setProtocols(protocols);

            return null;
        }
    }).when(httpsServer).setHttpsConfigurator(isA(HttpsConfigurator.class));

    // act
    HttpServer result = simpleHttpsServerfactorybean.getinitializedServer(inetSocketAddress);

    // assert
    verify(httpsServer).setHttpsConfigurator(isA(HttpsConfigurator.class));
    assertEquals(httpsServer,result);
}

private HttpsConfigurator createHttpsConfigurator() throws Exception {
  KeyStore keyStore = loadKeyStore();
  SSLContext sslContext = SSLContext.getInstance("TLS");
  sslContext.init(createKeyManagerFactory(keyStore).getKeyManagers(),createTrustManagerFactory(keyStore)
      .getTrustManagers(),null);
  return new HttpsConfigurator(sslContext);
}

private HttpsConfigurator createHttpsConfigurator() throws Exception {
    KeyStore keyStore = loadKeyStore();
    SSLContext sslContext = SSLContext.getInstance("TLS");
    sslContext.init(createKeyManagerFactory(keyStore).getKeyManagers(),createTrustManagerFactory(keyStore)
            .getTrustManagers(),null);
    return new HttpsConfigurator(sslContext);
}

private HttpsConfigurator getConfigurator(SSLContext sslContext) {
  return new HttpsConfigurator(sslContext) {
        @Override
        public void configure (HttpsParameters params) {
          SSLContext context = getSSLContext();
          SSLParameters sslParams = context.getDefaultSSLParameters();
          params.setNeedClientAuth(false);
          params.setSSLParameters(sslParams);
        }
      };
}

/**
 * Create a VaadinSession
 * @param locale Client locale
 * @return VaadinSession instance
 * @throws Exception Failed to create session
 */
protected VaadinSession createVaadinSession(Locale locale) throws Exception {
    WrappedSession wrappedSession = mock(WrappedSession.class);
    VaadinServletService vaadinService = mock(VaadinServletService.class);
    when(vaadinService.getDeploymentConfiguration())
            .thenReturn(new DefaultDeploymentConfiguration(VaadinServletService.class,getDeploymentProperties()));

    VaadinSession session = mock(VaadinSession.class);
    when(session.getState()).thenReturn(VaadinSession.State.OPEN);
    when(session.getSession()).thenReturn(wrappedSession);
    when(session.getService()).thenReturn(vaadinService);
    when(session.getSession().getId()).thenReturn(TEST_SESSION_ID);
    when(session.hasLock()).thenReturn(true);
    when(session.getLocale()).thenReturn(locale != null ? locale : Locale.US);
    return session;
}

/**
 * Create a VaadinSession
 * @param locale Client locale
 * @return VaadinSession instance
 * @throws Exception Failed to create session
 */
protected VaadinSession createVaadinSession(Locale locale) throws Exception {
    WrappedSession wrappedSession = mock(WrappedSession.class);
    VaadinServletService vaadinService = mock(VaadinServletService.class);
    when(vaadinService.getDeploymentConfiguration())
            .thenReturn(new DefaultDeploymentConfiguration(VaadinServletService.class,getDeploymentProperties()));

    VaadinSession session = mock(VaadinSession.class);
    when(session.getState()).thenReturn(VaadinSession.State.OPEN);
    when(session.getSession()).thenReturn(wrappedSession);
    when(session.getService()).thenReturn(vaadinService);
    when(session.getSession().getId()).thenReturn(TEST_SESSION_ID);
    when(session.hasLock()).thenReturn(true);
    when(session.getLocale()).thenReturn(locale != null ? locale : Locale.US);
    return session;
}

public TestSpringVaadinServletService(VaadinServlet servlet,WebApplicationContext applicationContext)
        throws ServiceException {
    super(servlet,new DefaultDeploymentConfiguration(TestSpringVaadinServletService.class,new Properties()),"");
    this.appContext = applicationContext;
    init();
}

public TestSpringVaadinServletService(VaadinServlet servlet,"");
    this.appContext = applicationContext;
    init();
}

private DefaultDeploymentConfiguration createDeploymentConfiguration() {
    return new DefaultDeploymentConfiguration(getClass(),initProperties());
}

public VertxVaadinService(VertxVaadin vertxVaadin,DefaultDeploymentConfiguration deploymentConfiguration) {
    super(deploymentConfiguration);
    this.vertxVaadin = vertxVaadin;
}

@Override
protected VaadinServletService createServletService(DeploymentConfiguration deploymentConfiguration)
        throws ServiceException {
    JMeterService service = new JMeterService(this,deploymentConfiguration);
    service.init();
    return service;
}

@Override
protected VaadinServletService createServletService(DeploymentConfiguration deploymentConfiguration)
        throws ServiceException {
    VaadinServletService servletService = super.createServletService(deploymentConfiguration);
    servletService.addSessionInitListener(e -> e.getSession().addUIProvider(this.uiProvider));
    servletService.addSessionInitListener(e -> sessions.add(e.getSession()));
    servletService.addSessionDestroyListener(e -> sessions.remove(e.getSession()));
    return servletService;
}

@Override
protected VaadinServletService createServletService(DeploymentConfiguration deploymentConfiguration) throws ServiceException {
    VaadinServletService servletService = super.createServletService(deploymentConfiguration);
    servletService.addSessionInitListener(new SessionInitListener() {
        @Override
        public void sessionInit(SessionInitEvent sessionInitEvent) throws ServiceException {
            sessionInitEvent.getSession().addUIProvider(provider);
        }
    });
    return servletService;
}

public JMeterService(VaadinServlet servlet,DeploymentConfiguration deploymentConfiguration)
        throws ServiceException {
    super(servlet,deploymentConfiguration,null);
}

@BeforeClass
public static void beforeClass() {
    DeploymentConfiguration conf = new TestDeploymentConfiguration();
    VaadinService service = new TestVaadinService(conf);
    VaadinService.setCurrent(service);
}

public TestVaadinService(DeploymentConfiguration deploymentConfiguration) {
    super(deploymentConfiguration);
}

/**
 * Create a servlet service instance that allows the use of a custom service
 * URL.
 *
 * @param servlet
 * @param deploymentConfiguration
 * @param serviceUrl              custom service URL to use (relative to context path,starting
 *                                with a slash) or null for default
 * @throws ServiceException
 */
public Vaadin4SpringServletService(VaadinServlet servlet,DeploymentConfiguration deploymentConfiguration,String serviceUrl) throws ServiceException {
    super(servlet,serviceUrl);
    logger.info("Using custom Vaadin4Spring servlet service");
    applicationContext = WebApplicationContextUtils.getWebApplicationContext(servlet.getServletContext());
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce.getServletContext().getAttribute(
            Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    List<Class<? extends Encoder>> encoders = new ArrayList<Class<? extends Encoder>>();
    encoders.add(Bug58624Encoder.class);
    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            Bug58624Endpoint.class,PATH).encoders(encoders).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

DefaultServerEndpointConfig(Class<?> endpointClass,String path,List<String> subprotocols,List<Extension> extensions,List<Class<? extends Encoder>> encoders,List<Class<? extends Decoder>> decoders,ServerEndpointConfig.Configurator serverEndpointConfigurator) {
    this.path = path;
    this.endpointClass = endpointClass;
    this.subprotocols = Collections.unmodifiableList(subprotocols);
    this.extensions = Collections.unmodifiableList(extensions);
    this.encoders = Collections.unmodifiableList(encoders);
    this.decoders = Collections.unmodifiableList(decoders);
    if (serverEndpointConfigurator == null) {
        this.serverEndpointConfigurator = ServerEndpointConfig.Configurator.fetchContainerDefaultConfigurator();
    } else{  
        this.serverEndpointConfigurator = serverEndpointConfigurator;
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce.getServletContext().getAttribute(
            Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    List<Class<? extends Encoder>> encoders = new ArrayList<Class<? extends Encoder>>();
    encoders.add(Bug58624Encoder.class);
    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            Bug58624Endpoint.class,PATH).encoders(encoders).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

private ConfiguredServerEndpoint createConfiguredServerEndpoint(String selectedProtocol,List<Extension> selectedExtensions,Endpoint endpoint,HttpServletRequest servletRequest) {

    String path = servletRequest.getRequestURI();  // shouldn't matter
    ServerEndpointRegistration endpointRegistration = new ServerEndpointRegistration(path,endpoint);
    endpointRegistration.setSubprotocols(Arrays.asList(selectedProtocol));
    endpointRegistration.setExtensions(selectedExtensions);

    EncodingFactory encodingFactory = new EncodingFactory(
            Collections.<Class<?>,List<InstanceFactory<? extends Encoder>>>emptyMap(),Collections.<Class<?>,List<InstanceFactory<? extends Decoder>>>emptyMap(),List<InstanceFactory<? extends Decoder>>>emptyMap());
    try {
        return (endpointConstructorWithEndpointFactory ?
                endpointConstructor.newInstance(endpointRegistration,new EndpointInstanceFactory(endpoint),null,encodingFactory,null) :
                endpointConstructor.newInstance(endpointRegistration,encodingFactory));
    }
    catch (Exception ex) {
        throw new HandshakeFailureException("Failed to instantiate ConfiguredServerEndpoint",ex);
    }
}

protected ServerEndpointConfig createWsServerEndpointConfig(ServletContext servletContext) {
  final List<Class<? extends Encoder>> encoders = new LinkedList<>();
  final List<Class<? extends Decoder>> decoders = new LinkedList<>();
  encoders.add(OutputMessageEncoder.class);
  decoders.add(InputMessageDecoder.class);
  final ServerEndpointConfig endpointConfig =
      create(CheWSConnection.class,websocketContext + websocketEndPoint)
          .configurator(createConfigurator())
          .encoders(encoders)
          .decoders(decoders)
          .build();
  endpointConfig
      .getUserProperties()
      .put(EVERREST_PROCESSOR_ATTRIBUTE,getEverrestProcessor(servletContext));
  endpointConfig
      .getUserProperties()
      .put(EVERREST_CONfig_ATTRIBUTE,getEverrestConfiguration(servletContext));
  endpointConfig.getUserProperties().put(EXECUTOR_ATTRIBUTE,createExecutor(servletContext));
  return endpointConfig;
}

protected ServerEndpointConfig createEventbusServerEndpointConfig(ServletContext servletContext) {
  final List<Class<? extends Encoder>> encoders = new LinkedList<>();
  final List<Class<? extends Decoder>> decoders = new LinkedList<>();
  encoders.add(OutputMessageEncoder.class);
  decoders.add(InputMessageDecoder.class);
  final ServerEndpointConfig endpointConfig =
      create(CheWSConnection.class,websocketContext + eventBusEndPoint)
          .configurator(createConfigurator())
          .encoders(encoders)
          .decoders(decoders)
          .build();
  endpointConfig
      .getUserProperties()
      .put(EVERREST_PROCESSOR_ATTRIBUTE,createExecutor(servletContext));
  return endpointConfig;
}

@Override
protected ServerEndpointConfig buildServerEndpointConfig(String path,WebSocket wseAnnotation,Class<?> annotatedClass,String[] subProtocols,List<Class<? extends Encoder>> encoderClasses,List<Class<? extends Decoder>> decoderClasses) {
    int max = getMaxSessions(annotatedClass);
    if (max != -1) {
        TyrusServerEndpointConfig.Builder builder =
                TyrusServerEndpointConfig.Builder
                        .create(annotatedClass,path)
                        .encoders(encoderClasses)
                        .decoders(decoderClasses)
                        .subprotocols(Arrays.asList(subProtocols));
        if (!ServerEndpointConfig.Configurator.class.equals(wseAnnotation.configurator())) {
            builder = builder.configurator(Injections.getorCreate(manager,wseAnnotation.configurator()));
        }
        return builder.maxSessions(max).build();
    }
    return super.buildServerEndpointConfig(path,wseAnnotation,annotatedClass,subProtocols,encoderClasses,decoderClasses);
}

private Encoder findEncoder(Object obj) {
    for (EncoderEntry entry : encoderEntries) {
        if (entry.getClazz().isAssignableFrom(obj.getClass())) {
            return entry.getEncoder();
        }
    }
    return null;
}

DefaultServerEndpointConfig(
        Class<?> endpointClass,Configurator serverEndpointConfigurator) {
    this.endpointClass = endpointClass;
    this.path = path;
    this.subprotocols = subprotocols;
    this.extensions = extensions;
    this.encoders = encoders;
    this.decoders = decoders;
    this.serverEndpointConfigurator = serverEndpointConfigurator;
}

private Encoder findEncoder(Object obj) {
    for (EncoderEntry entry : encoderEntries) {
        if (entry.getClazz().isAssignableFrom(obj.getClass())) {
            return entry.getEncoder();
        }
    }
    return null;
}

DefaultServerEndpointConfig(
        Class<?> endpointClass,Configurator serverEndpointConfigurator) {
    this.endpointClass = endpointClass;
    this.path = path;
    this.subprotocols = subprotocols;
    this.extensions = extensions;
    this.encoders = encoders;
    this.decoders = decoders;
    this.serverEndpointConfigurator = serverEndpointConfigurator;
}

private Encoder findEncoder(Object obj) {
    for (EncoderEntry entry : encoderEntries) {
        if (entry.getClazz().isAssignableFrom(obj.getClass())) {
            return entry.getEncoder();
        }
    }
    return null;
}

DefaultServerEndpointConfig(Class<?> endpointClass,Configurator serverEndpointConfigurator) {
    this.endpointClass = endpointClass;
    this.path = path;
    this.subprotocols = subprotocols;
    this.extensions = extensions;
    this.encoders = encoders;
    this.decoders = decoders;
    this.serverEndpointConfigurator = serverEndpointConfigurator;
}

@Override
public Set<ServerEndpointConfig> getEndpointConfigs(Set<Class<? extends Endpoint>> endpointClasses) {
    logger.info("Checking the endpoint...");
    // Configuring the decoders
    List<Class<? extends Decoder>> decoders = new LinkedList<>();
    decoders.add(CommandMessageDecoder.class);
    // Configuring the encoders
    List<Class<? extends Encoder>> encoders = new LinkedList<>();
    encoders.add(CommandMessageEncoder.class);
    Set<ServerEndpointConfig> configs = new HashSet<>();
    configs.add(ServerEndpointConfig.Builder.create(ClientChatEndpoint.class,"/chat").decoders(decoders).encoders(encoders).build());
    configs.add(ServerEndpointConfig.Builder.create(SupportChatEndpoint.class,"/support").decoders(decoders).encoders(encoders).build());
    return configs;
}

private Encoder findEncoder(Object obj) {
    for (EncoderEntry entry : encoderEntries) {
        if (entry.getClazz().isAssignableFrom(obj.getClass())) {
            return entry.getEncoder();
        }
    }
    return null;
}

DefaultServerEndpointConfig(
        Class<?> endpointClass,Configurator serverEndpointConfigurator) {
    this.endpointClass = endpointClass;
    this.path = path;
    this.subprotocols = subprotocols;
    this.extensions = extensions;
    this.encoders = encoders;
    this.decoders = decoders;
    this.serverEndpointConfigurator = serverEndpointConfigurator;
}

/**
 * Processes requests for both HTTP
 * <code>GET</code> and
 * <code>POST</code> methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws servletexception if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request,HttpServletResponse response)
        throws servletexception,IOException {
    response.setContentType("text/html;charset=UTF-8");
    try (PrintWriter out = response.getWriter()) {
        out.println("<html>");
        out.println("<head>");
        out.println("<title>Servlet TestServlet</title>");            
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Servlet TestServlet at " + request.getcontextpath() + "</h1>");

        List<Class<? extends Encoder>> encoders = new ArrayList<>();
        encoders.add(MyMessageEncoder.class);
        List<Class<? extends Decoder>> decoders = new ArrayList<>();
        decoders.add(MyMessageDecoder.class);

        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        String uri = "ws://localhost:8080" + request.getcontextpath() + "/websocket";
        out.println("Connecting to " + uri);
        container.connectToServer(MyClient.class,ClientEndpointConfig.Builder.create()
                .encoders(encoders)
                .decoders(decoders)
                .build(),URI.create(uri));
        out.println("<br><br>Look in server.log for message exchange between client/server.");

        out.println("</body>");
        out.println("</html>");
    } catch (DeploymentException ex) {
        Logger.getLogger(TestClient.class.getName()).log(Level.SEVERE,ex);
    }
}

private Encoder findEncoder(Object obj) {
    for (EncoderEntry entry : encoderEntries) {
        if (entry.getClazz().isAssignableFrom(obj.getClass())) {
            return entry.getEncoder();
        }
    }
    return null;
}

DefaultServerEndpointConfig(
        Class<?> endpointClass,Configurator serverEndpointConfigurator) {
    this.endpointClass = endpointClass;
    this.path = path;
    this.subprotocols = subprotocols;
    this.extensions = extensions;
    this.encoders = encoders;
    this.decoders = decoders;
    this.serverEndpointConfigurator = serverEndpointConfigurator;
}

public EncoderEntry(Class<?> clazz,Encoder encoder) {
    this.clazz = clazz;
    this.encoder = encoder;
}

public Encoder getEncoder() {
    return encoder;
}

static Class<?> getEncoderType(Class<? extends Encoder> encoder) {
    return Util.getGenericType(Encoder.class,encoder).getClazz();
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return perEndpointConfig.getEncoders();
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return this.encoders;
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    org.apache.tomcat.websocket.server.Constants.
                    SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(new ServerEndpointConfig() {
            @Override
            public Map<String,Object> getUserProperties() {
                return Collections.emptyMap();
            }
            @Override
            public List<Class<? extends Encoder>> getEncoders() {
                List<Class<? extends Encoder>> encoders = new ArrayList<Class<? extends Encoder>>(2);
                encoders.add(MsgStringEncoder.class);
                encoders.add(MsgByteEncoder.class);
                return encoders;
            }
            @Override
            public List<Class<? extends Decoder>> getDecoders() {
                List<Class<? extends Decoder>> decoders = new ArrayList<Class<? extends Decoder>>(2);
                decoders.add(MsgStringDecoder.class);
                decoders.add(MsgByteDecoder.class);
                return decoders;
            }
            @Override
            public List<String> getSubprotocols() {
                return Collections.emptyList();
            }
            @Override
            public String getPath() {
                return PATH_PROGRAMMATIC_EP;
            }
            @Override
            public List<Extension> getExtensions() {
                return Collections.emptyList();
            }
            @Override
            public Class<?> getEndpointClass() {
                return ProgrammaticEndpoint.class;
            }
            @Override
            public Configurator getConfigurator() {
                return new ServerEndpointConfig.Configurator() {
                };
            }
        });
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return Collections.emptyList();
}

public EncoderEntry(Class<?> clazz,Encoder encoder) {
    this.clazz = clazz;
    this.encoder = encoder;
}

public Encoder getEncoder() {
    return encoder;
}

static Class<?> getEncoderType(Class<? extends Encoder> encoder) {
    return Util.getGenericType(Encoder.class,encoder).getClazz();
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return perEndpointConfig.getEncoders();
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return this.encoders;
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    org.apache.tomcat.websocket.server.Constants.
                    SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(new ServerEndpointConfig() {
            @Override
            public Map<String,Object> getUserProperties() {
                return Collections.emptyMap();
            }
            @Override
            public List<Class<? extends Encoder>> getEncoders() {
                List<Class<? extends Encoder>> encoders = new ArrayList<Class<? extends Encoder>>(2);
                encoders.add(MsgStringEncoder.class);
                encoders.add(MsgByteEncoder.class);
                return encoders;
            }
            @Override
            public List<Class<? extends Decoder>> getDecoders() {
                List<Class<? extends Decoder>> decoders = new ArrayList<Class<? extends Decoder>>(2);
                decoders.add(MsgStringDecoder.class);
                decoders.add(MsgByteDecoder.class);
                return decoders;
            }
            @Override
            public List<String> getSubprotocols() {
                return Collections.emptyList();
            }
            @Override
            public String getPath() {
                return PATH_PROGRAMMATIC_EP;
            }
            @Override
            public List<Extension> getExtensions() {
                return Collections.emptyList();
            }
            @Override
            public Class<?> getEndpointClass() {
                return ProgrammaticEndpoint.class;
            }
            @Override
            public Configurator getConfigurator() {
                return new ServerEndpointConfig.Configurator() {
                };
            }
        });
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

public EncoderEntry(Class<?> clazz,Encoder encoder) {
    this.clazz = clazz;
    this.encoder = encoder;
}

public Encoder getEncoder() {
    return encoder;
}

static Class<?> getEncoderType(Class<? extends Encoder> encoder) {
    return Util.getGenericType(Encoder.class,encoder).getClazz();
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return perEndpointConfig.getEncoders();
}

@Override
public List<Class<? extends Encoder>> getEncoders() {
    return this.encoders;
}

public void setEncoders(List<Class<? extends Encoder>> encoders) {
    this.configBuilder.encoders(encoders);
}

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        System.out.println("WebSocket Client UID:[" + this.uid + "] handshaker connected!");
        handshakeFuture.setSuccess();
        return;
    }

    if (msg instanceof BinaryWebSocketFrame) {
        try {
            Object obj = protobufDecoder.decode(((BinaryWebSocketFrame) msg).content());
            resQueue.add((Response.HeshResMessage)obj);
        } catch (Exception e) {
            e.printstacktrace();
        }
    }

}

@Override
protected void encode(ChannelHandlerContext ctx,Proto proto,List<Object> list) throws Exception {
    ByteBuf byteBuf = ByteBufAllocator.DEFAULT.buffer();
    if (proto.getBody() != null) {
        byteBuf.writeInt(Proto.HEADER_LENGTH + proto.getBody().length);
        byteBuf.writeShort(Proto.HEADER_LENGTH);
        byteBuf.writeShort(Proto.VERSION);
        byteBuf.writeInt(proto.getoperation());
        byteBuf.writeInt(proto.getSeqId());
        byteBuf.writeBytes(proto.getBody());
    } else {
        byteBuf.writeInt(Proto.HEADER_LENGTH);
        byteBuf.writeShort(Proto.HEADER_LENGTH);
        byteBuf.writeShort(Proto.VERSION);
        byteBuf.writeInt(proto.getoperation());
        byteBuf.writeInt(proto.getSeqId());
    }

    list.add(new BinaryWebSocketFrame(byteBuf));

    logger.debug("encode: {}",proto);
}

@Test
public void testVersion() throws Exception {
    try {
        String uuid = UUID.randomUUID().toString();
        VersionRequest request = new VersionRequest();
        request.setRequestId(uuid);
        ch.writeAndFlush(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(JsonSerializer.getobjectMapper()
                .writeValueAsBytes(request))));
        // Confirm receipt of all data sent to this point
        List<byte[]> response = handler.getResponses();
        while (response.size() == 0 && handler.isConnected()) {
            LOG.info("Waiting for web socket response");
            sleepUninterruptibly(500,TimeUnit.MILLISECONDS);
            response = handler.getResponses();
        }
        assertEquals(1,response.size());
        VersionResponse version = JsonSerializer.getobjectMapper()
                .readValue(response.get(0),VersionResponse.class);
        assertEquals(VersionResponse.VERSION,version.getVersion());
        assertEquals(uuid,version.getRequestId());
    } finally {
        ch.close().sync();
        s.shutdown();
        group.shutdownGracefully();
    }
}

@SuppressWarnings({ "unchecked","rawtypes" })
@Override
   protected void encode(ChannelHandlerContext ctx,Packet packet,List out) throws Exception {
       ByteBuf buf = ctx.alloc().buffer().order(ByteOrder.LITTLE_ENDIAN);
       int packetId = PacketRegistry.SERVER2CLIENT.getPacketId(packet.getClass());
       if (packetId == -1) {
           throw new IllegalArgumentException("Provided packet is not registered as a clientbound packet!");
       }

       buf.writeByte(packetId);
       packet.writeData(buf);
       new BinaryWebSocketFrame(buf);
       out.add(new BinaryWebSocketFrame(buf));

       Log.logDebug("Sent packet ID " + packetId + " (" + packet.getClass().getSimpleName() + ") to " + ctx.channel().remoteAddress());
   }

private void handleFrame(Channel channel,WebSocketFrame frame,WebSocketUpgradeHandler handler,NettyWebSocket webSocket) throws Exception {
    if (frame instanceof CloseWebSocketFrame) {
        Channels.setdiscard(channel);
        CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
        webSocket.onClose(closeFrame.statusCode(),closeFrame.reasonText());
    } else {
        ByteBuf buf = frame.content();
        if (buf != null && buf.readableBytes() > 0) {
            HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf,frame.isFinalFragment());
            handler.onBodyPartReceived(part);

            if (frame instanceof BinaryWebSocketFrame) {
                webSocket.onBinaryFragment(part);
            } else if (frame instanceof TextWebSocketFrame) {
                webSocket.onTextFragment(part);
            } else if (frame instanceof PingWebSocketFrame) {
                webSocket.onPing(part);
            } else if (frame instanceof PongWebSocketFrame) {
                webSocket.onPong(part);
            }
        }
    }
}

private Message decodeWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return null;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.content().retain()));
        return null;
    }

    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        return parseMessage(textFrame.content());
    }

    if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) frame;
        return parseMessage(binFrame.content());
    }

    log.warn("Message format error: " + frame); 
    return null;
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // Check for closing frame
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    System.out.println("client channelRead0 "+ctx);
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        System.out.println("WebSocket Client connected!");
        handshakeFuture.setSuccess();
    }

    if(msg instanceof WebSocketFrame){
        WebSocketFrame frame = (WebSocketFrame)msg;
        if(frame instanceof BinaryWebSocketFrame){
            handleWebSocketFrame(ctx,frame);
        }
        return;
    }
    return;
}

@Override
public void channelRead0(ChannelHandlerContext ctx,frame);
        }
        return;
    }
    sendRealTimeMessageTest(ctx);
    return;
}

@Override
protected void channelRead0(ChannelHandlerContext context,Object message) throws Exception {
    final Channel channel = context.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(channel,(FullHttpResponse) message);
        channel.pipeline().addBefore(HANDLER_NAME,"websocket-frame-aggregator",new WebSocketFrameAggregator(64 * 1024));
        subscriber.onStart();
        return;
    }

    if (message instanceof FullHttpResponse) {
        final FullHttpResponse response = (FullHttpResponse) message;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    final WebSocketFrame frame = (WebSocketFrame) message;
    if (frame instanceof PingWebSocketFrame) {
        context.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame)frame).retain().content()));
    } else if (frame instanceof BinaryWebSocketFrame) {
        final ByteBufInputStream input = new ByteBufInputStream(((BinaryWebSocketFrame)message).content());
        final Envelope envelope = Envelope.ADAPTER.decode(input);
        subscriber.onNext(envelope);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format(
                "Channel %s received %s",ctx.channel().hashCode(),StringUtil.simpleClassName(frame)));
    }

    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame);
    } else if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.isFinalFragment(),frame.rsv(),frame.content()),ctx.voidPromise());
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private ReactiveSocketWebSocketClient(WebSocketConnection wsConn) {
    this.reactiveSocket = ReactiveSocket.createRequestor();
    connect = this.reactiveSocket.connect(
            new DuplexConnection() {
                @Override
                public Publisher<Frame> getinput() {
                    return toPublisher(wsConn.getinput().map(frame -> {
                        return Frame.from(frame.content().nioBuffer());
                    }));
                }

                @Override
                public Publisher<Void> addOutput(Publisher<Frame> o) {
                    // had to use writeAndFlushOnEach instead of write for frames to get through
                    // Todo determine if that's expected or not
                    Publisher<Void> p = toPublisher(wsConn.writeAndFlushOnEach(toObservable(o)
                            .map(frame -> new BinaryWebSocketFrame(Unpooled.wrappedBuffer(frame.getByteBuffer())))
                    ));
                    return p;
                }
            });
}

/**
   * Use this method as the RxNetty HttpServer WebSocket handler.
   * 
   * @param ws
   * @return
   */
  public Observable<Void> acceptWebsocket(WebSocketConnection ws) {
    return toObservable(reactiveSocket.connect(new DuplexConnection() {
    @Override
    public Publisher<Frame> getinput() {
        return toPublisher(ws.getinput().map(frame -> {
            // Todo is this copying bytes?
            try {
                return Frame.from(frame.content().nioBuffer());
            } catch (Exception e) {
                e.printstacktrace();
                throw new RuntimeException(e);
            }
        }));
    }

    @Override
    public Publisher<Void> addOutput(Publisher<Frame> o) {
        // had to use writeAndFlushOnEach instead of write for frames to reliably get through
        // Todo determine if that's expected or not
        return toPublisher(ws.writeAndFlushOnEach(toObservable(o).map(frame -> {
            return new BinaryWebSocketFrame(Unpooled.wrappedBuffer(frame.getByteBuffer()));
        })));
    }
}));
  }

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
  Channel ch = ctx.channel();

  if (!handshaker.isHandshakeComplete()) {
    handshaker.finishHandshake(ch,(FullHttpResponse) msg);
    handshakeFuture.setSuccess();
    return;
  }

  if (!(msg instanceof BinaryWebSocketFrame)) {
    ch.close();
    log.warn("Received {},closing",msg);
    return;
  }

  byte[] b = extractBytes(msg);

  ctx.fireChannelRead(b);
}

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg)
        throws UnkNownWebSocketFrameTypeException,ServerConnectorException {
    if (!(msg instanceof WebSocketFrame)) {
        logger.error("Expecting WebSocketFrame. UnkNown type.");
        throw new UnkNownWebSocketFrameTypeException("Expecting WebSocketFrame. UnkNown type.");
    }
    if (msg instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) msg);
    } else if (msg instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) msg);
    } else if (msg instanceof CloseWebSocketFrame) {
        notifyCloseMessage((CloseWebSocketFrame) msg);
    } else if (msg instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) msg);
    } else if (msg instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) msg);
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception {
    if (frame instanceof TextWebSocketFrame) {
        // Echos the same text
        String text = ((TextWebSocketFrame) frame).text();
        if (PING.equals(text)) {
            ctx.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(new byte[]{1,2,3,4})));
            return;
        }
        ctx.channel().writeAndFlush(new TextWebSocketFrame(text));
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.channel().writeAndFlush(frame.retain());
    } else if (frame instanceof CloseWebSocketFrame) {
        ctx.close();
    } else {
        String message = "unsupported frame type: " + frame.getClass().getName();
        throw new UnsupportedOperationException(message);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                .getName()));
    }
}

private void performSend(byte[] raw) throws IOException
{
    if (this.outBuf != null)
    {
        this.outBuf.write(raw);
        raw = this.outBuf.toByteArray();
        this.outBuf = null;
    }
    //char[] encoded = Base64.encode(raw);

    if (this.binary)
    {
        this.ctx.channel().write(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(raw)));
    }
    else
    {
        this.ctx.channel().write(new TextWebSocketFrame(StringUtil.toUtfString(raw)));
    }

}

@Override
public void write(ChannelHandlerContext ctx,Object msg,ChannelPromise promise) throws Exception {
    LOG.trace("NettyServerHandler: Channel write: {}",msg);
    if (isWebSocketServer() && msg instanceof ByteBuf) {
        if(isFragmentWrites()) {
            ByteBuf orig = (ByteBuf) msg;
            int origIndex = orig.readerIndex();
            int split = orig.readableBytes()/2;

            ByteBuf part1 = orig.copy(origIndex,split);
            LOG.trace("NettyServerHandler: Part1: {}",part1);
            orig.readerIndex(origIndex + split);
            LOG.trace("NettyServerHandler: Part2: {}",orig);

            BinaryWebSocketFrame frame1 = new BinaryWebSocketFrame(false,part1);
            ctx.writeAndFlush(frame1);
            ContinuationWebSocketFrame frame2 = new ContinuationWebSocketFrame(true,orig);
            ctx.write(frame2,promise);
        } else {
            BinaryWebSocketFrame frame = new BinaryWebSocketFrame((ByteBuf) msg);
            ctx.write(frame,promise);
        }
    } else {
        ctx.write(msg,promise);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.content()));
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
  // Check for closing frame
  if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
  }
  if (frame instanceof PingWebSocketFrame) {
    ctx.write(new PongWebSocketFrame(frame.content().retain()));
    return;
  }
  if (frame instanceof TextWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
    return;
  }
  if (frame instanceof BinaryWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
  }
}

public void handle(final Object msg) {
  ready();
  if (msg instanceof TextWebSocketFrame) {
    onTextCallback.accept(((TextWebSocketFrame) msg).text());
  } else if (msg instanceof BinaryWebSocketFrame) {
    onBinaryCallback.accept(((BinaryWebSocketFrame) msg).content().nioBuffer());
  } else if (msg instanceof CloseWebSocketFrame) {
    CloseWebSocketFrame closeFrame = ((CloseWebSocketFrame) msg).retain();
    int statusCode = closeFrame.statusCode();
    onCloseCallback.accept(statusCode == -1 ? WebSocket.norMAL.code() : statusCode,Optional.ofNullable(closeFrame.reasonText()));
    handshaker.close(ctx.channel(),closeFrame).addListener(CLOSE);
  } else if (msg instanceof Throwable) {
    onErrorCallback.accept((Throwable) msg);
  }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof BinaryWebSocketFrame)
        try {
            this.connection.onMessage(((BinaryWebSocketFrame) frame).content().retain());
        } catch (Exception e) {
            logger.error("onMessage error",e);
            handshaker.close(ctx.channel(),new CloseWebSocketFrame(true,frame.content().clear()
                                    .writeShort(1000)
                                    .writeBytes(e.getMessage().getBytes(CharsetUtil.UTF_8))
                                    .retain()));
        }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame msg) throws Exception {
  if (log.isDebugEnabled())
    log.debug("Received {} WebSocketFrame: {} from channel: {}",getTransportType().getName(),msg,ctx.channel());

  if (msg instanceof CloseWebSocketFrame) {
    sessionIdByChannel.remove(ctx.channel());
    ChannelFuture f = ctx.writeAndFlush(msg);
    f.addListener(ChannelFutureListener.CLOSE);
  } else if (msg instanceof PingWebSocketFrame) {
    ctx.writeAndFlush(new PongWebSocketFrame(msg.content()));
  } else if (msg instanceof TextWebSocketFrame || msg instanceof BinaryWebSocketFrame){
    Packet packet = PacketDecoder.decodePacket(msg.content());
    packet.setTransportType(getTransportType());
    String sessionId = sessionIdByChannel.get(ctx.channel());
    packet.setSessionId(sessionId);
    msg.release();
    ctx.fireChannelRead(packet);
  } else {
    msg.release();
    log.warn("{} frame type is not supported",msg.getClass().getName());
  }
}

@Override
protected void decode(final ChannelHandlerContext ctx,final WebSocketFrame msg,final List<Object> out)
    throws Exception {
    if (msg instanceof BinaryWebSocketFrame) {
        ByteBuf content = msg.content();
        // the content is passed to other handlers so they need to be retained.
        content.retain();
        fragments.add(content);
        if (msg.isFinalFragment()) {
            if (fragments.size() == 1) {
                out.add(fragments.get(0));
            } else {
                ByteBuf[] array = fragments.toArray(BYTE_BUF_TYPE);
                out.add(Unpooled.wrappedBuffer(array));
            }
            fragments.clear();
        }
    } else if (msg instanceof TextWebSocketFrame) {
        LOG.warn("Recieved a Websocket text frame. This was not expected. Ignoring it.");
    }
}

/**
 * 向当前客户端发送数据
 * @param message
 */
public void send(Message message) {
    byte[] bytes = message.toByteArray();

    ByteBuf b = Unpooled.buffer(bytes.length);
    b.writeBytes(bytes);

    WebSocketFrame frame = new BinaryWebSocketFrame(b);

    channel.writeAndFlush(frame);
}

public ChannelFuture write(Communication.HeshReqMessage message) {
    byte[] bytes = message.toByteArray();

    ByteBuf b = Unpooled.buffer(bytes.length);
    b.writeBytes(bytes);

    WebSocketFrame frame = new BinaryWebSocketFrame(b);
    return channel.writeAndFlush(frame);
}

@Override
protected void decode(ChannelHandlerContext ctx,BinaryWebSocketFrame wsFrame,List<Object> out) throws Exception {
    ByteBuf buf = wsFrame.content();

    this.messageNewDecoder.decode(ctx,buf,out);
}

@Override
protected void encode(ChannelHandlerContext ctx,Message msg,List<Object> out) throws Exception {
    if (msg == null || !(msg instanceof Message))
        return;

    byte[] data = ((Message) msg).toBytes();

    out.add(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(data)));
}

/**
 * 将webSocket消息转换为bytebuf类型,以适配后面的解码器
 */
@Override
protected void decode(ChannelHandlerContext paramChannelHandlerContext,WebSocketFrame paramINBOUND_IN,List<Object> paramList)
        throws Exception {
    if(paramINBOUND_IN instanceof BinaryWebSocketFrame)
    {
        BinaryWebSocketFrame msg=(BinaryWebSocketFrame)paramINBOUND_IN;
        ByteBuf data = msg.content();
        paramList.add(data);
        data.retain();
    }
}

/**
 * 对于业务层直接发送的bytebuf实例将其转换为websocket消息
 */
@Override
protected void encode(ChannelHandlerContext paramChannelHandlerContext,ByteBuf paramOUTBOUND_IN,List<Object> paramList) throws Exception {
    paramList.add(new BinaryWebSocketFrame(paramOUTBOUND_IN));
    paramOUTBOUND_IN.retain();
}

@Override
public void run() {
    try {
        VersionResponse response = new VersionResponse();
        response.setRequestId(this.request.getRequestId());
        ctx.writeAndFlush(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(om.writeValueAsBytes(response))));
    } catch (JsonProcessingException e) {
        LOG.error("Error serializing version response",e);
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    LOG.info("Received msg: {}",msg);
    if (!this.handshaker.isHandshakeComplete()) {
        this.handshaker.finishHandshake(ctx.channel(),(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text().getBytes(StandardCharsets.UTF_8));
        }
    } else if (frame instanceof BinaryWebSocketFrame) {
        ByteBuf buf = frame.content();
        byte[] b = new byte[buf.readableBytes()];
        buf.readBytes(b);
        synchronized (responses) {
            responses.add(b);
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

@Override
public void channelRead0(final ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception {
    webSocketServerThread.log(Level.FInesT,"channel read,frame="+frame);
    // Todo: log at INFO level if this the first data we received from a client (new first connection),to
    // help detect clients connecting but not sending authentication commands (in newPlayer)

    if (this.checkIPBans) {
        String ip = webSocketServerThread.getRemoteIP(ctx.channel());
        if (this.ipBans.contains(ip)) {
            webSocketServerThread.sendLine(ctx.channel(),"T,Banned from server"); // Todo: show reason,getBanList
            return;
        }
    }

    if (frame instanceof BinaryWebSocketFrame) {
        ByteBuf content = frame.content();

        byte[] bytes = new byte[content.capacity()];
        content.getBytes(0,bytes);

        final String string = new String(bytes);
        webSocketServerThread.log(Level.FInesT,"received "+content.capacity()+" bytes: "+string);

        this.webSocketServerThread.scheduleSyncTask(new Runnable() {
            @Override
            public void run() {
                webSocketServerThread.handle(string,ctx);
            }
        });
    } else {
        String message = "unsupported frame type: " + frame.getClass().getName();
        throw new UnsupportedOperationException(message);
    }
}

public void broadcastLineExcept(ChannelId excludeChannelId,String message) {
    for (Channel channel: allUsersGroup) {
        if (channel.id().equals(excludeChannelId)) {
            continue;
        }

        channel.writeAndFlush(new BinaryWebSocketFrame(Unpooled.copiedBuffer((message + "\n").getBytes())));
    }
}

@SuppressWarnings({ "unchecked","rawtypes" })
@Override
protected void encode(ChannelHandlerContext ctx,List out) throws Exception {
    ByteBuf buf = ctx.alloc().buffer().order(ByteOrder.LITTLE_ENDIAN);
    int packetId = reg.CLIENTBOUND.getPacketId(packet.getClass());
    if (packetId == -1) {
        throw new IllegalArgumentException("Provided packet is not registered as a clientbound packet!");
    }

    buf.writeByte(packetId);
    packet.writeData(buf);
    out.add(new BinaryWebSocketFrame(buf));

    Server.log.finest("Sent packet ID " + packetId + " (" + packet.getClass().getSimpleName() + ") to " + ctx.channel().remoteAddress());
}

@Override
protected void decode(ChannelHandlerContext chc,BinaryWebSocketFrame frame,List<Object> out) throws Exception
{
    //convert the frame to a ByteBuf
    ByteBuf bb = frame.content();
    bb.retain();
    out.add(bb);
}

@Override
protected void encode(ChannelHandlerContext chc,ByteBuf bb,List<Object> out) throws Exception
{
    //convert the ByteBuf to a WebSocketFrame
    BinaryWebSocketFrame result = new BinaryWebSocketFrame();
    result.content().writeBytes(bb);
    out.add(result);
}

@SuppressWarnings({ "deprecation","unchecked",List out) throws Exception {
       ByteBuf buf = ctx.alloc().buffer().order(ByteOrder.BIG_ENDIAN);
       int packetId = PacketRegistry.CLIENTBOUND.getPacketId(packet.getClass());
       if (packetId == -1) {
           throw new IllegalArgumentException("Provided packet is not registered as a clientbound packet!");
       }

       buf.writeByte(packetId);
       packet.writeData(buf);
       out.add(new BinaryWebSocketFrame(buf));

       ClitherServer.log.finest("Sent packet " + " (" + packet.getClass().getSimpleName() + ") to " + ctx.channel().remoteAddress());
   }

@Override
public void channelRead0(ChannelHandlerContext context,Object message) throws Exception {
  Channel channel = context.channel();
  if (message instanceof FullHttpResponse) {
    checkState(!handshaker.isHandshakeComplete());
    try {
      handshaker.finishHandshake(channel,(FullHttpResponse) message);
      delegate.onopen();
    } catch (WebSocketHandshakeException e) {
      delegate.onError(e);
    }
  } else if (message instanceof TextWebSocketFrame) {
    delegate.onMessage(((TextWebSocketFrame) message).text());
  } else {
    checkState(message instanceof CloseWebSocketFrame);
    delegate.onClose();
  }
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        socketServerHandshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(
                new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 本例程仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format(
                "%s frame types not supported",frame.getClass().getName()));
    }
    // 返回应答消息
    String request = ((TextWebSocketFrame) frame).text();
    System.out.println("服务端收到：" + request);
    TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
            + ctx.channel().id() + "：" + request);
    // 群发
    group.writeAndFlush(tws);
}

@Test
public void testCreateSubscriptionWithMissingSessionId() throws Exception {
    decoder = new WebSocketRequestDecoder(config);
    // @formatter:off
    String request = "{ "+ 
      "\"operation\" : \"create\"," +
      "\"subscriptionId\" : \"1234\"" + 
    " }";
    // @formatter:on
    TextWebSocketFrame frame = new TextWebSocketFrame();
    frame.content().writeBytes(request.getBytes(StandardCharsets.UTF_8));
    decoder.decode(ctx,frame,results);
    Assert.assertNotNull(ctx.msg);
    Assert.assertEquals(CloseWebSocketFrame.class,ctx.msg.getClass());
    Assert.assertEquals(1008,((CloseWebSocketFrame) ctx.msg).statusCode());
    Assert.assertEquals("User must log in",((CloseWebSocketFrame) ctx.msg).reasonText());
}

@Test
public void testCreateSubscriptionWithInvalidSessionIdAndNonAnonymousAccess() throws Exception {
    ctx.channel().attr(SubscriptionRegistry.SESSION_ID_ATTR)
            .set(URLEncoder.encode(UUID.randomUUID().toString(),StandardCharsets.UTF_8.name()));
    decoder = new WebSocketRequestDecoder(config);
    // @formatter:off
    String request = "{ "+ 
      "\"operation\" : \"create\",((CloseWebSocketFrame) ctx.msg).reasonText());
}

private void handleFrame(Channel channel,WebSocketFrame frame,WebSocketUpgradeHandler handler,NettyWebSocket webSocket) throws Exception {
    if (frame instanceof CloseWebSocketFrame) {
        Channels.setdiscard(channel);
        CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
        webSocket.onClose(closeFrame.statusCode(),closeFrame.reasonText());
    } else {
        ByteBuf buf = frame.content();
        if (buf != null && buf.readableBytes() > 0) {
            HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf,frame.isFinalFragment());
            handler.onBodyPartReceived(part);

            if (frame instanceof BinaryWebSocketFrame) {
                webSocket.onBinaryFragment(part);
            } else if (frame instanceof TextWebSocketFrame) {
                webSocket.onTextFragment(part);
            } else if (frame instanceof PingWebSocketFrame) {
                webSocket.onPing(part);
            } else if (frame instanceof PongWebSocketFrame) {
                webSocket.onPong(part);
            }
        }
    }
}

@Override
public void onInboundNext(ChannelHandlerContext ctx,Object frame) {
    if (frame instanceof CloseWebSocketFrame && ((CloseWebSocketFrame) frame).isFinalFragment()) {
        if (log.isDebugEnabled()) {
            log.debug("CloseWebSocketFrame detected. Closing Websocket");
        }
        CloseWebSocketFrame close = (CloseWebSocketFrame) frame;
        sendClose(new CloseWebSocketFrame(true,close.rsv(),close.content()),f -> onHandlerTerminate());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame) frame).content()));
        ctx.read();
        return;
    }
    super.onInboundNext(ctx,frame);
}

private Message decodeWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return null;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.content().retain()));
        return null;
    }

    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        return parseMessage(textFrame.content());
    }

    if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) frame;
        return parseMessage(binFrame.content());
    }

    log.warn("Message format error: " + frame); 
    return null;
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // Check for closing frame
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        addTraceForFrame(frame,"close");
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        addTraceForFrame(frame,"ping");
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
            .getName()));
    }

    // todo [om] think about BinaryWebsocketFrame

    handleTextWebSocketFrameInternal((TextWebSocketFrame) frame,ctx);
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        System.err.printf("%s received %s%n",ctx.channel(),request);
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format(
                "Channel %s received %s",ctx.channel().hashCode(),StringUtil.simpleClassName(frame)));
    }

    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame);
    } else if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.isFinalFragment(),frame.rsv(),frame.content()),ctx.voidPromise());
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

@Override
public void accept(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        endpoint.releaseReferences();
        endpoint.onClose();
        return;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof TextWebSocketFrame) {
        endpoint.onMessage(((TextWebSocketFrame) frame).text());
        return;
    }

    throw new UnsupportedOperationException(String.format("Unsupported websocket frame of type %s",frame.getClass().getName()));
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        ctx.close();//(String.format("%s frame types not supported",frame.getClass().getName()));
        return;
    }

}

public void handle(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame);
        onClose(ctx);
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String msg = ((TextWebSocketFrame) frame).text();
    onMessage(ctx,msg);
}

public void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // 判断是否是关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }

        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
        }
        //返回应答消息
        String request= ((TextWebSocketFrame)frame).text();
        System.out.println(String.format("%s received %s",request));

        ctx.channel().write(new TextWebSocketFrame(request+",现在时刻："+new Date()));

    }

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
  Channel channel = ctx.channel();
  if (!handshaker.isHandshakeComplete()) {
    handshaker.finishHandshake(channel,(FullHttpResponse) msg);
    handshakeFuture.setSuccess();
    eventBus.post(new Connected());
    return;
  }

  if (msg instanceof FullHttpResponse) {
    FullHttpResponse response = (FullHttpResponse) msg;
    throw new IllegalStateException(
        "Unexpected FullHttpResponse (getStatus=" + response.status() +
            ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
  }

  WebSocketFrame frame = (WebSocketFrame) msg;
  if (frame instanceof TextWebSocketFrame) {
    TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
    eventBus.post(new Response(textFrame.text()));
  } else if (frame instanceof CloseWebSocketFrame) {
    channel.close();
    eventBus.post(new disconnected());
  }
}

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg)
        throws UnkNownWebSocketFrameTypeException,ServerConnectorException {
    if (!(msg instanceof WebSocketFrame)) {
        logger.error("Expecting WebSocketFrame. UnkNown type.");
        throw new UnkNownWebSocketFrameTypeException("Expecting WebSocketFrame. UnkNown type.");
    }
    if (msg instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) msg);
    } else if (msg instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) msg);
    } else if (msg instanceof CloseWebSocketFrame) {
        notifyCloseMessage((CloseWebSocketFrame) msg);
    } else if (msg instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) msg);
    } else if (msg instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) msg);
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception {
    if (frame instanceof TextWebSocketFrame) {
        // Echos the same text
        String text = ((TextWebSocketFrame) frame).text();
        if (PING.equals(text)) {
            ctx.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(new byte[]{1,2,3,4})));
            return;
        }
        ctx.channel().writeAndFlush(new TextWebSocketFrame(text));
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.channel().writeAndFlush(frame.retain());
    } else if (frame instanceof CloseWebSocketFrame) {
        ctx.close();
    } else {
        String message = "unsupported frame type: " + frame.getClass().getName();
        throw new UnsupportedOperationException(message);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("%s received %s",request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception
{
    this.last = ctx;
    if (frame instanceof CloseWebSocketFrame)
    {
        this.log.debug("recevied close frame");
        this.server.unsubscribe(this);
        this.handshaker.close(ctx.channel(),(CloseWebSocketFrame)frame);
    }
    else if (frame instanceof PingWebSocketFrame)
    {
        this.log.debug("recevied ping frame");
        ctx.write(new PongWebSocketFrame(frame.content()));
    }
    else if (frame instanceof TextWebSocketFrame)
    {
        this.log.debug("recevied text frame");
        this.handleTextWebSocketFrame(ctx,(TextWebSocketFrame)frame);
    }
    else
    {
        this.log.info("recevied unkNown incompatible frame");
        ctx.close();
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    _logger.debug("Handling websocket frame");
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        _handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String request = ((TextWebSocketFrame) frame).text();
    _logger.debug("{} received {}",request);
    _messageQueue.add(frame.content().retain());
    //ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.content()));
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
  // Check for closing frame
  if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
  }
  if (frame instanceof PingWebSocketFrame) {
    ctx.write(new PongWebSocketFrame(frame.content().retain()));
    return;
  }
  if (frame instanceof TextWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
    return;
  }
  if (frame instanceof BinaryWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
  }
}

public void handle(final Object msg) {
  ready();
  if (msg instanceof TextWebSocketFrame) {
    onTextCallback.accept(((TextWebSocketFrame) msg).text());
  } else if (msg instanceof BinaryWebSocketFrame) {
    onBinaryCallback.accept(((BinaryWebSocketFrame) msg).content().nioBuffer());
  } else if (msg instanceof CloseWebSocketFrame) {
    CloseWebSocketFrame closeFrame = ((CloseWebSocketFrame) msg).retain();
    int statusCode = closeFrame.statusCode();
    onCloseCallback.accept(statusCode == -1 ? WebSocket.norMAL.code() : statusCode,Optional.ofNullable(closeFrame.reasonText()));
    handshaker.close(ctx.channel(),closeFrame).addListener(CLOSE);
  } else if (msg instanceof Throwable) {
    onErrorCallback.accept((Throwable) msg);
  }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof BinaryWebSocketFrame)
        try {
            this.connection.onMessage(((BinaryWebSocketFrame) frame).content().retain());
        } catch (Exception e) {
            logger.error("onMessage error",e);
            handshaker.close(ctx.channel(),new CloseWebSocketFrame(true,frame.content().clear()
                                    .writeShort(1000)
                                    .writeBytes(e.getMessage().getBytes(CharsetUtil.UTF_8))
                                    .retain()));
        }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame msg) throws Exception {
  if (log.isDebugEnabled())
    log.debug("Received {} WebSocketFrame: {} from channel: {}",getTransportType().getName(),msg,ctx.channel());

  if (msg instanceof CloseWebSocketFrame) {
    sessionIdByChannel.remove(ctx.channel());
    ChannelFuture f = ctx.writeAndFlush(msg);
    f.addListener(ChannelFutureListener.CLOSE);
  } else if (msg instanceof PingWebSocketFrame) {
    ctx.writeAndFlush(new PongWebSocketFrame(msg.content()));
  } else if (msg instanceof TextWebSocketFrame || msg instanceof BinaryWebSocketFrame){
    Packet packet = PacketDecoder.decodePacket(msg.content());
    packet.setTransportType(getTransportType());
    String sessionId = sessionIdByChannel.get(ctx.channel());
    packet.setSessionId(sessionId);
    msg.release();
    ctx.fireChannelRead(packet);
  } else {
    msg.release();
    log.warn("{} frame type is not supported",msg.getClass().getName());
  }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    LOG.info("Received msg: {}",msg);
    if (!this.handshaker.isHandshakeComplete()) {
        this.handshaker.finishHandshake(ctx.channel(),(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text().getBytes(StandardCharsets.UTF_8));
        }
    } else if (frame instanceof BinaryWebSocketFrame) {
        ByteBuf buf = frame.content();
        byte[] b = new byte[buf.readableBytes()];
        buf.readBytes(b);
        synchronized (responses) {
            responses.add(b);
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg)
        throws Exception {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        System.out.println("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                    ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    } else if (msg instanceof WebSocketFrame) {
        WebSocketFrame frame = (WebSocketFrame) msg;
        if (msg instanceof TextWebSocketFrame) {
            TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
            System.out.println("WebSocket Client received message: " + textFrame.text());
        } else if (msg instanceof PongWebSocketFrame) {
            System.out.println("WebSocket Client received pong");
        } else if (msg instanceof CloseWebSocketFrame) {
            System.out.println("WebSocket Client received closing");
            ch.close();
        }
    }
}

/**
 * disconnect from the AudioConnect server and reset.<br>
 * If a connection is not established or being established,this will do nothing.
 * @return a Future for when the connection has been fully disconnected and closed
 */
public Future<?> disconnect() {
    Connection connection;
    synchronized (connectionLock) {
        connection = this.connection;
        this.connection = null;
    }

    if (connection != null) {
        playerScheduler.clear();
        connection.playerConnections.clear();

        // Remove channelCloseListener to not reconnect
        connection.channel.closeFuture().removeListener(channelCloseListener);

        if (connection.channel.isActive()) {
            final Promise<Object> disconnectPromise = bootstrap.group().next().newPromise();

            Object closeFrame = new CloseWebSocketFrame(WEBSOCKET_CLOSE_CODE_GOING_AWAY,"Going offline");
            connection.channel.writeAndFlush(closeFrame).addListener(new ChannelFutureListener() {

                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    future.channel().close().addListener(new PromiseNotifier<>(disconnectPromise));
                }
            });
            return disconnectPromise;
        }
    }
    return bootstrap.group().next().newSucceededFuture(null);
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,AddSubscription add) throws Exception {
    Subscription s = SubscriptionRegistry.get().get(add.getSubscriptionId());
    if (null != s) {
        String metric = add.getMetric();
        if (null == metric) {
            LOG.error("Metric name cannot be null in add subscription");
            ctx.writeAndFlush(new CloseWebSocketFrame(1008,"Metric name cannot be null in add subscription"));
        }
        Map<String,String> tags = null;
        Long startTime = 0L;
        Long endTime = 0L;
        Long delayTime = 5000L;
        if (add.getTags().isPresent()) {
            tags = add.getTags().get();
        }
        if (add.getStartTime().isPresent()) {
            startTime = add.getStartTime().get();
        }
        if (add.getEndTime().isPresent()) {
            endTime = add.getEndTime().get();
        }
        if (add.getDelayTime().isPresent()) {
            delayTime = add.getDelayTime().get();
        }
        s.addMetric(metric,tags,startTime,endTime,delayTime);
    } else {
        LOG.error("UnkNown subscription id,create subscription first");
        ctx.writeAndFlush(new CloseWebSocketFrame(1003,"UnkNown subscription id,create subscription first"));
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,CloseSubscription close) throws Exception {
    Subscription s = SubscriptionRegistry.get().remove(close.getSubscriptionId());
    if (null != s) {
        s.close();
    }
    ctx.writeAndFlush(new CloseWebSocketFrame(1000,"Client requested close."));
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,QueryRequest msg) throws Exception {
    try {
        String response = JsonUtil.getobjectMapper().writeValueAsstring(dataStore.query(msg));
        ctx.writeAndFlush(new TextWebSocketFrame(response));
    } catch (TimelyException e) {
        if (e.getMessage().contains("No matching tags")) {
            LOG.trace(e.getMessage());
        } else {
            LOG.error(e.getMessage(),e);
        }
        ctx.writeAndFlush(new CloseWebSocketFrame(1008,e.getMessage()));
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,SuggestRequest msg) throws Exception {
    try {
        String response = JsonUtil.getobjectMapper().writeValueAsstring(dataStore.suggest(msg));
        ctx.writeAndFlush(new TextWebSocketFrame(response));
    } catch (TimelyException e) {
        LOG.error(e.getMessage(),e);
        ctx.writeAndFlush(new CloseWebSocketFrame(1008,e.getMessage()));
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,SearchLookupRequest msg) throws Exception {
    try {
        String response = JsonUtil.getobjectMapper().writeValueAsstring(dataStore.lookup(msg));
        ctx.writeAndFlush(new TextWebSocketFrame(response));
    } catch (TimelyException e) {
        LOG.error(e.getMessage(),e.getMessage()));
    }
}

@Test
public void testCreateSubscriptionWithoutSubscriptionId() throws Exception {
    decoder = new WebSocketRequestDecoder(anonConfig);
    String request = "{ \"operation\" : \"create\" }";
    TextWebSocketFrame frame = new TextWebSocketFrame();
    frame.content().writeBytes(request.getBytes(StandardCharsets.UTF_8));
    decoder.decode(ctx,((CloseWebSocketFrame) ctx.msg).statusCode());
    Assert.assertEquals("Subscription ID is required.",((CloseWebSocketFrame) ctx.msg).reasonText());
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format(
                "Channel %s received %s",ctx.channel().hashCode(),StringUtil.simpleClassName(frame)));
    }

    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame);
    } else if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.isFinalFragment(),frame.rsv(),frame.content()),ctx.voidPromise());
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                .getName()));
    }
}

@Override
public void write(ChannelHandlerContext ctx,Object msg,ChannelPromise promise) throws Exception {
    LOG.trace("NettyServerHandler: Channel write: {}",msg);
    if (isWebSocketServer() && msg instanceof ByteBuf) {
        if(isFragmentWrites()) {
            ByteBuf orig = (ByteBuf) msg;
            int origIndex = orig.readerIndex();
            int split = orig.readableBytes()/2;

            ByteBuf part1 = orig.copy(origIndex,split);
            LOG.trace("NettyServerHandler: Part1: {}",part1);
            orig.readerIndex(origIndex + split);
            LOG.trace("NettyServerHandler: Part2: {}",orig);

            BinaryWebSocketFrame frame1 = new BinaryWebSocketFrame(false,part1);
            ctx.writeAndFlush(frame1);
            ContinuationWebSocketFrame frame2 = new ContinuationWebSocketFrame(true,orig);
            ctx.write(frame2,promise);
        } else {
            BinaryWebSocketFrame frame = new BinaryWebSocketFrame((ByteBuf) msg);
            ctx.write(frame,promise);
        }
    } else {
        ctx.write(msg,promise);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.content()));
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

protected void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
   logger.debug("Received incoming frame [{}]",frame.getClass().getName());
   // Check for closing frame
   if (frame instanceof CloseWebSocketFrame) {
      if (frameBuffer != null) {
          handleMessageCompleted(ctx,frameBuffer.toString());
      }
      handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
      return;
   }

   if (frame instanceof PingWebSocketFrame) {
      ctx.channel().writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
      return;
   }

   if (frame instanceof PongWebSocketFrame) {
      logger.info("Pong frame received");
      return;
   }

   if (frame instanceof TextWebSocketFrame) {
      frameBuffer = new StringBuilder();
      frameBuffer.append(((TextWebSocketFrame)frame).text());
   } else if (frame instanceof ContinuationWebSocketFrame) {
      if (frameBuffer != null) {
         frameBuffer.append(((ContinuationWebSocketFrame)frame).text());
      } else {
         logger.warn("Continuation frame received without initial frame.");
      }
   } else {
      throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
   }

   // Check if Text or Continuation Frame is final fragment and handle if needed.
   if (frame.isFinalFragment()) {
      handleMessageCompleted(ctx,frameBuffer.toString());
      frameBuffer = null;
   }
}

protected void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame)
{
    logger.debug("Received incoming frame [{}]",frame.getClass().getName());
    // Check for closing frame
    if ( frame instanceof CloseWebSocketFrame) {
        if ( frameBuffer != null) {
            handleMessageCompleted( ctx,frameBuffer.toString());
        }
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof PongWebSocketFrame) {
        logger.info("Pong frame received");
        return;
    }

    if (frame instanceof TextWebSocketFrame) {
        frameBuffer = new StringBuilder();
        frameBuffer.append(((TextWebSocketFrame)frame).text());
    }
    else if (frame instanceof ContinuationWebSocketFrame) {
        if (frameBuffer != null) {
            frameBuffer.append(((ContinuationWebSocketFrame)frame).text());
        }
        else {
            logger.warn("Continuation frame received without initial frame.");
        }
    }
    else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
    }

    // Check if Text or Continuation Frame is final fragment and handle if needed.
    if (frame.isFinalFragment()) {
        handleMessageCompleted(ctx,frameBuffer.toString());
        frameBuffer = null;
    }
}

/**
 * Handle web socket frame.
 *
 * @param ctx the ctx
 * @param frame the frame
 */
private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

    try{

        // Check for closing frame
        if (frame instanceof CloseWebSocketFrame) {
            dominoServer.onClose(this.newWrapper(ctx));
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;

        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }


        if(frame instanceof PongWebSocketFrame){
            return;//do nothing.

        }


        if(frame instanceof TextWebSocketFrame){
            String message = ((TextWebSocketFrame) frame).text();
            textBuffer.append(message);
        }else if(frame instanceof ContinuationWebSocketFrame){
            textBuffer.append(((ContinuationWebSocketFrame) frame).text());
        }


        if(frame.isFinalFragment()){
            dominoServer.onMessage(this.newWrapper(ctx),textBuffer.toString());
            textBuffer = new StringBuilder();
        }


    }catch(Exception e){
        e.printstacktrace();
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object message) throws Exception {
   LOG.trace("New data read: incoming: {}",message);

   Channel ch = ctx.channel();
   if (!handshaker.isHandshakeComplete()) {
      handshaker.finishHandshake(ch,(FullHttpResponse) message);
      LOG.trace("WebSocket Client connected! {}",ctx.channel());
      // Now trigger super processing as we are really connected.
      NettyWSTransport.super.handleConnected(ch);
      return;
   }

   // We shouldn't get this since we handle the handshake prevIoUsly.
   if (message instanceof FullHttpResponse) {
      FullHttpResponse response = (FullHttpResponse) message;
      throw new IllegalStateException(
         "Unexpected FullHttpResponse (getStatus=" + response.status() + ",content=" + response.content().toString(StandardCharsets.UTF_8) + ')');
   }

   WebSocketFrame frame = (WebSocketFrame) message;
   if (frame instanceof TextWebSocketFrame) {
      TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
      LOG.warn("WebSocket Client received message: " + textFrame.text());
      ctx.fireExceptionCaught(new IOException("Received invalid frame over WebSocket."));
   } else if (frame instanceof BinaryWebSocketFrame) {
      BinaryWebSocketFrame binaryFrame = (BinaryWebSocketFrame) frame;
      LOG.trace("WebSocket Client received data: {} bytes",binaryFrame.content().readableBytes());
      listener.onData(binaryFrame.content());
   } else if (frame instanceof ContinuationWebSocketFrame) {
      ContinuationWebSocketFrame continuationFrame = (ContinuationWebSocketFrame) frame;
      LOG.trace("WebSocket Client received data continuation: {} bytes",continuationFrame.content().readableBytes());
      listener.onData(continuationFrame.content());
   } else if (frame instanceof PingWebSocketFrame) {
      LOG.trace("WebSocket Client received ping,response with pong");
      ch.write(new PongWebSocketFrame(frame.content()));
   } else if (frame instanceof CloseWebSocketFrame) {
      LOG.trace("WebSocket Client received closing");
      ch.close();
   }
}

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
  Channel ch = ctx.channel();
  if (!handshaker.isHandshakeComplete()) {
    handshaker.finishHandshake(ch,(FullHttpResponse) msg);
    log.debug("{} WebSocket Client connected!",label);
    handshakeFuture.setSuccess();
    return;
  }

  if (msg instanceof FullHttpResponse) {
    FullHttpResponse response = (FullHttpResponse) msg;
    throw new IllegalStateException(
        "Unexpected FullHttpResponse (getStatus=" + response.status() + ",content="
            + response.content().toString(CharsetUtil.UTF_8) + ')');
  }

  WebSocketFrame frame = (WebSocketFrame) msg;
  if (frame instanceof TextWebSocketFrame) {
    TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
    if (textFrame.isFinalFragment()) {
      receivedTextMessage(textFrame.text());
    } else {
      partialText.append(textFrame.text());
    }
  } else if (frame instanceof ContinuationWebSocketFrame) {
    ContinuationWebSocketFrame continuationFrame = (ContinuationWebSocketFrame) frame;
    partialText.append(continuationFrame.text());
    if (continuationFrame.isFinalFragment()) {
      receivedTextMessage(partialText.toString());
      partialText.setLength(0);
    }
  } else if (frame instanceof CloseWebSocketFrame) {
    CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
    log.info("{} Received close frame from server. Will close client! Reason: {}",label,closeFrame.reasonText());
  } else {
    log.warn("{} Received frame of type {}. Will be ignored",frame.getClass().getSimpleName());
  }

}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object message) throws Exception {
    LOG.trace("New data read: incoming: {}",message);

    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) message);
        LOG.trace("WebSocket Client connected! {}",ctx.channel());
        // Now trigger super processing as we are really connected.
        NettyWsTransport.super.handleConnected(ch);
        return;
    }

    // We shouldn't get this since we handle the handshake prevIoUsly.
    if (message instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) message;
        throw new IllegalStateException(
            "Unexpected FullHttpResponse (getStatus=" + response.status() +
            ",content=" + response.content().toString(StandardCharsets.UTF_8) + ')');
    }

    WebSocketFrame frame = (WebSocketFrame) message;
    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        LOG.warn("WebSocket Client received message: " + textFrame.text());
        ctx.fireExceptionCaught(new IOException("Received invalid frame over WebSocket."));
    } else if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binaryFrame = (BinaryWebSocketFrame) frame;
        LOG.trace("WebSocket Client received data: {} bytes",binaryFrame.content().readableBytes());
        listener.onData(binaryFrame.content());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ContinuationWebSocketFrame continuationFrame = (ContinuationWebSocketFrame) frame;
        LOG.trace("WebSocket Client received data continuation: {} bytes",continuationFrame.content().readableBytes());
        listener.onData(continuationFrame.content());
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.trace("WebSocket Client received ping,response with pong");
        ch.write(new PongWebSocketFrame(frame.content()));
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.trace("WebSocket Client received closing");
        ch.close();
    }
}

@Override
protected void messageReceived(ChannelHandlerContext ctx,ContinuationWebSocketFrame msg) throws Exception {

}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        socketServerHandshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(
                new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 本例程仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format(
                "%s frame types not supported",frame.getClass().getName()));
    }
    // 返回应答消息
    String request = ((TextWebSocketFrame) frame).text();
    System.out.println("服务端收到：" + request);
    TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
            + ctx.channel().id() + "：" + request);
    // 群发
    group.writeAndFlush(tws);
}

public Subscription(String subscriptionId,String sessionId,DataStore store,ChannelHandlerContext ctx,Configuration conf) {
    this.subscriptionId = subscriptionId;
    this.sessionId = sessionId;
    this.store = store;
    this.ctx = ctx;
    this.lag = conf.getWebsocket().getSubscriptionLag();
    this.scannerBatchSize = conf.getWebsocket().getScannerBatchSize();
    this.flushIntervalSeconds = conf.getWebsocket().getFlushIntervalSeconds();
    this.scannerReadAhead = conf.getWebsocket().getScannerReadAhead();
    this.subscriptionBatchSize = conf.getWebsocket().getSubscriptionBatchSize();
    // send a websocket ping at half the timeout interval.
    int rate = conf.getWebsocket().getTimeout() / 2;
    this.ping = this.ctx.executor().scheduleAtFixedrate(() -> {
        LOG.trace("Sending ping on channel {}",ctx.channel());
        ctx.writeAndFlush(new PingWebSocketFrame());
        cleanupCompletedMetrics();
    },rate,TimeUnit.SECONDS);
}

private void handleFrame(Channel channel,WebSocketFrame frame,WebSocketUpgradeHandler handler,NettyWebSocket webSocket) throws Exception {
    if (frame instanceof CloseWebSocketFrame) {
        Channels.setdiscard(channel);
        CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
        webSocket.onClose(closeFrame.statusCode(),closeFrame.reasonText());
    } else {
        ByteBuf buf = frame.content();
        if (buf != null && buf.readableBytes() > 0) {
            HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf,frame.isFinalFragment());
            handler.onBodyPartReceived(part);

            if (frame instanceof BinaryWebSocketFrame) {
                webSocket.onBinaryFragment(part);
            } else if (frame instanceof TextWebSocketFrame) {
                webSocket.onTextFragment(part);
            } else if (frame instanceof PingWebSocketFrame) {
                webSocket.onPing(part);
            } else if (frame instanceof PongWebSocketFrame) {
                webSocket.onPong(part);
            }
        }
    }
}

@Override
public void onInboundNext(ChannelHandlerContext ctx,Object frame) {
    if (frame instanceof CloseWebSocketFrame && ((CloseWebSocketFrame) frame).isFinalFragment()) {
        if (log.isDebugEnabled()) {
            log.debug("CloseWebSocketFrame detected. Closing Websocket");
        }
        CloseWebSocketFrame close = (CloseWebSocketFrame) frame;
        sendClose(new CloseWebSocketFrame(true,close.rsv(),close.content()),f -> onHandlerTerminate());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame) frame).content()));
        ctx.read();
        return;
    }
    super.onInboundNext(ctx,frame);
}

private Message decodeWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return null;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.content().retain()));
        return null;
    }

    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        return parseMessage(textFrame.content());
    }

    if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) frame;
        return parseMessage(binFrame.content());
    }

    log.warn("Message format error: " + frame); 
    return null;
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // Check for closing frame
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        addTraceForFrame(frame,"close");
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        addTraceForFrame(frame,"ping");
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
            .getName()));
    }

    // todo [om] think about BinaryWebsocketFrame

    handleTextWebSocketFrameInternal((TextWebSocketFrame) frame,ctx);
}

@Override
protected void channelRead0(ChannelHandlerContext context,Object message) throws Exception {
    final Channel channel = context.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(channel,(FullHttpResponse) message);
        channel.pipeline().addBefore(HANDLER_NAME,"websocket-frame-aggregator",new WebSocketFrameAggregator(64 * 1024));
        subscriber.onStart();
        return;
    }

    if (message instanceof FullHttpResponse) {
        final FullHttpResponse response = (FullHttpResponse) message;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    final WebSocketFrame frame = (WebSocketFrame) message;
    if (frame instanceof PingWebSocketFrame) {
        context.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame)frame).retain().content()));
    } else if (frame instanceof BinaryWebSocketFrame) {
        final ByteBufInputStream input = new ByteBufInputStream(((BinaryWebSocketFrame)message).content());
        final Envelope envelope = Envelope.ADAPTER.decode(input);
        subscriber.onNext(envelope);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        System.err.printf("%s received %s%n",ctx.channel(),request);
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format(
                "Channel %s received %s",ctx.channel().hashCode(),StringUtil.simpleClassName(frame)));
    }

    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame);
    } else if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.isFinalFragment(),frame.rsv(),frame.content()),ctx.voidPromise());
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

@Override
public void accept(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        endpoint.releaseReferences();
        endpoint.onClose();
        return;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof TextWebSocketFrame) {
        endpoint.onMessage(((TextWebSocketFrame) frame).text());
        return;
    }

    throw new UnsupportedOperationException(String.format("Unsupported websocket frame of type %s",frame.getClass().getName()));
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        ctx.close();//(String.format("%s frame types not supported",frame.getClass().getName()));
        return;
    }

}

public void handle(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame);
        onClose(ctx);
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String msg = ((TextWebSocketFrame) frame).text();
    onMessage(ctx,msg);
}

public void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // 判断是否是关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }

        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
        }
        //返回应答消息
        String request= ((TextWebSocketFrame)frame).text();
        System.out.println(String.format("%s received %s",request));

        ctx.channel().write(new TextWebSocketFrame(request+",现在时刻："+new Date()));

    }

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg)
        throws UnkNownWebSocketFrameTypeException,ServerConnectorException {
    if (!(msg instanceof WebSocketFrame)) {
        logger.error("Expecting WebSocketFrame. UnkNown type.");
        throw new UnkNownWebSocketFrameTypeException("Expecting WebSocketFrame. UnkNown type.");
    }
    if (msg instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) msg);
    } else if (msg instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) msg);
    } else if (msg instanceof CloseWebSocketFrame) {
        notifyCloseMessage((CloseWebSocketFrame) msg);
    } else if (msg instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) msg);
    } else if (msg instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) msg);
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception {
    if (frame instanceof TextWebSocketFrame) {
        // Echos the same text
        String text = ((TextWebSocketFrame) frame).text();
        if (PING.equals(text)) {
            ctx.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(new byte[]{1,2,3,4})));
            return;
        }
        ctx.channel().writeAndFlush(new TextWebSocketFrame(text));
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.channel().writeAndFlush(frame.retain());
    } else if (frame instanceof CloseWebSocketFrame) {
        ctx.close();
    } else {
        String message = "unsupported frame type: " + frame.getClass().getName();
        throw new UnsupportedOperationException(message);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("%s received %s",request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception
{
    this.last = ctx;
    if (frame instanceof CloseWebSocketFrame)
    {
        this.log.debug("recevied close frame");
        this.server.unsubscribe(this);
        this.handshaker.close(ctx.channel(),(CloseWebSocketFrame)frame);
    }
    else if (frame instanceof PingWebSocketFrame)
    {
        this.log.debug("recevied ping frame");
        ctx.write(new PongWebSocketFrame(frame.content()));
    }
    else if (frame instanceof TextWebSocketFrame)
    {
        this.log.debug("recevied text frame");
        this.handleTextWebSocketFrame(ctx,(TextWebSocketFrame)frame);
    }
    else
    {
        this.log.info("recevied unkNown incompatible frame");
        ctx.close();
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    _logger.debug("Handling websocket frame");
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        _handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String request = ((TextWebSocketFrame) frame).text();
    _logger.debug("{} received {}",request);
    _messageQueue.add(frame.content().retain());
    //ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.content()));
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
  // Check for closing frame
  if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
  }
  if (frame instanceof PingWebSocketFrame) {
    ctx.write(new PongWebSocketFrame(frame.content().retain()));
    return;
  }
  if (frame instanceof TextWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
    return;
  }
  if (frame instanceof BinaryWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
  }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof BinaryWebSocketFrame)
        try {
            this.connection.onMessage(((BinaryWebSocketFrame) frame).content().retain());
        } catch (Exception e) {
            logger.error("onMessage error",e);
            handshaker.close(ctx.channel(),new CloseWebSocketFrame(true,frame.content().clear()
                                    .writeShort(1000)
                                    .writeBytes(e.getMessage().getBytes(CharsetUtil.UTF_8))
                                    .retain()));
        }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame msg) throws Exception {
  if (log.isDebugEnabled())
    log.debug("Received {} WebSocketFrame: {} from channel: {}",getTransportType().getName(),msg,ctx.channel());

  if (msg instanceof CloseWebSocketFrame) {
    sessionIdByChannel.remove(ctx.channel());
    ChannelFuture f = ctx.writeAndFlush(msg);
    f.addListener(ChannelFutureListener.CLOSE);
  } else if (msg instanceof PingWebSocketFrame) {
    ctx.writeAndFlush(new PongWebSocketFrame(msg.content()));
  } else if (msg instanceof TextWebSocketFrame || msg instanceof BinaryWebSocketFrame){
    Packet packet = PacketDecoder.decodePacket(msg.content());
    packet.setTransportType(getTransportType());
    String sessionId = sessionIdByChannel.get(ctx.channel());
    packet.setSessionId(sessionId);
    msg.release();
    ctx.fireChannelRead(packet);
  } else {
    msg.release();
    log.warn("{} frame type is not supported",msg.getClass().getName());
  }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    LOG.info("Received msg: {}",msg);
    if (!this.handshaker.isHandshakeComplete()) {
        this.handshaker.finishHandshake(ctx.channel(),(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text().getBytes(StandardCharsets.UTF_8));
        }
    } else if (frame instanceof BinaryWebSocketFrame) {
        ByteBuf buf = frame.content();
        byte[] b = new byte[buf.readableBytes()];
        buf.readBytes(b);
        synchronized (responses) {
            responses.add(b);
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text());
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

/**
 * Send a ping message to the server.
 *
 * @param buf content of the ping message to be sent.
 */
public void sendPing(ByteBuffer buf) throws IOException {
    if (channel == null) {
        logger.error("Channel is null. Cannot send text.");
        throw new IllegalArgumentException("Cannot find the channel to write");
    }
    channel.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(buf)));
}

protected void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
   logger.debug("Received incoming frame [{}]",frame.getClass().getName());
   // Check for closing frame
   if (frame instanceof CloseWebSocketFrame) {
      if (frameBuffer != null) {
          handleMessageCompleted(ctx,frameBuffer.toString());
      }
      handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
      return;
   }

   if (frame instanceof PingWebSocketFrame) {
      ctx.channel().writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
      return;
   }

   if (frame instanceof PongWebSocketFrame) {
      logger.info("Pong frame received");
      return;
   }

   if (frame instanceof TextWebSocketFrame) {
      frameBuffer = new StringBuilder();
      frameBuffer.append(((TextWebSocketFrame)frame).text());
   } else if (frame instanceof ContinuationWebSocketFrame) {
      if (frameBuffer != null) {
         frameBuffer.append(((ContinuationWebSocketFrame)frame).text());
      } else {
         logger.warn("Continuation frame received without initial frame.");
      }
   } else {
      throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
   }

   // Check if Text or Continuation Frame is final fragment and handle if needed.
   if (frame.isFinalFragment()) {
      handleMessageCompleted(ctx,frameBuffer.toString());
      frameBuffer = null;
   }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

// 判断是否是关闭链路的指令
if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
}
// 判断是否是Ping消息
if (frame instanceof PingWebSocketFrame) {
    ctx.channel().write(
        new PongWebSocketFrame(frame.content().retain()));
    return;
}
// 本例程仅支持文本消息，不支持二进制消息
if (!(frame instanceof TextWebSocketFrame)) {
    throw new UnsupportedOperationException(String.format(
        "%s frame types not supported",frame.getClass().getName()));
}

// 返回应答消息
String request = ((TextWebSocketFrame) frame).text();
if (logger.isLoggable(Level.FINE)) {
    logger.fine(String.format("%s received %s",request));
}
ctx.channel().write(
    new TextWebSocketFrame(request
        + ",欢迎使用Netty WebSocket服务，现在时刻："
        + new java.util.Date().toString()));
   }

/**
 * Send a ping message to the server.
 * @param buf content of the ping message to be sent.
 */
public void sendPing(ByteBuffer buf) throws IOException {
    if (channel == null) {
        logger.error("Channel is null. Cannot send text.");
        throw new IllegalArgumentException("Cannot find the channel to write");
    }
    channel.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(buf)));
}

private void notifyPingMessage(PingWebSocketFrame pingWebSocketFrame) throws ServerConnectorException {
    //Control message for WebSocket is Ping Message
    ByteBuf byteBuf = pingWebSocketFrame.content();
    ByteBuffer byteBuffer = byteBuf.nioBuffer();
    WebSocketMessageImpl webSocketControlMessage =
            new WebSocketControlMessageImpl(WebSocketControlSignal.PING,byteBuffer);
    webSocketControlMessage = setupCommonProperties(webSocketControlMessage);
    connectorFuture.notifyWSListener((WebSocketControlMessage) webSocketControlMessage);
}

@Override
public void channelRead0(ChannelHandlerContext ctx,URISyntaxException,ServerConnectorException {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        log.debug("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        channelSession = WebSocketUtil.getSession(ctx,isSecure,requestedUri);
        return;
    }

    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.status() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) frame,ctx);
    } else if (frame instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) frame,ctx);
    } else if (frame instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) frame,ctx);
    } else if (frame instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) frame,ctx);
    } else if (frame instanceof CloseWebSocketFrame) {
        if (channelSession != null) {
            channelSession.setIsOpen(false);
        }
        notifyCloseMessage((CloseWebSocketFrame) frame,ctx);
        ch.close();
    } else {
        throw new UnkNownWebSocketFrameTypeException("Cannot identify the WebSocket frame type");
    }
}

private void notifyPingMessage(PingWebSocketFrame pingWebSocketFrame,ChannelHandlerContext ctx)
        throws ServerConnectorException {
    //Control message for WebSocket is Ping Message
    ByteBuf byteBuf = pingWebSocketFrame.content();
    ByteBuffer byteBuffer = byteBuf.nioBuffer();
    WebSocketMessageImpl webSocketControlMessage =
            new WebSocketControlMessageImpl(WebSocketControlSignal.PING,byteBuffer);
    webSocketControlMessage = setupCommonProperties(webSocketControlMessage,ctx);
    connectorListener.onMessage((WebSocketControlMessage) webSocketControlMessage);
}

/**
 * Send a ping message to the server.
 * @param buf content of the ping message to be sent.
 */
public void sendPing(ByteBuffer buf) throws IOException {
    if (channel == null) {
        logger.error("Channel is null. Cannot send text.");
        throw new IllegalArgumentException("Cannot find the channel to write");
    }
    channel.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(buf)));
}

private boolean handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

      // Check for closing frame
      if (frame instanceof CloseWebSocketFrame) {
         this.handshaker.close(ctx.channel(),((CloseWebSocketFrame) frame).retain());
         return false;
      } else if (frame instanceof PingWebSocketFrame) {
         ctx.writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
         return false;
      } else if (!(frame instanceof TextWebSocketFrame) && !(frame instanceof BinaryWebSocketFrame)) {
         throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
      }
      return true;
   }

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        TextWebSocketFrame frame2 = (TextWebSocketFrame) frame;

        String request = frame2.text();


        Thread t = Thread.currentThread();
        System.err.printf("%s received %s%n thread %d ",request,t.getId());        



        ///////////////////
        //Do your work here
        ///////////////////


        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));

    }

private void connect() throws Exception {
    while (sessionServer != null && !sessionServer.isopen()) {
        break;
    }
    SSLContext context = createSSLContext();
    SecureSocketClient endpoint = new SecureSocketClient();

    Configurator configurator = new Configurator() {

        @Override
        public void beforeRequest(Map<String,List<String>> headers) {
            headers.put(SEC_WEB_SOCKET_PROTOCOL_STRING,singletonList("configured-proto"));
        }

    };
    ClientEndpointConfig clientEndpointConfig = create().configurator(configurator)
            .preferredSubprotocols(asList(new String[] { "foo","bar","configured-proto" })).build();
    clientEndpointConfig.getUserProperties().put(SSL_CONTEXT,context);

    final WebSocketContainer serverContainer = getWebSocketContainer();
    URI uri = new URI("wss://127.0.0.1:8443/secure-test/session");
    serverContainer.connectToServer(endpoint,clientEndpointConfig,uri);
    awake();
}

public WebsocketClient(String uri,final String sessionID,MessageHandler.Whole<String> messageHandler)
    throws IOException {

// add session ID so the request gets through LAMS security
Builder configBuilder = ClientEndpointConfig.Builder.create();
configBuilder.configurator(new Configurator() {
    @Override
    public void beforeRequest(Map<String,List<String>> headers) {
    headers.put("Cookie",Arrays.asList("JSESSIONID=" + sessionID));
    }
});
ClientEndpointConfig clientConfig = configBuilder.build();
this.websocketEndpoint = new WebsocketEndpoint(messageHandler);
WebSocketContainer container = ContainerProvider.getWebSocketContainer();
try {
    container.connectToServer(websocketEndpoint,clientConfig,new URI(uri));
} catch (DeploymentException | URISyntaxException e) {
    throw new IOException("Error while connecting to websocket server",e);
}
   }

public void setConfigurator(Configurator configurator) {
    this.configBuilder.configurator(configurator);
}

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mGLSurfaceView = new GLSurfaceView(this);

        // Check if the system support OpenGL ES 2.0
        final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

        if (supportsEs2) {
            // Request an OpenGL ES 2.0 compatible context.
            mGLSurfaceView.setEGLContextClientVersion(2);

            // Set the renderer to out demo renderer,define below
//            mGLSurfaceView.setRenderer(new LessonThreeRenderer());
            mGLSurfaceView.setRenderer(new NativeThreeRenderer());
        } else {
            // This is where you Could create an OpenGL ES 1.x compatible
            // renderer if you wanted to support both ES 1 and ES 2
            return;
        }
        setContentView(mGLSurfaceView);
    }

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mGLSurfaceView = new LessonFiveGLSurfaceView(this);

        // Check if the system support OpenGL ES 2.0
        final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

        if (supportsEs2) {
            // Request an OpenGL ES 2.0 compatible context.
            mGLSurfaceView.setEGLContextClientVersion(2);

            // Set the renderer to out demo renderer,define below
//            mGLSurfaceView.setRenderer(new LessonFiveRenderer(this));
            mGLSurfaceView.setRenderer(new NativeFiveRenderer(this));
        } else {
            // This is where you Could create an OpenGL ES 1.x compatible
            // renderer if you wanted to support both ES 1 and ES 2
            return;
        }
        setContentView(mGLSurfaceView);
    }

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mGLSurfaceView = new GLSurfaceView(this);

        // Check if the system support OpenGL ES 2.0
        final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

        if (supportsEs2) {
            // Request an OpenGL ES 2.0 compatible context.
            mGLSurfaceView.setEGLContextClientVersion(2);

            // Set the renderer to out demo renderer,define below
//            mGLSurfaceView.setRenderer(new LessonTwoRenderer());
            mGLSurfaceView.setRenderer(new NativeTwoRenderer());
        } else {
            // This is where you Could create an OpenGL ES 1.x compatible
            // renderer if you wanted to support both ES 1 and ES 2
            return;
        }
        setContentView(mGLSurfaceView);
    }

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mGLSurfaceView = new GLSurfaceView(this);

        // Check if the system support OpenGL ES 2.0
        final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

        if (supportsEs2) {
            // Request an OpenGL ES 2.0 compatible context.
            mGLSurfaceView.setEGLContextClientVersion(2);

            // Set the renderer to out demo renderer,define below
//             mGLSurfaceView.setRenderer(new LessonOneRenderer());
            // or set a native implementation
            mGLSurfaceView.setRenderer(new NativeOneRenderer());
        } else {
            // This is where you Could create an OpenGL ES 1.x compatible
            // renderer if you wanted to support both ES 1 and ES 2
            return;
        }
        setContentView(mGLSurfaceView);
    }

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mGLSurfaceView = new GLSurfaceView(this);

        // Check if the system support OpenGL ES 2.0
        final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

        if (supportsEs2) {
            // Request an OpenGL ES 2.0 compatible context.
            mGLSurfaceView.setEGLContextClientVersion(2);

            // Set the renderer to out demo renderer,define below
//            mGLSurfaceView.setRenderer(new LessonFourRenderer(this));
            mGLSurfaceView.setRenderer(new NativeFourRenderer(this));
        } else {
            // This is where you Could create an OpenGL ES 1.x compatible
            // renderer if you wanted to support both ES 1 and ES 2
            return;
        }
        setContentView(mGLSurfaceView);
    }

void init(OpenGLEngine engine) {
    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager
            .getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) {
        // Request an OpenGL ES 2.0 compatible context.
        engine.setEGLContextClientVersion(2);

        // Set the renderer to our user-defined renderer.
        engine.setRenderer(getNeWrenderer());
    } else {
        // This is where you Could create an OpenGL ES 1.x compatible
        // renderer if you wanted to support both ES 1 and ES 2.
        return;
    }
}

@Override
public void onCreate(SurfaceHolder surfaceHolder) {
    super.onCreate(surfaceHolder);

    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) 
    {
        // Request an OpenGL ES 2.0 compatible context.
        setEGLContextClientVersion(2);

        // Set the renderer to our user-defined renderer.
        setRenderer(getNeWrenderer());
    } 
    else 
    {
        // This is where you Could create an OpenGL ES 1.x compatible
        // renderer if you wanted to support both ES 1 and ES 2.
        return;
    }           
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    mGLSurfaceView = new GLSurfaceView(this);

    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) {
        // Request an OpenGL ES 2.0 compatible context.
        mGLSurfaceView.setEGLContextClientVersion(2);

        // Set the renderer to our demo renderer,defined below.
        mGLSurfaceView.setRenderer(new LessonOneRenderer());
    } else {
        // This is where you Could create an OpenGL ES 1.x compatible
        // renderer if you wanted to support both ES 1 and ES 2.
        return;
    }

    setContentView(mGLSurfaceView);
}

@Before
public void setUp() throws Exception {
    mockStatic(Build.class,System.class);
    mockStaticField(Build.VERSION.class,"RELEASE",ANDROID_VERSION);
    mockStaticField(Build.VERSION.class,"SDK_INT",ANDROID_API);
    mockStaticField(Build.class,"ID",BUILD_ID);
    mockStaticField(Build.class,"cpu_ABI",ABI);
    mockStaticField(Build.class,"BOOTLOADER",BOOTLOADER);

    when(System.getProperty(SystemInfoProviderImpl.OS_NAME)).thenReturn(OS_NAME);
    when(System.getProperty(SystemInfoProviderImpl.OS_VERSION)).thenReturn(OS_VERSION);

    ActivityManager mockActivityManager = mock(ActivityManager.class);
    ConfigurationInfo mockConfigInfo = mock(ConfigurationInfo.class);
    when(mMockContext.getSystemService(Application.ACTIVITY_SERVICE)).thenReturn(mockActivityManager);
    when(mockActivityManager.getDeviceConfigurationInfo()).thenReturn(mockConfigInfo);
    when(mockConfigInfo.getGlEsversion()).thenReturn(OPEN_GL_VERSION);


    mProvider = new SystemInfoProviderImpl(mMockContext);
}

private void checkGLEsversion() {
    if (!mGLEsversionCheckComplete) {
        // mGLEsversion = SystemProperties.getInt(
        // "ro.opengles.version",// ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
        ActivityManager am = (ActivityManager) context
                .getSystemService(Context.ACTIVITY_SERVICE);
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        mGLEsversion = info.reqGlEsversion;
        if (mGLEsversion >= kGLES_20) {
            mMultipleGLESContextsAllowed = true;
        }
        if (LOG_SURFACE) {
            Log.w(TAG,"checkGLEsversion mGLEsversion =" + " "
                    + mGLEsversion + " mMultipleGLESContextsAllowed = "
                    + mMultipleGLESContextsAllowed);
        }
        mGLEsversionCheckComplete = true;
    }
}

/**
 * Basic settings for component
 *
 * @param glSurfaceView   - view that will contain the component
 * @param backgroundColor - preferable background color for correct colors blending
 */
private void initView(GLSurfaceView glSurfaceView,@ColorInt int backgroundColor) {
    // check if the system supports opengl es 2.0.
    Context context = glSurfaceView.getContext();
    final ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) {
        // Request an OpenGL ES 2.0 compatible context.
        glSurfaceView.setEGLContextClientVersion(2);

        // Set the renderer to our demo renderer,defined below.
        mRenderer = new BezierRenderer(glSurfaceView,backgroundColor);
        glSurfaceView.setRenderer(mRenderer);
        glSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
    } else {
        throw new UnsupportedOperationException();
    }
}

private void checkGLEsversion() {
    if (!mGLEsversionCheckComplete) {
        // mGLEsversion = SystemProperties.getInt(
        // "ro.opengles.version","checkGLEsversion mGLEsversion =" + " "
                    + mGLEsversion + " mMultipleGLESContextsAllowed = "
                    + mMultipleGLESContextsAllowed);
        }
        mGLEsversionCheckComplete = true;
    }
}

/**
 * Convince feature to add state of multiple system features.
 * Uses {@link PackageManager#hasSystemFeature(String)} call.
 * <p>
 * See https://developer.android.com/guide/topics/manifest/uses-feature-element.html#features-reference for
 * available system features.
 *
 * @param context               can be null,but will just return an empty list
 * @param labelSystemFeatureMap a map which has ui labels as key and android system feature string
 *                              (as returned as name by {@link PackageManager#getSystemAvailableFeatures()}) as value
 * @return list of page-entries (one for each map entry)
 */
public static List<PageEntry<?>> createSystemFeatureInfo(@Nullable Context context,Map<CharSequence,String> labelSystemFeatureMap) {
    List<PageEntry<?>> entries = new ArrayList<>();
    if (context != null) {

        for (Map.Entry<CharSequence,String> entry : labelSystemFeatureMap.entrySet()) {
            boolean supported;
            if (entry.getValue().matches("^-?\\d+$")) {
                final ConfigurationInfo configurationInfo = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getDeviceConfigurationInfo();
                supported = configurationInfo.reqGlEsversion >= Integer.valueOf(entry.getValue());
            } else {
                supported = context.getPackageManager().hasSystemFeature(entry.getValue());
            }
            entries.add(Hood.get().createPropertyEntry(entry.getKey(),String.valueOf(supported)));
        }
    }
    return entries;
}

@Override
public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState) {
    final Context context = getActivity();
    final View v = inflater.inflate(getContentViewId(),container,false);

    ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    ConfigurationInfo info = am.getDeviceConfigurationInfo();
    if (info.reqGlEsversion < 0x20000)
        throw new Error("OpenGL ES 2.0 is not supported by this device");

    loading = v.findViewById(R.id.loading);
    gLView = (GLSurfaceView) v.findViewById(R.id.gl);
    renderer = new ModelRenderer(context);
    renderer.setSurfaceView(gLView);
    gLView.setRenderer(renderer);

    loader.loadModel(getActivity(),this);
    return v;
}

private void initGlSurfaceView() {
    mGLSurfaceView = new StarWarsTilesGLSurfaceView(getContext());
    mGLSurfaceView.setBackgroundColor(Color.TRANSPARENT);

    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getContext().getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) {
        // Request an OpenGL ES 2.0 compatible context.
        mGLSurfaceView.setEGLContextClientVersion(2);

        mRenderer = new StarWarsRenderer(mGLSurfaceView,this,mAnimationDuration,mNumberOfTilesX);
        mGLSurfaceView.setEGLConfigChooser(8,8,16,0);
        mGLSurfaceView.getHolder().setFormat(PixelFormat.TRANSPARENT);
        mGLSurfaceView.setRenderer(mRenderer);
        mGLSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
        mGLSurfaceView.setZOrderOnTop(true);
    } else {
        throw new UnsupportedOperationException();
    }
}

@Override protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mGlSurfaceView = new GLSurfaceView(this);

    final ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo deviceConfigurationInfo = am.getDeviceConfigurationInfo();
    mIsSupportedEs2 =
            deviceConfigurationInfo.reqGlEsversion >= 0x20000 || (Build.VERSION.SDK_INT
                    >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1
                    && (Build.FINGERPRINT.startsWith("generic") || Build.FINGERPRINT.startsWith(
                    "unkNow") || Build.MODEL.contains("google_sdk") || Build.MODEL.contains(
                    "Emulator") || Build.MODEL.contains("Android SDK built for x86")));
    mGlSurfaceView.setEGLContextClientVersion(2);
    if (mIsSupportedEs2) {
        setGlSurfaceVieWrenderer();
        mRenderSet = true;
    } else {
        Toast.makeText(this,"This device does not support OpenGl ES 2.0",Toast.LENGTH_SHORT)
                .show();
        return;
    }
    setContentView(mGlSurfaceView);
}

@Override
public void onCreate(SurfaceHolder surfaceHolder)
{
    super.onCreate(surfaceHolder);
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) {
        puvoGLSurfaceView = new PuvoGLSurfaceView(PuvoGLWallpaperService.this);

        setEGLContextClientVersion(2);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            setPreserveEGLContextOnPause(true);
            setEGConfigChooser();
        }
        setRenderer(getNeWrenderer());
        setRenderMode();
    } else {
        throw new RuntimeException("system doesn't support OpenGL ES 2.0");
    }
}

@Override
public View onCreateView(LayoutInflater inflater,this);
    return v;
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this.getActivity());

    ActivityManager am = (ActivityManager) this.getActivity().getSystemService(Context.ACTIVITY_SERVICE);
    if (checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if (info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);

    if (mMultisamplingEnabled)
        createMultisampleConfig();
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this);

    ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    if (checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if (info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);
    mLayout = new FrameLayout(this);
    mLayout.addView(mSurfaceView);

    if (mMultisamplingEnabled)
        createMultisampleConfig();

    setContentView(mLayout);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this);

    ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    if (checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if (info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);
    mLayout = new FrameLayout(this);
    mLayout.addView(mSurfaceView);

    if (mMultisamplingEnabled)
        createMultisampleConfig();

    setContentView(mLayout);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this.getActivity());

    ActivityManager am = (ActivityManager)this.getActivity().getSystemService(Context.ACTIVITY_SERVICE);
    if(checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if(info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);

    if(mMultisamplingEnabled)
        createMultisampleConfig();
}

protected void createSurfaceView()
{
    mSurfaceView = new GLSurfaceView(this);

    ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
    if(checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if(info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);

    mLayout = new FrameLayout(this);
    mLayout.addView(mSurfaceView);

    if(mMultisamplingEnabled)
        createMultisampleConfig();

    setContentView(mLayout);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    // Turn off the window's title bar
    requestwindowFeature(Window.FEATURE_NO_TITLE);

    super.onCreate(savedInstanceState);
    mGLSurfaceView = new GLSurfaceView(this);
    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;
    if (supportsEs2)
    {
        // Request an OpenGL ES 2.0 compatible context.
        mGLSurfaceView.setEGLContextClientVersion(2);
        // Set the renderer to our demo renderer,defined below.
        mGLSurfaceView.setRenderer(new LessonOneRenderer());
    }
    else
    {
        // This is where you Could create an OpenGL ES 1.x compatible
        // renderer if you wanted to support both ES 1 and ES 2.
        return;
    }
    setContentView(mGLSurfaceView);
}

public static IGLVersion getGLVersion(Context context)
{
   IGLVersion glVersion = XeglunkNown.GL_UNKNowN;

   final ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
   final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

   String glesversionString = configurationInfo.getGlEsversion();

   // This is messy...
   if (XeGLES2.GLES2_0.versionString.equals(glesversionString))
   {
      glVersion = XeGLES2.GLES2_0;
   }
   else if (XeGLES3.GLES3_0.versionString.equals(glesversionString))
   {
      glVersion = XeGLES3.GLES3_0;
   }
   else if (XeGLES3.GLES3_1.versionString.equals(glesversionString))
   {
      glVersion = XeGLES3.GLES3_1;
   }

   return glVersion;
}

@Override
public View onCreateView(LayoutInflater inflater,this);
    return v;
}

/**
 * Check whether Google Maps v2 is supported on this device.
 */
public static boolean isGoogleMapsV2Supported(final Context aContext) {
    try {
        // first check if Google Play Services is available
        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(aContext);
        if (resultCode == ConnectionResult.SUCCESS) {
            // then check if OpenGL ES 2.0 is available
            final ActivityManager activityManager =
                    (ActivityManager) aContext.getSystemService(Context.ACTIVITY_SERVICE);
            final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
            return configurationInfo.reqGlEsversion >= 0x20000;
        }
    } catch (Throwable e) {
    }
    return false;
}

boolean detectGoogleMapsSupport() {
    // 1. Check for OpenGL ES 2.0
    final ActivityManager activityManager =
            (ActivityManager)getActivity().getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo =
            activityManager.getDeviceConfigurationInfo();
    if (configurationInfo.reqGlEsversion < 0x20000) {
        Log.w("LessonThreeFragment","Device does not support OpenGL ES 2.0");
        return false;
    }

    // 2. Check for Google Play Services availability
    final int playServicesstatus =
            GooglePlayServicesUtil.isGooglePlayServicesAvailable(getActivity());
    if (playServicesstatus != ConnectionResult.SUCCESS
            && Build.HARDWARE.contains("golfdish")) {
        // It's not possible to install or update Google Play on an emulator
        Log.w("LessonThreeFragment","Detected an emulator with missing or outdated Play Services.");
        return false;
    }

    Log.i("LessonThreeFragment","Locations will be displayed in Google Maps.");
    return true;
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this.getActivity());

    ActivityManager am = (ActivityManager)this.getActivity().getSystemService(Context.ACTIVITY_SERVICE);
    if(checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if(info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);

    if(mMultisamplingEnabled)
        createMultisampleConfig();
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this);

    ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
    if(checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if(info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);
    mLayout = new FrameLayout(this);
    mLayout.addView(mSurfaceView);

    if(mMultisamplingEnabled)
        createMultisampleConfig();

    setContentView(mLayout);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSurfaceView = new GLSurfaceView(this);

    ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
    if(checkOpenGLVersion) {
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        if(info.reqGlEsversion < 0x20000)
            throw new Error("OpenGL ES 2.0 is not supported by this device");
    }
    mSurfaceView.setEGLContextClientVersion(2);
    mLayout = new FrameLayout(this);
    mLayout.addView(mSurfaceView);

    if(mMultisamplingEnabled)
        createMultisampleConfig();

    setContentView(mLayout);
}

@Override
public View onCreateView(LayoutInflater inflater,this);
    return v;
}

public static boolean IsSupported(Context context) {
    ActivityManager am =
            (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    ConfigurationInfo info = am.getDeviceConfigurationInfo();
    if(info.reqGlEsversion >= 0x20000) {
        // Open GL ES 2.0 is supported.
        return true;
    }
    return false;
}

/**
 * Checks if OpenGL ES 2.0 is supported on the current device.
 *
 * @param context the context
 * @return true,if successful
 */
private boolean supportsOpenGLES2(final Context context) {
    final ActivityManager activityManager = (ActivityManager)
            context.getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo =
            activityManager.getDeviceConfigurationInfo();
    return configurationInfo.reqGlEsversion >= 0x20000;
}

@Override
public void onCreate(SurfaceHolder surfaceHolder) {
    super.onCreate(surfaceHolder);
    glSurfaceView = new WallpaperGLSurfaceView(GLWallpaperService.this);

    ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000
            || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1 &&
            (Build.FINGERPRINT.startsWith("generic")
                    || Build.FINGERPRINT.startsWith("unkNown")
                    || Build.MODEL.contains("google_sdk")
                    || Build.MODEL.contains("Emulator")
                    || Build.MODEL.contains("Android SDK built for x86")));

    particlesRenderer = new ParticlesRenderer(GLWallpaperService.this);
    if (supportsEs2) {
        glSurfaceView.setEGLContextClientVersion(2);
        glSurfaceView.setRenderer(particlesRenderer);
        rendererSet = true;
    } else {
        Toast.makeText(GLWallpaperService.this,"not support egl 2.0",Toast.LENGTH_LONG);
        return;
    }

    displayMetrics dm = getResources().getdisplayMetrics();
    screenX = dm.widthPixels;
    screenY = dm.heightPixels;
}

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    boolean supportES2 = configurationInfo.reqGlEsversion >= 0x2000;
    if (supportES2) {
        mGlSurfaceView = new GLSurfaceView(this);
        mGlSurfaceView.setEGLContextClientVersion(2);
        mGlSurfaceView.setRenderer(new RendererWrapper());
        rendererSet = true;
        setContentView(mGlSurfaceView);
    }
}

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mGlSurfaceView = new LessonEightGLSurfaceView(this);
        setContentView(mGlSurfaceView);
        // Check if the system support OpenGL ES 2.0
        final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

        if (supportsEs2) {
            // Request an OpenGL ES 2.0 compatible context.
            mGlSurfaceView.setEGLContextClientVersion(2);

            final displayMetrics displayMetrics = new displayMetrics();
            getwindowManager().getDefaultdisplay().getMetrics(displayMetrics);

            // Set the renderer to our demo renderer,defined below.
//            mRender = (Action) new LessonEightRenderer(this);
            mRender = (Action) new NativeEightRenderer(this);
            mGlSurfaceView.setRenderer((GLSurfaceView.Renderer) mRender,displayMetrics.density);
        } else {
            // This is where you Could create an OpenGL ES 1.x compatible
            // renderer if you wanted to support both ES 1 and ES 2
            return;
        }

    }

@Override
public void onCreate(SurfaceHolder surfaceHolder) {
    super.onCreate(surfaceHolder);

    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) 
    {
        // Request an OpenGL ES 2.0 compatible context.
        setEGLContextClientVersion(2);

        // On Honeycomb+ devices,this improves the performance when
        // leaving and resuming the live wallpaper.
        setPreserveEGLContextOnPause(true);

        // Set the renderer to our user-defined renderer.
        setRenderer(getNeWrenderer());
    } 
    else 
    {
        // This is where you Could create an OpenGL ES 1.x compatible
        // renderer if you wanted to support both ES 1 and ES 2.
        return;
    }           
}

@Override
public void onCreate(Bundle savedInstanceState) 
{
    super.onCreate(savedInstanceState);

    mGLSurfaceView = new GLSurfaceView(this);

    // Check if the system supports OpenGL ES 2.0.
    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
    final boolean supportsEs2 = configurationInfo.reqGlEsversion >= 0x20000;

    if (supportsEs2) 
    {
        // Request an OpenGL ES 2.0 compatible context.
        mGLSurfaceView.setEGLContextClientVersion(2);

        // Set the renderer to our demo renderer,defined below.
        mGLSurfaceView.setRenderer(new LessonThreeRenderer());
    } 
    else 
    {
        // This is where you Could create an OpenGL ES 1.x compatible
        // renderer if you wanted to support both ES 1 and ES 2.
        return;
    }

    setContentView(mGLSurfaceView);
}

@Before
public void setup() {
  store = new InMemoryStorage();
  metrics = new InMemoryCollectorMetrics();

  collector = new SQSCollector.Builder()
      .queueUrl(sqsRule.queueUrl())
      .parallelism(2)
      .waitTimeSeconds(1) // using short wait time to make test teardown faster
      .endpointConfiguration(new EndpointConfiguration(sqsRule.queueUrl(),"us-east-1"))
      .credentialsProvider(new AWsstaticCredentialsProvider(new BasicAWSCredentials("x","x")))
      .metrics(metrics)
      .sampler(CollectorSampler.ALWAYS_SAMPLE)
      .storage(store)
      .build()
      .start();
}

/**
 * Returns a client instance for AWS DynamoDB.
 * @return a client that talks to DynamoDB
 */
public static AmazonDynamoDB getClient() {
    if (ddbClient != null) {
        return ddbClient;
    }

    if (Config.IN_PRODUCTION) {
        ddbClient = AmazonDynamoDBClientBuilder.standard().withCredentials(new AWsstaticCredentialsProvider(
            new BasicAWSCredentials(Config.AWS_ACCESSKEY,Config.AWS_SECRETKEY))).
                withRegion(Config.AWS_REGION).build();
    } else {
        ddbClient = AmazonDynamoDBClientBuilder.standard().
                withCredentials(new AWsstaticCredentialsProvider(new BasicAWSCredentials("local","null"))).
                withEndpointConfiguration(new EndpointConfiguration(LOCAL_ENDPOINT,"")).build();
    }

    if (!existsTable(Config.getRootAppIdentifier())) {
        createTable(Config.getRootAppIdentifier());
    }

    ddb = new DynamoDB(ddbClient);

    Para.addDestroyListener(new DestroyListener() {
        public void onDestroy() {
            shutdownClient();
        }
    });

    return ddbClient;
}

/**
 * Returns a client instance for AWS SQS.
 * @return a client that talks to SQS
 */
public static AmazonSQS getClient() {
    if (sqsClient != null) {
        return sqsClient;
    }
    if (Config.IN_PRODUCTION) {
        sqsClient = AmazonSQSClientBuilder.standard().withCredentials(new AWsstaticCredentialsProvider(
            new BasicAWSCredentials(Config.AWS_ACCESSKEY,Config.AWS_SECRETKEY))).
                withRegion(Config.AWS_REGION).build();
    } else {
        sqsClient = AmazonSQSClientBuilder.standard().
                withCredentials(new AWsstaticCredentialsProvider(new BasicAWSCredentials("x","x"))).
                withEndpointConfiguration(new EndpointConfiguration(LOCAL_ENDPOINT,"")).build();
    }

    Para.addDestroyListener(new DestroyListener() {
        public void onDestroy() {
            sqsClient.shutdown();
        }
    });
    return sqsClient;
}

/**
 * Gets an Amazon S3 client from basic session credentials.
 *
 * @return an authenticated Amazon S3 amazonS3
 */
public AmazonS3 getAmazonS3Client() {
    if (amazonS3 == null) {
        amazonS3 = AmazonS3ClientBuilder.standard()
            .withEndpointConfiguration(new EndpointConfiguration(endpoint,region))
            .withClientConfiguration(new ClientConfiguration().withProtocol(Protocol.HTTP))
            .withCredentials(
                new AWsstaticCredentialsProvider(new BasicAWSCredentials(accessKeyId,accessKeySecret)))
            .build();
    }
    return amazonS3;
}

private AmazonS3 newInstance(String region,S3S3copierOptions s3s3copierOptions) {
  HadoopAWSCredentialProviderChain credentialsChain = getCredentialsProviderChain();
  AmazonS3ClientBuilder builder = AmazonS3ClientBuilder.standard().withCredentials(credentialsChain);
  URI s3Endpoint = s3s3copierOptions.getS3Endpoint(region);
  if (s3Endpoint != null) {
    EndpointConfiguration endpointConfiguration = new EndpointConfiguration(s3Endpoint.toString(),region);
    builder.withEndpointConfiguration(endpointConfiguration);
  } else {
    builder.withRegion(region);
  }
  return builder.build();
}

private AmazonS3 newGlobalInstance(S3S3copierOptions s3s3copierOptions) {
  HadoopAWSCredentialProviderChain credentialsChain = getCredentialsProviderChain();
  AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withForceGlobalBucketAccessEnabled(Boolean.TRUE)
      .withCredentials(credentialsChain);
  URI s3Endpoint = s3s3copierOptions.getS3Endpoint();
  if (s3Endpoint != null) {
    EndpointConfiguration endpointConfiguration = new EndpointConfiguration(s3Endpoint.toString(),Region.US_Standard.getFirstRegionId());
    builder.withEndpointConfiguration(endpointConfiguration);
  }
  return builder.build();
}

private static EndpointConfiguration getEndpointConfiguration(Configuration conf) {
  String endpointUrl = conf.get(ConfigurationVariable.S3_ENDPOINT_URI.getName());
  if (endpointUrl == null) {
    return null;
  }
  return new EndpointConfiguration(endpointUrl,getRegion(conf));
}

public AmazonS3 newInstance(Configuration conf) {
  int maxErrorRetry = conf.getInt(ConfigurationVariable.UPLOAD_RETRY_COUNT.getName(),ConfigurationVariable.UPLOAD_RETRY_COUNT.defaultIntValue());
  long errorRetryDelay = conf.getLong(ConfigurationVariable.UPLOAD_RETRY_DELAY_MS.getName(),ConfigurationVariable.UPLOAD_RETRY_DELAY_MS.defaultLongValue());

  LOG.info("Creating AWS S3 client with a retry policy of {} retries and {} ms of exponential backoff delay",maxErrorRetry,errorRetryDelay);

  RetryPolicy retryPolicy = new RetryPolicy(new CounterBasedRetryCondition(maxErrorRetry),new ExponentialBackoffStrategy(errorRetryDelay),true);
  ClientConfiguration clientConfiguration = new ClientConfiguration();
  clientConfiguration.setRetryPolicy(retryPolicy);
  clientConfiguration.setMaxErrorRetry(maxErrorRetry);

  AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withCredentials(new HadoopAWSCredentialProviderChain(conf))
      .withClientConfiguration(clientConfiguration);

  EndpointConfiguration endpointConfiguration = getEndpointConfiguration(conf);
  if (endpointConfiguration != null) {
    builder.withEndpointConfiguration(endpointConfiguration);
  } else {
    builder.withRegion(getRegion(conf));
  }

  return builder.build();
}

@Before
public void setup() {
  EndpointConfiguration endpoint =
      new EndpointConfiguration(UNIT_STACK_URL + ":" + SNS_PORT,Region.EU_Frankfurt.name());
  AWSCredentials credentials = new BasicAWSCredentials("key","secret");
  AWSCredentialsProvider credentialsProvider = new AWsstaticCredentialsProvider(credentials);

  sns = AmazonSNSAsyncclientBuilder.standard().withEndpointConfiguration(endpoint)
      .withCredentials(credentialsProvider).build();
}

@Before
public void setup() {
  MockParameters params = new MockParameters();
  params.setMockRegion("EU");
  mockS3(params);

  EndpointConfiguration endpoint =
      new EndpointConfiguration(UNIT_STACK_URL + ":" + S3_PORT,"secret");
  AWSCredentialsProvider credentialsProvider = new AWsstaticCredentialsProvider(credentials);

  s3 = AmazonS3ClientBuilder.standard().withEndpointConfiguration(endpoint)
      .withCredentials(credentialsProvider).build();
}

@Before
public void setup() {
  mockSqs(null);

  EndpointConfiguration endpoint =
      new EndpointConfiguration(UNIT_STACK_URL + ":" + SQS_PORT,"eu-central-1");
  AWSCredentials credentials = new BasicAWSCredentials("key","secret");
  AWSCredentialsProvider credentialsProvider = new AWsstaticCredentialsProvider(credentials);

  sqs = AmazonSQSAsyncclientBuilder.standard().withEndpointConfiguration(endpoint)
      .withCredentials(credentialsProvider).build();
}

@Test
public void endpointAndSigningRegionCanBeUsedInPlaceOfSetRegion() {
    AmazonConcreteClient client = new ConcreteSyncBuilder()
            .withEndpointConfiguration(new EndpointConfiguration("https://mockprefix.ap-southeast-2.amazonaws.com","us-east-1"))
            .build();
    assertEquals("us-east-1",client.getSignerRegionOverride());
    assertEquals(URI.create("https://mockprefix.ap-southeast-2.amazonaws.com"),client.getEndpoint());
}

@Test(expected = IllegalStateException.class)
public void cannotSetBothEndpointConfigurationAndRegionOnBuilder() {
    new ConcreteSyncBuilder()
            .withEndpointConfiguration(new EndpointConfiguration("http://localhost:3030","us-west-2"))
            .withRegion("us-east-1")
            .build();
}

/**
 * @return An {@link AmazonS3} client instance that is configured to call the started S3Mock
 *         server using HTTPS.
 */
public AmazonS3 createS3Client() {
  final BasicAWSCredentials credentials = new BasicAWSCredentials("foo","bar");

  return AmazonS3ClientBuilder.standard()
      .withCredentials(new AWsstaticCredentialsProvider(credentials))
      .withClientConfiguration(
          configureClientToIgnoreInvalidSslCertificates(new ClientConfiguration()))
      .withEndpointConfiguration(
          new EndpointConfiguration("https://localhost:" + getPort(),"us-east-1"))
      .enablePathStyleAccess()
      .build();
}

/**
 * Configures the S3-Client to be used in the Test. Sets the SSL context to accept untrusted SSL
 * connections.
 */
@Before
public void prepareS3Client() {
  final BasicAWSCredentials credentials = new BasicAWSCredentials("foo","bar");

  s3Client = AmazonS3ClientBuilder.standard()
      .withCredentials(new AWsstaticCredentialsProvider(credentials))
      .withClientConfiguration(ignoringInvalidSslCertificates(new ClientConfiguration()))
      .withEndpointConfiguration(
          new EndpointConfiguration("https://" + getHost() + ":" + getPort(),"us-east-1"))
      .enablePathStyleAccess()
      .build();
}

@Before
public void setup() throws Exception {
  sender = KinesisSender.builder()
      .streamName("test")
      .endpointConfiguration(new EndpointConfiguration(server.url("/").toString(),"us-east-1"))
      .credentialsProvider(new AWsstaticCredentialsProvider(new AnonymousAWSCredentials()))
      .build();
}

/**
 * Get or initialize the S3 client.
 * Note: this method must be synchronized because we're accessing the
 * {@link #s3Client} field and we're calling this method from a worker thread.
 * @return the S3 client
 */
private synchronized AmazonS3 getS3Client() {
  if (s3Client == null) {
    BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey,secretKey);

    AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withCredentials(new AWsstaticCredentialsProvider(credentials));

    if (forceSignatureV2) {
      ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
      ClientConfiguration config = configFactory.getConfig();
      config.setSignerOverride("S3SignerType");
      builder = builder.withClientConfiguration(config);
    }

    String endpoint = "http://" + host + ":" + port;
    String clientRegion = null;
    if (!ServiceUtils.isS3UsstandardEndpoint(endpoint)) {
      clientRegion = AwsHostNameUtils.parseRegion(host,AmazonS3Client.S3_SERVICE_NAME);
    }

    builder = builder.withEndpointConfiguration(new EndpointConfiguration(
        endpoint,clientRegion));
    builder = builder.withPathStyleAccessEnabled(pathStyleAccess);

    s3Client = builder.build();
  }
  return s3Client;
}

protected void before() throws Throwable {
  s3Mock = S3Mock.create(Helper.findRandomOpenPortOnAllLocalInterfaces());
  localAddress = s3Mock.start().localAddress();
  amazonS3 = AmazonS3ClientBuilder.standard()
      .withEndpointConfiguration(new EndpointConfiguration(getEndpoint(),"eu-west-1"))
      .build();

  buckets.forEach(amazonS3::createBucket);
  files.forEach(fakeFile -> amazonS3.putObject(fakeFile.bucket,fakeFile.name,fakeFile.content));
}

@Test
public void getterSettertest() {
  String randomValue = UUID.randomUUID().toString();

  DynamoExample exampleClient = new DynamoExample(AmazonDynamoDBClientBuilder
      .standard()
      .withEndpointConfiguration(new EndpointConfiguration(subject.getEndpoint(),"eu-west-1"))
      .build());
  exampleClient.createTable();
  exampleClient.setValue(1L,randomValue);

  assertthat(exampleClient.getValue(1L),is(randomValue));
}

@Before
public void setUp() throws Exception {
    TestUtils.S3ProxyLaunchInfo info = TestUtils.startS3Proxy(
            "s3proxy.conf");
    awsCreds = new BasicAWSCredentials(info.getS3Identity(),info.getS3Credential());
    context = info.getBlobStore().getContext();
    s3Proxy = info.getS3Proxy();
    s3Endpoint = info.getSecureEndpoint();
    servicePath = info.getServicePath();
    s3EndpointConfig = new EndpointConfiguration(
            s3Endpoint.toString() + servicePath,"us-east-1");
    client = AmazonS3ClientBuilder.standard()
            .withCredentials(new AWsstaticCredentialsProvider(awsCreds))
            .withEndpointConfiguration(s3EndpointConfig)
            .build();

    containerName = createrandomContainerName();
    info.getBlobStore().createContainerInLocation(null,containerName);

    blobStoreType = context.unwrap().getProviderMetadata().getId();
    if (Quirks.OPAQUE_ETAG.contains(blobStoreType)) {
        System.setProperty(
                SkipMd5CheckStrategy
                        .disABLE_GET_OBJECT_MD5_VALIDATION_PROPERTY,"true");
        System.setProperty(
                SkipMd5CheckStrategy
                        .disABLE_PUT_OBJECT_MD5_VALIDATION_PROPERTY,"true");
    }
}

@Before
public void setUp() throws Exception {
    TestUtils.S3ProxyLaunchInfo info = TestUtils.startS3Proxy(
            "s3proxy-anonymous.conf");
    awsCreds = new AnonymousAWSCredentials();
    context = info.getBlobStore().getContext();
    s3Proxy = info.getS3Proxy();
    s3Endpoint = info.getSecureEndpoint();
    servicePath = info.getServicePath();
    s3EndpointConfig = new EndpointConfiguration(
            s3Endpoint.toString() + servicePath,"true");
    }
}

/**
 * Gets configured AmazonS3 client instance. Does not perform actual request until first remote data is needed
 */
private AmazonS3 getClient() {

    if (s3Client != null) {
        return s3Client; // already cached
    }

    ClientConfiguration config = new ClientConfiguration();
    if (endpoint != null && endpoint.startsWith("https://")) {
        config.setProtocol(Protocol.HTTPS);
    } else {
        config.setProtocol(Protocol.HTTP);
    }

    BasicAWSCredentials creds = new BasicAWSCredentials(accessKey,secretKey);
    if (LOG.isDebugEnabled()) {
        LOG.debug("Creating S3 client to " + ( (endpoint == null)
                                                                  ? "default Amazon"
                                                                  : endpoint)
                  + " endpoint with access key " + accessKey);
    }

    if (this.endpoint != null) {
        if (region == null || region.trim().length() == 0) {
            region = Regions.DEFAULT_REGION.name();
        }
        s3Client = AmazonS3ClientBuilder.standard()
                                        .withCredentials(new AWsstaticCredentialsProvider(creds))
                                        .withEndpointConfiguration(new EndpointConfiguration(endpoint,region))
                                        .withClientConfiguration(config)
                                        .withPathStyleAccessEnabled(true)
                                        .build();
    } else {
        s3Client = AmazonS3ClientBuilder.standard()
                                        .withCredentials(new AWsstaticCredentialsProvider(creds))
                                        .withClientConfiguration(config)
                                        .withPathStyleAccessEnabled(true)
                                        .build();
    }
    return s3Client;
}

private static AmazonMTurk getSandBoxClient() {
    AmazonMTurkClientBuilder builder = AmazonMTurkClientBuilder.standard();
    builder.setEndpointConfiguration(new EndpointConfiguration(SANDBox_ENDPOINT,SIGNING_REGION));
    return builder.build();
}

private static AmazonMTurk getProdClient() {
    AmazonMTurkClientBuilder builder = AmazonMTurkClientBuilder.standard();
    builder.setEndpointConfiguration(new EndpointConfiguration(PROD_ENDPOINT,SIGNING_REGION));
    return builder.build();
}

private static AmazonMTurk getSandBoxClient() {
    AmazonMTurkClientBuilder builder = AmazonMTurkClientBuilder.standard();
    builder.setEndpointConfiguration(new EndpointConfiguration(SANDBox_ENDPOINT,SIGNING_REGION));
    return builder.build();
}

private static AmazonMTurk getProductionClient() {
    AmazonMTurkClientBuilder builder = AmazonMTurkClientBuilder.standard();
    builder.setEndpointConfiguration(new EndpointConfiguration(PRODUCTION_ENDPOINT,SIGNING_REGION));
    return builder.build();
}

private static AmazonMTurk getSandBoxClient() {
    AmazonMTurkClientBuilder builder = AmazonMTurkClientBuilder.standard();
    builder.setEndpointConfiguration(new EndpointConfiguration(SANDBox_ENDPOINT,SIGNING_REGION));
    return builder.build();
}

public static EndpointConfiguration getEndpointConfig(String serviceEndpoint,String signingRegion) {
    return new EndpointConfiguration(serviceEndpoint,signingRegion);
}

@Nullable abstract EndpointConfiguration endpointConfiguration();

@Nullable abstract EndpointConfiguration endpointConfiguration();

/**
 * Creates an AmazonKinesis client.
 * @param configProps configuration properties containing the access key,secret key,and region
 * @return a new AmazonKinesis client
 */
public static AmazonKinesis createKinesisClient(Properties configProps) {
    // set a Flink-specific user agent
    ClientConfiguration awsClientConfig = new ClientConfigurationFactory().getConfig()
            .withUserAgentPrefix(String.format(USER_AGENT_FORMAT,Environmentinformation.getVersion(),Environmentinformation.getRevisioninformation().commitId));

    // utilize automatic refreshment of credentials by directly passing the AWSCredentialsProvider
    AmazonKinesisClientBuilder builder = AmazonKinesisClientBuilder.standard()
            .withCredentials(AWSUtil.getCredentialsProvider(configProps))
            .withClientConfiguration(awsClientConfig)
            .withRegion(Regions.fromName(configProps.getProperty(AWSConfigConstants.AWS_REGION)));

    if (configProps.containsKey(AWSConfigConstants.AWS_ENDPOINT)) {
        // Set signingRegion as null,to facilitate mocking Kinesis for local tests
        builder.withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(
                                                configProps.getProperty(AWSConfigConstants.AWS_ENDPOINT),null));
    }
    return builder.build();
}

/**
 * Creates an Amazon Kinesis Client.
 * @param configProps configuration properties containing the access key,and region
 * @return a new Amazon Kinesis Client
 */
public static AmazonKinesisClient createKinesisClient(Properties configProps) {
    // set a Flink-specific user agent
    ClientConfiguration awsClientConfig = new ClientConfigurationFactory().getConfig();
    awsClientConfig.setUserAgent("Apache Flink " + Environmentinformation.getVersion() +
        " (" + Environmentinformation.getRevisioninformation().commitId + ") Kinesis Connector");

    // utilize automatic refreshment of credentials by directly passing the AWSCredentialsProvider
    AmazonKinesisClient client = new AmazonKinesisClient(
        AWSUtil.getCredentialsProvider(configProps),awsClientConfig);

    client.setRegion(Region.getRegion(Regions.fromName(configProps.getProperty(AWSConfigConstants.AWS_REGION))));
    if (configProps.containsKey(AWSConfigConstants.AWS_ENDPOINT)) {
        client.setEndpoint(configProps.getProperty(AWSConfigConstants.AWS_ENDPOINT));
    }
    return client;
}

@SdkTestInternalApi
AmazonS3Builder(SdkFunction<AmazonS3ClientParamsWrapper,AmazonS3> clientFactory,ClientConfigurationFactory clientConfigFactory,AwsRegionProvider regionProvider) {
    super(clientConfigFactory,regionProvider);
    this.clientFactory = clientFactory;
}

/**
 * Get or initialize the S3 client.
 * Note: this method must be synchronized because we're accessing the
 * {@link #s3Client} field and we're calling this method from a worker thread.
 * @return the S3 client
 */
private synchronized AmazonS3 getS3Client() {
  if (s3Client == null) {
    BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey,secretKey);

    AmazonS3ClientBuilder builder = AmazonS3ClientBuilder
      .standard()
      .withCredentials(new AWsstaticCredentialsProvider(credentials));

    if (forceSignatureV2) {
      ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
      ClientConfiguration config = configFactory.getConfig();
      config.setSignerOverride("S3SignerType");
      builder = builder.withClientConfiguration(config);
    }

    String endpoint = "http://" + host + ":" + port;
    String clientRegion = null;
    if (!ServiceUtils.isS3UsstandardEndpoint(endpoint)) {
      clientRegion = AwsHostNameUtils.parseRegion(host,AmazonS3Client.S3_SERVICE_NAME);
    }

    builder = builder.withEndpointConfiguration(new EndpointConfiguration(
        endpoint,clientRegion));
    builder = builder.withPathStyleAccessEnabled(pathStyleAccess);

    s3Client = builder.build();
  }
  return s3Client;
}

/**
 * Create AWS client configuration and return it.
 * @return AWS client configuration
 */
private ClientConfiguration createClientConfiguration() {
  ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
  ClientConfiguration config = configFactory.getConfig();

  String s3SignerOverride = conf.getS3SignerOverride();
  if (StringUtils.isNotBlank(s3SignerOverride)) {
    config.setSignerOverride(s3SignerOverride);
  }

  return config;
}

public static ClientConfiguration forAWS(@NotNull HttpUrl proxyUrl) {
    return new ClientConfigurationFactory().getConfig()
            .withProxyHost(proxyUrl.host())
            .withProxyPort(proxyUrl.port())
            .withProxyUsername(proxyUrl.username())
            .withProxyPassword(proxyUrl.password());
}

protected AwsSyncclientBuilder(ClientConfigurationFactory clientConfigFactory) {
    super(clientConfigFactory);
}

@SdkTestInternalApi
protected AwsSyncclientBuilder(ClientConfigurationFactory clientConfigFactory,regionProvider);
}

protected AwsAsyncclientBuilder(ClientConfigurationFactory clientConfigFactory) {
    super(clientConfigFactory);
}

@SdkTestInternalApi
protected AwsAsyncclientBuilder(ClientConfigurationFactory clientConfigFactory,regionProvider);
}

protected AwsClientBuilder(ClientConfigurationFactory clientConfigFactory) {
    this(clientConfigFactory,DEFAULT_REGION_PROVIDER);
}

@SdkTestInternalApi
protected AwsClientBuilder(ClientConfigurationFactory clientConfigFactory,AwsRegionProvider regionProvider) {
    this.clientConfigFactory = clientConfigFactory;
    this.regionProvider = regionProvider;
}

@SdkTestInternalApi
AmazonS3ClientBuilder(SdkFunction<AmazonS3ClientParamsWrapper,AwsRegionProvider regionProvider) {
    super(clientFactory,clientConfigFactory,regionProvider);
}

private AmazonTestWebserviceClientBuilder() {
    super(new ClientConfigurationFactory());
}

@Test
public void testExecute_noApiKey_noCreds() throws IOException {
    client = new GenericApiGatewayClientBuilder()
            .withEndpoint("https://foobar.execute-api.us-east-1.amazonaws.com")
            .withRegion(Region.getRegion(Regions.fromName("us-east-1")))
            .withClientConfiguration(new ClientConfiguration())
            .withHttpClient(new AmazonHttpClient(new ClientConfiguration(),mockClient,null))
            .build();

    GenericApiGatewayResponse response = client.execute(
            new GenericApiGatewayRequestBuilder()
                    .withBody(new ByteArrayInputStream("test request".getBytes()))
                    .withHttpMethod(HttpMethodName.POST)
                    .withResourcePath("/test/orders").build());

    assertEquals("Wrong response body","test payload",response.getBody());
    assertEquals("Wrong response status",200,response.getHttpResponse().getStatusCode());

    Mockito.verify(mockClient,times(1)).execute(argThat(new Lambdamatcher<>(
                    x -> (x.getmethod().equals("POST")
                            && x.getFirstHeader("x-api-key") == null
                            && x.getFirstHeader("Authorization") == null
                            && x.getURI().toString().equals("https://foobar.execute-api.us-east-1.amazonaws.com/test/orders")))),any(HttpContext.class));
}

private ClientConfiguration createConnectionProperties() {
    ClientConfiguration clientConfiguration = new ClientConfiguration();
    Optional<HttpProxySettings.HttpProxy> proxyOptional = s3ConnectionProperties.getProxy();
    if (proxyOptional.isPresent()) {
        HttpProxySettings.HttpProxy proxy = s3ConnectionProperties.getProxy().get();
        clientConfiguration.setProxyHost(proxy.host);
        clientConfiguration.setProxyPort(proxy.port);
        PasswordCredentials credentials = proxy.credentials;
        if (credentials != null) {
            clientConfiguration.setProxyUsername(credentials.getUsername());
            clientConfiguration.setProxyPassword(credentials.getpassword());
        }
    }
    Optional<Integer> maxErrorRetryCount = s3ConnectionProperties.getMaxErrorRetryCount();
    if (maxErrorRetryCount.isPresent()) {
        clientConfiguration.setMaxErrorRetry(maxErrorRetryCount.get());
    }
    return clientConfiguration;
}

public void testSigners() {
    assertthat(signerTester(null),is(false));
    assertthat(signerTester("QueryStringSignerType"),is(true));
    assertthat(signerTester("AWS3SignerType"),is(true));
    assertthat(signerTester("AWS4SignerType"),is(true));
    assertthat(signerTester("NoOpSignerType"),is(true));
    assertthat(signerTester("UndefinedSigner"),is(false));

    assertthat(signerTester("S3SignerType"),is(false));
    assertthat(signerTester("AWSS3V4SignerType"),is(false));

    ClientConfiguration configuration = new ClientConfiguration();
    AwsSigner.configureSigner("AWS4SignerType",configuration);
    assertEquals(configuration.getSignerOverride(),"AWS4SignerType");
    AwsSigner.configureSigner("AWS3SignerType","AWS3SignerType");
}

@Test(expected = AbortedException.class)
public void
clientExecutionTimeoutEnabled_aborted_exception_occurs_timeout_not_expired()
        throws Exception {
    ClientConfiguration config = new ClientConfiguration()
            .withClientExecutionTimeout(CLIENT_EXECUTION_TIMEOUT)
            .withMaxErrorRetry(0);
    ConnectionManagerAwareHttpClient rawHttpClient =
            createrawHttpClientSpy(config);

    doThrow(new AbortedException()).when(rawHttpClient).execute(any
            (HttpRequestBase.class),any(HttpContext.class));

    httpClient = new AmazonHttpClient(config,rawHttpClient,null);

    execute(httpClient,createMockGetRequest());
}

/**
 * The sync client is tested less thoroughly then the async client primarily because the async
 * client exercises most of the same code paths so a bug introduced in the sync client builder
 * should be exposed via tests written against the async builder. This test is mainly for
 * additional coverage of the sync builder in case there is a regression specific to sync
 * builders.
 */
@Test
public void syncclientBuilder() {
    final List<RequestHandler2> requestHandlers = createRequestHandlerList(
            new ConcreteRequestHandler(),new ConcreteRequestHandler());
    final AWSCredentialsProvider credentials = mock(AWSCredentialsProvider.class);
    final RequestMetricCollector metrics = mock(RequestMetricCollector.class);

    //@formatter:off
    AmazonConcreteClient client = new ConcreteSyncBuilder()
            .withRegion(Regions.EU_CENTRAL_1)
            .withClientConfiguration(new ClientConfiguration().withSocketTimeout(1234))
            .withCredentials(credentials)
            .withMetricsCollector(metrics)
            .withRequestHandlers(requestHandlers.toArray(new RequestHandler2[requestHandlers.size()]))
            .build();
    //@formatter:on

    assertEquals(URI.create("https://mockprefix.eu-central-1.amazonaws.com"),client.getEndpoint());
    assertEquals(1234,client.getSyncParams().getClientConfiguration().getSocketTimeout());
    assertEquals(requestHandlers,client.getSyncParams().getRequestHandlers());
    assertEquals(credentials,client.getSyncParams().getCredentialsProvider());
    assertEquals(metrics,client.getSyncParams().getRequestMetricCollector());
}

@Test
public void clientExecutionTimeoutEnabled_RequestCompletesWithinTimeout_EntityNotBufferedForStreamedResponse()
        throws Exception {
    ClientConfiguration config = new ClientConfiguration().withClientExecutionTimeout(CLIENT_EXECUTION_TIMEOUT);
    ConnectionManagerAwareHttpClient rawHttpClient = createrawHttpClientSpy(config);

    HttpResponseProxy responseProxy = createHttpResponseProxySpy();
    doReturn(responseProxy).when(rawHttpClient).execute(any(HttpRequestBase.class),null);

    try {
        httpClient.requestExecutionBuilder().request(createMockGetRequest()).execute(new ErrorDuringUnmarshallingResponseHandler().leaveConnectionopen());
        fail("Exception expected");
    } catch (AmazonClientException e) {
    }

    assertResponseWasNotBuffered(responseProxy);
}

@Bean
public AmazonCloudWatch amazonCloudWatchClient(final AWSCredentialsProvider awsCredentialsProvider,final ClientConfiguration awsClientConfig,final Region awsRegion) {
    return AmazonCloudWatchClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}

@Test
public void testAwsClientConfig_noproxy() {
    String clientProtocol = "http";
    int clientConnectionTimeout = 10;
    int clientMaxErrorRetry = 20;
    setField(awsConfig,"clientProtocol",clientProtocol);
    setField(awsConfig,"clientConnectionTimeout",clientConnectionTimeout);
    setField(awsConfig,"clientMaxErrorRetry",clientMaxErrorRetry);

    setField(awsConfig,"useProxy",false);
    ClientConfiguration clientConfiguration = awsConfig.awsClientConfig(null);

    assertthat(clientConfiguration.getProxyHost(),nullValue());
    assertthat(clientConfiguration.getProxyPort(),equalTo(-1));
    assertthat(clientConfiguration.getProtocol().toString(),equalTo(clientProtocol));
    assertthat(clientConfiguration.getConnectionTimeout(),equalTo(clientConnectionTimeout));
    assertthat(clientConfiguration.getMaxErrorRetry(),equalTo(clientMaxErrorRetry));
}

public KMSEncryptionFeature(final S3Session session,final int timeout) {
    super(session);
    this.bookmark = session.getHost();
    configuration = new ClientConfiguration();
    configuration.setConnectionTimeout(timeout);
    configuration.setSocketTimeout(timeout);
    final UseragentProvider ua = new PreferencesUseragentProvider();
    configuration.setUserAgentPrefix(ua.get());
    configuration.setMaxErrorRetry(0);
    configuration.setMaxConnections(1);
    configuration.setUseGzip(PreferencesFactory.get().getBoolean("http.compression.enable"));
    final Proxy proxy = ProxyFactory.get().find(bookmark);
    switch(proxy.getType()) {
        case HTTP:
        case HTTPS:
            configuration.setProxyHost(proxy.getHostname());
            configuration.setProxyPort(proxy.getPort());
    }
    locationFeature = session.getFeature(Location.class);
}

public AmazonIdentityConfiguration(final Host bookmark,final int timeout) {
    this.bookmark = bookmark;
    this.configuration = new ClientConfiguration();
    this.configuration.setConnectionTimeout(timeout);
    this.configuration.setSocketTimeout(timeout);
    final UseragentProvider ua = new PreferencesUseragentProvider();
    this.configuration.setUserAgentPrefix(ua.get());
    this.configuration.setMaxErrorRetry(0);
    this.configuration.setMaxConnections(1);
    this.configuration.setUseGzip(PreferencesFactory.get().getBoolean("http.compression.enable"));
    final Proxy proxy = ProxyFactory.get().find(bookmark);
    switch(proxy.getType()) {
        case HTTP:
        case HTTPS:
            this.configuration.setProxyHost(proxy.getHostname());
            this.configuration.setProxyPort(proxy.getPort());
    }
}

@Override
protected void obtainResource() throws Exception {
    // See https://github.com/mhart/kinesalite#cbor-protocol-issues-with-the-java-sdk
    System.setProperty(SDKGlobalConfiguration.AWS_CBOR_disABLE_SYstem_PROPERTY,"true");

    this.resource = AmazonKinesisAsyncclientBuilder.standard()
            .withClientConfiguration(
                    new ClientConfiguration()
                            .withMaxErrorRetry(0)
                            .withConnectionTimeout(1000))
            .withEndpointConfiguration(
                    new AwsClientBuilder.EndpointConfiguration("http://localhost:" + this.port,Regions.DEFAULT_REGION.getName()))
            .withCredentials(new AWsstaticCredentialsProvider(new BasicAWSCredentials("","")))
            .build();

    // Check connection
    this.resource.listStreams();
}

@Test(expected = ClientExecutionTimeoutException.class)
public void
clientExecutionTimeoutEnabled_aborted_exception_occurs_timeout_expired()
        throws Exception {
    ClientConfiguration config = new ClientConfiguration()
            .withClientExecutionTimeout(CLIENT_EXECUTION_TIMEOUT)
            .withMaxErrorRetry(0);
    ConnectionManagerAwareHttpClient rawHttpClient =
            createrawHttpClientSpy(config);

    httpClient = new AmazonHttpClient(config,new EmptyHttpRequest(server.getEndpoint(),HttpMethodName.PUT,new SdkBufferedInputStream(new InputStream() {
        @Override
        public int read() throws IOException {
            // Sleeping here to avoid OOM issues from a limitless InputStream
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return 1;
        }
    })));
}

private AmazonSQSAsyncclientBuilder createStandardAsyncclientBuilder(SQSQueue queue,AWSCredentialsProvider credentials) {
    ClientConfiguration clientConfiguration = this.getClientConfiguration(queue);
    AmazonSQSAsyncclientBuilder builder = AmazonSQSAsyncclientBuilder.standard()
        .withClientConfiguration(clientConfiguration)
        .withCredentials(credentials)
        .withExecutorFactory(this.SQSExecutorFactory);

    if (queue != null) {
        Regions region = queue.getRegion();
        if (region != null) {
            builder.withRegion(region);
        }
    }

    return builder;
}

@Override
public AmazonS3Client load(S3ClientKey clientKey) throws Exception {
  logger.debug("opening S3 client connection for {}",clientKey);
  ClientConfiguration clientConf = new ClientConfiguration();
  clientConf.setProtocol(clientKey.isSecure ? Protocol.HTTPS : Protocol.HTTP);
  // Proxy settings (if configured)
  clientConf.setProxyHost(clientKey.s3Config.get(Constants.PROXY_HOST));
  if (clientKey.s3Config.get(Constants.PROXY_PORT) != null) {
    clientConf.setProxyPort(Integer.valueOf(clientKey.s3Config.get(Constants.PROXY_PORT)));
  }
  clientConf.setProxyDomain(clientKey.s3Config.get(Constants.PROXY_DOMAIN));
  clientConf.setProxyUsername(clientKey.s3Config.get(Constants.PROXY_USERNAME));
  clientConf.setProxyPassword(clientKey.s3Config.get(Constants.PROXY_PASSWORD));
  clientConf.setProxyWorkstation(clientKey.s3Config.get(Constants.PROXY_WORKSTATION));

  if (clientKey.accessKey == null){
    return new AmazonS3Client(new AnonymousAWSCredentialsProvider(),clientConf);
  } else {
    return new AmazonS3Client(new BasicAWSCredentials(clientKey.accessKey,clientKey.secretKey),clientConf);
  }
}

@Test(timeout = 60 * 1000)
public void testSslHandshakeTimeout() {
    AmazonHttpClient httpClient = new AmazonHttpClient(new ClientConfiguration()
            .withSocketTimeout(CLIENT_SOCKET_TO).withMaxErrorRetry(0));

    System.out.println("Sending request to localhost...");

    try {
        httpClient.requestExecutionBuilder()
                .request(new EmptyHttpRequest(server.getHttpsEndpoint(),HttpMethodName.GET))
                .execute();
        fail("Client-side socket read timeout is expected!");

    } catch (AmazonClientException e) {
        /**
         * Http client catches the SocketTimeoutException and throws a
         * ConnectTimeoutException.
         * {@link org.apache.http.impl.conn.DefaultHttpClientConnectionoperator#connect(ManagedHttpClientConnection,HttpHost,InetSocketAddress,int,SocketConfig,HttpContext)}
         */
        Assert.assertTrue(e.getCause() instanceof ConnectTimeoutException);

        ConnectTimeoutException cte = (ConnectTimeoutException) e.getCause();
        Assert.assertthat(cte.getMessage(),org.hamcrest.Matchers
                .containsstring("Read timed out"));
    }
}

@Test(timeout = 60 * 1000)
public void leasing_a_new_connection_fails_with_connection_pool_timeout()
        throws Exception {

    String localhostEndpoint = "http://localhost:" + server.getPort();

    AmazonHttpClient httpClient = new AmazonHttpClient(
            new ClientConfiguration()
                    .withMaxConnections(1)
                    .withConnectionTimeout(100)
                    .withMaxErrorRetry(0));

    Request<?> request = new EmptyHttpRequest(localhostEndpoint,HttpMethodName.GET);

    // Block the first connection in the pool with this request.
    httpClient.requestExecutionBuilder().request(request).execute(new EmptyAWSResponseHandler());

    try {
        // A new connection will be leased here which would fail in
        // ConnectionPoolTimeoutException.
        httpClient.requestExecutionBuilder().request(request).execute();
        Assert.fail("Connection pool timeout exception is expected!");
    } catch (AmazonClientException e) {
        Assert.assertTrue(e.getCause() instanceof ConnectionPoolTimeoutException);
    }
}

@Test(timeout = TEST_TIMEOUT)
public void requestTimeoutdisabledInRequestObject_TakesPrecedenceOverClientConfiguration() {
    final int socketTimeout = REQUEST_TIMEOUT;
    // Client configuration is set arbitrarily low so that the request will be aborted if
    // the client configuration is incorrectly honored over the request config
    httpClient = new AmazonHttpClient(
            new ClientConfiguration().withSocketTimeout(socketTimeout).withRequestTimeout(1).withMaxErrorRetry(0));

    try {
        EmptyHttpRequest request = newGetRequest();
        request.setoriginalRequest(new EmptyAmazonWebServiceRequest().withSdkRequestTimeout(0));
        execute(httpClient,request);
        fail("Exception expected");
    } catch (AmazonClientException e) {
        assertthat(e.getCause(),instanceOf(SocketTimeoutException.class));
    }
}

@Test
public void requestTimeoutEnabled_RequestCompletesWithinTimeout_TaskCanceledAndEntityBuffered() throws Exception {
    ClientConfiguration config = new ClientConfiguration().withRequestTimeout(5 * 1000).withMaxErrorRetry(0);
    ConnectionManagerAwareHttpClient rawHttpClient = createrawHttpClientSpy(config);

    HttpResponseProxy responseProxy = createHttpResponseProxySpy();
    doReturn(responseProxy).when(rawHttpClient).execute(any(HttpRequestBase.class),null);

    try {
        execute(httpClient,createMockGetRequest());
        fail("Exception expected");
    } catch (AmazonClientException e) {
        NullResponseHandler.assertIsUnmarshallingException(e);
    }

    assertResponseIsBuffered(responseProxy);
    ScheduledThreadPoolExecutor requestTimerExecutor = httpClient.getHttpRequestTimer().getExecutor();
    assertTimerNeverTriggered(requestTimerExecutor);
    assertCanceledTasksRemoved(requestTimerExecutor);
    // Core threads should be spun up on demand. Since only one task was submitted only one
    // thread should exist
    assertEquals(1,requestTimerExecutor.getPoolSize());
    assertCoreThreadsShutDownAfterBeingIdle(requestTimerExecutor);
}

@Test
public void requestTimeoutdisabled_RequestCompletesWithinTimeout_EntityNotBuffered() throws Exception {
    ClientConfiguration config = new ClientConfiguration().withRequestTimeout(0);
    ConnectionManagerAwareHttpClient rawHttpClient = createrawHttpClientSpy(config);

    HttpResponseProxy responseProxy = createHttpResponseProxySpy();
    doReturn(responseProxy).when(rawHttpClient).execute(any(HttpRequestBase.class),createMockGetRequest());
        fail("Exception expected");
    } catch (AmazonClientException e) {
    }

    assertResponseWasNotBuffered(responseProxy);
}

@Test
public void requestTimeoutEnabled_RequestCompletesWithinTimeout_EntityNotBufferedForStreamedResponse()
        throws Exception {
    ClientConfiguration config = new ClientConfiguration().withRequestTimeout(5 * 1000);
    ConnectionManagerAwareHttpClient rawHttpClient = createrawHttpClientSpy(config);

    HttpResponseProxy responseProxy = createHttpResponseProxySpy();
    doReturn(responseProxy).when(rawHttpClient).execute(any(HttpRequestBase.class),null);

    try {
        httpClient.requestExecutionBuilder().request(createMockGetRequest()).execute(new ErrorDuringUnmarshallingResponseHandler().leaveConnectionopen());
        fail("Exception expected");
    } catch (AmazonClientException e) {
    }

    assertResponseWasNotBuffered(responseProxy);
}

@Test(timeout = TEST_TIMEOUT)
public void requestTimeoutSetInRequestObject_TakesPrecedenceOverClientConfiguration() {
    // Client configuration is set arbitrarily high so that the test will timeout if the
    // client configuration is incorrectly honored over the request config
    httpClient = new AmazonHttpClient(new ClientConfiguration().withSocketTimeout(LONGER_SOCKET_TIMEOUT)
            .withRequestTimeout(REQUEST_TIMEOUT * 1000).withMaxErrorRetry(0));

    try {
        EmptyHttpRequest request = newGetRequest();
        request.setoriginalRequest(new EmptyAmazonWebServiceRequest().withSdkRequestTimeout(REQUEST_TIMEOUT));
        execute(httpClient,instanceOf(HttpRequestTimeoutException.class));
    }
}

/**
 * Add a AWS API Signer.
 * @param signer Signer to use
 * @param configuration AWS Client configuration
 */
public static void configureSigner(String signer,ClientConfiguration configuration) {
    try {
        validateSignerType(signer);
    } catch (IllegalArgumentException e) {
        logger.warn("{}",e.getMessage());
    }

    configuration.setSignerOverride(signer);
}

/**
 * @deprecated use {@link AmazonS3EncryptionClientBuilder#withEncryptionMaterials(EncryptionMaterialsProvider)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withCredentials(AWSCredentialsProvider)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withCryptoConfiguration(CryptoConfiguration)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withClientConfiguration(ClientConfiguration)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withMetricsCollector(RequestMetricCollector)}
 */
@Deprecated
public AmazonS3EncryptionClient(
        AWSCredentialsProvider credentialsProvider,EncryptionMaterialsProvider kekMaterialsProvider,ClientConfiguration clientConfig,CryptoConfiguration cryptoConfig,RequestMetricCollector requestMetricCollector) {
    this(null,// KMS client
        credentialsProvider,kekMaterialsProvider,clientConfig,cryptoConfig,requestMetricCollector);
}

private HttpClient createHttpClient(String nonProxyHosts) {
    HttpClientFactory<ConnectionManagerAwareHttpClient> httpClientFactory = new ApacheHttpClientFactory();
    ClientConfiguration config = new ClientConfiguration()
            .withProxyHost("localhost").withProxyPort(server.getPort())
            .withNonProxyHosts(nonProxyHosts);
    return httpClientFactory.create(HttpClientSettings.adapt(config));
}

protected void launchAWSConfigurationTest(Settings settings,Settings singleRepositorySettings,Protocol expectedProtocol,String expectedProxyHost,int expectedProxyPort,String expectedProxyUsername,String expectedProxyPassword,String expectedSigner,Integer expectedMaxRetries,boolean expectedUseThrottleRetries,int expectedReadTimeout) {
    Integer maxRetries = S3Repository.getValue(singleRepositorySettings,settings,S3Repository.Repository.MAX_RETRIES_SETTING,S3Repository.Repositories.MAX_RETRIES_SETTING);
    Boolean useThrottleRetries = S3Repository.getValue(singleRepositorySettings,S3Repository.Repository.USE_THRottLE_RETRIES_SETTING,S3Repository.Repositories.USE_THRottLE_RETRIES_SETTING);

    ClientConfiguration configuration = InternalAwsS3Service.buildConfiguration(logger,singleRepositorySettings,"default",maxRetries,null,useThrottleRetries);

    assertthat(configuration.getResponseMetadataCacheSize(),is(0));
    assertthat(configuration.getProtocol(),is(expectedProtocol));
    assertthat(configuration.getProxyHost(),is(expectedProxyHost));
    assertthat(configuration.getProxyPort(),is(expectedProxyPort));
    assertthat(configuration.getProxyUsername(),is(expectedProxyUsername));
    assertthat(configuration.getProxyPassword(),is(expectedProxyPassword));
    assertthat(configuration.getSignerOverride(),is(expectedSigner));
    assertthat(configuration.getMaxErrorRetry(),is(expectedMaxRetries));
    assertthat(configuration.useThrottledRetries(),is(expectedUseThrottleRetries));
    assertthat(configuration.getSocketTimeout(),is(expectedReadTimeout));
}

public AmazonEC2HostProvider(final AWSCredentials credentials,final ClientConfiguration configuration,String endpoint,Function<Instance,Host> instance_converter) {

        this.instance_converter = instance_converter;
        ec2_client = new AmazonEC2Client(credentials,configuration);
        ec2_client.setEndpoint(endpoint);
        next_host_index = new AtomicInteger();
    }

private MasterKeyProvider<?> masterKeyProvider() {

        final AWSCredentialsProvider credentials
                = new DefaultAWSCredentialsProviderChain();

        List<KmsMasterKey> masterKeys
                = new LinkedList<>();

        for (String region : this.regions) {
            KmsMasterKeyProvider provider
                    = new KmsMasterKeyProvider(
                            credentials,Region.getRegion(
                                    Regions.fromName(
                                            region)),new ClientConfiguration(),this.keyId);



            masterKeys.add(
                    provider.getMasterKey(
                            this.keyId));
        }

        return MultipleProviderFactory
                .buildMultiProvider(
                        masterKeys);
    }

@Test(timeout = TEST_TIMEOUT,expected = ClientExecutionTimeoutException.class)
public void clientExecutionTimeoutEnabled_SlowResponseHandler_ThrowsClientExecutionTimeoutException()
        throws Exception {
    httpClient = new AmazonHttpClient(
            new ClientConfiguration().withClientExecutionTimeout(CLIENT_EXECUTION_TIMEOUT));

    requestBuilder().execute(new UnresponsiveResponseHandler());
}

@Bean
public AmazonEC2 amazonEC2Client(final AWSCredentialsProvider awsCredentialsProvider,final Region awsRegion) {
    return AmazonEC2ClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}

@Test
public void regionAndProxyShouldBeReflectedInClient(){
    AwsKmsClientBuilder clientBuilder = new AwsKmsClientBuilder();
    clientBuilder.region("eu-west-1").proxyHost("host").proxyPort(8080);
    AWSKMSClient amazonKmsClient = clientBuilder.build();
    {
        ClientConfiguration configuration = (ClientConfiguration) WhiteBox.getInternalState(amazonKmsClient,"clientConfiguration");
        assertthat(configuration.getProxyHost()).isEqualTo("host");
        assertthat(configuration.getProxyPort()).isEqualTo(8080);
    }
}

/**
 * @return An {@link AmazonS3} client instance that is configured to call the started S3Mock
 *         server using HTTPS.
 */
public AmazonS3 createS3Client() {
  final BasicAWSCredentials credentials = new BasicAWSCredentials("foo","bar");

  return AmazonS3ClientBuilder.standard()
      .withCredentials(new AWsstaticCredentialsProvider(credentials))
      .withClientConfiguration(
          configureClientToIgnoreInvalidSslCertificates(new ClientConfiguration()))
      .withEndpointConfiguration(
          new EndpointConfiguration("https://localhost:" + getPort(),"us-east-1"))
      .enablePathStyleAccess()
      .build();
}

@Bean
public AmazonCloudFormation amazonCloudFormationClient(final AWSCredentialsProvider awsCredentialsProvider,final Region awsRegion) {
    return AmazonCloudFormationClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}

@Bean
public AmazonS3 amazonS3Client(final AWSCredentialsProvider awsCredentialsProvider,final Region awsRegion) {
    return AmazonS3ClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}

@Test
public void regionSetButHostFilledWithSpaces() {
    AwsS3ClientBuilder clientBuilder = new AwsS3ClientBuilder();
    clientBuilder.region("eu-west-1").proxyHost("    ").proxyPort(8080);
    AmazonS3Client amazonS3Client = clientBuilder.build();
    assertthat(amazonS3Client.getRegion().toString()).isEqualTo(Region.getRegion(Regions.EU_WEST_1).toString());
    {
        ClientConfiguration configuration = (ClientConfiguration)WhiteBox.getInternalState(amazonS3Client,"clientConfiguration");
        assertthat(configuration.getProxyHost()).isNull();
        assertthat(configuration.getProxyPort()).isEqualTo(-1);
    }
}

@Bean
public ClientConfiguration awsClientConfig() {
    ClientConfiguration clientConfig = new ClientConfiguration();

    if (useProxy) {
        clientConfig.setProxyHost(clientProxyHost);
        clientConfig.setProxyPort(clientProxyPort);
    }

    clientConfig.setProtocol(Protocol.valueOf(clientProtocol.toupperCase()));
    clientConfig.setConnectionTimeout(clientConnectionTimeout);
    clientConfig.setMaxErrorRetry(clientMaxErrorRetry);

    return clientConfig;
}

protected static AmazonS3 createS3(String accessKey,String secretKey) {
  AWSCredentials credentials = new BasicAWSCredentials(accessKey,secretKey);
  ClientConfiguration clientConfig = new ClientConfiguration();
  clientConfig.setProtocol(Protocol.HTTP);
  clientConfig.withSignerOverride("S3SignerType");
  //noinspection deprecation
  AmazonS3 s3 = new AmazonS3Client(credentials,clientConfig);
  s3.setEndpoint(s3Endpoint);
  return s3;
}

/**
 * Return amazon interface
 * 
 * @return AmazonEC2 client ec2
 */

AmazonEC2 getEC2() {
    if (ec2 == null) {
        String endpoint = ENDPOINT_PREFIX + ph.getRegion()
                + ENDPOINT_SUFFIX;
        String proxyHost = System.getProperty(HTTPS_PROXY_HOST);
        String proxyPort = System.getProperty(HTTPS_PROXY_PORT);
        String proxyUser = System.getProperty(HTTPS_PROXY_USER);
        String proxyPassword = System.getProperty(HTTPS_PROXY_PASSWORD);

        int proxyPortInt = 0;
        try {
            proxyPortInt = Integer.parseInt(proxyPort);
        } catch (NumberFormatException e) {
            // ignore
        }
        ClientConfiguration clientConfiguration = new ClientConfiguration();
        if (!isNonProxySet(endpoint)) {
            if (proxyHost != null) {
                clientConfiguration.setProxyHost(proxyHost);
            }
            if (proxyPortInt > 0) {
                clientConfiguration.setProxyPort(proxyPortInt);
            }
            if (proxyUser != null && proxyUser.length() > 0) {
                clientConfiguration.setProxyUsername(proxyUser);
            }
            if (proxyPassword != null && proxyPassword.length() > 0) {
                clientConfiguration.setProxyPassword(proxyPassword);
            }
        }
        ec2 = getEC2(credentialsProvider,clientConfiguration);
        ec2.setEndpoint(endpoint);
    }
    return ec2;
}

/**
 * Allow mocking of EC2 client by having it in separate creation method
 * 
 * @param credentialsProvider
 * @param clientConfiguration
 */
AmazonEC2Client getEC2(AWSCredentialsProvider credentialsProvider,ClientConfiguration clientConfiguration) {
    if (ec2 == null) {
        ec2 = (ec2_stub != null) ? ec2_stub : new AmazonEC2Client(
                credentialsProvider,clientConfiguration);
    }
    return ec2;
}

@Bean
AmazonSNSAsyncclient amazonSNS(ListenerConfig config,AWSCredentialsProvider awsCredentialsProvider) {
  AmazonSNSAsyncclient client = new AmazonSNSAsyncclient(awsCredentialsProvider,new ClientConfiguration().withRetryPolicy(PredefinedRetryPolicies.getDefaultRetryPolicy()),Executors.newSingleThreadScheduledExecutor());
  client.setRegion(Region.getRegion(Regions.fromName(config.getRegion())));
  return client;
}

@Test(timeout = TEST_TIMEOUT,expected = ClientExecutionTimeoutException.class)
public void clientExecutionTimeoutEnabled_SlowBeforeRequestRequestHandler_ThrowsClientExecutionTimeoutException()
        throws Exception {
    httpClient = new AmazonHttpClient(
            new ClientConfiguration().withClientExecutionTimeout(CLIENT_EXECUTION_TIMEOUT));

    List<RequestHandler2> requestHandlers = RequestHandlerTestUtils.buildrequestHandlerList(
            new SlowRequestHandler().withBeforeRequestWaitInSeconds(SLOW_REQUEST_HANDLER_TIMEOUT));

    requestBuilder().executionContext(withHandlers(requestHandlers)).execute(new DummyResponseHandler());
}

@Test
public void testClientDropsConnection() throws Exception {
    Tomcat tomcat = getTomcatInstance();
    // No file system docBase required
    Context ctx = tomcat.addContext("",null);
    ctx.addApplicationListener(Bug58624Config.class.getName());
    Tomcat.addServlet(ctx,"default",new DefaultServlet());
    ctx.addServletMapping("/","default");

    WebSocketContainer wsContainer =
            ContainerProvider.getWebSocketContainer();

    tomcat.start();

    SimpleClient client = new SimpleClient();
    URI uri = new URI("ws://localhost:" + getPort() + Bug58624Config.PATH);

    Session session = wsContainer.connectToServer(client,uri);
    // Break point A required on following line
    session.close();
}

@OnMessage
public void msgReceived(ChatMessage msg,Session s) {
    msg.from(user);
    if (msg.getMsg().equals(logoUT_MSG)) {
        try {
            s.close();
            return;
        } catch (IOException ex) {
            Logger.getLogger(ChatServer.class.getName()).log(Level.SEVERE,null,ex);
        }
    }

    ChatEventBus.getInstance().publishChat(msg);
    System.out.println("Chat Message placed on HZ Topic " + CHAT_TOPIC_NAME);

}

@Override
public void onClose(Session session,CloseReason closeReason) {
    Room room = getRoom(false);
    if (room != null) {
        room.invokeAndWait(new Runnable() {
            @Override
            public void run() {
                try {
                    // Player can be null if it Couldn't enter the room
                    if (player != null) {
                        // Remove this player from the room.
                        player.removeFromroom();

                        // Set player to null to prevent NPEs when onMessage events
                        // are processed (from other threads) after onClose has been
                        // called from different thread which closed the Websocket session.
                        player = null;
                    }
                } catch (RuntimeException ex) {
                    log.error("Unexpected exception: " + ex.toString(),ex);
                }
            }
        });
    }
}

/**
 * 
 * Called by web socket server,message contain execution tracking status that updated on job canvas.
 *
 * @param message the message
 * @param session the session
 */
@OnMessage
public void updateJobTrackingStatus(String message,Session session) { 

    final String status = message; 
    display.getDefault().asyncExec(new Runnable() {
        public void run() {
            Gson gson = new Gson();
            ExecutionStatus executionStatus=gson.fromJson(status,ExecutionStatus.class);
            IWorkbenchPage page = PlatformUI.getWorkbench().getWorkbenchWindows()[0].getActivePage();
            IEditorReference[] refs = page.getEditorReferences();
            for (IEditorReference ref : refs){
                IEditorPart editor = ref.getEditor(false);
                if(editor instanceof ELTGraphicalEditor){
                    ELTGraphicalEditor editPart=(ELTGraphicalEditor)editor;
                    if(editPart.getJobId().equals(executionStatus.getJobId()) || (((editPart.getContainer()!=null) && 
                            (editPart.getContainer().getUniqueJobId().equals(executionStatus.getJobId()))) && editPart.getContainer().isOpenedForTracking() )){
                            TrackingStatusUpdateUtils.INSTANCE.updateEditorWithCompStatus(executionStatus,(ELTGraphicalEditor)editor,false);
                    }
                }
            }
        }
    });
}

private static Object[] buildArgs(PojoPathParam[] pathParams,Map<String,String> pathParameters,Session session,EndpointConfig config,Throwable throwable,CloseReason closeReason) throws DecodeException {
    Object[] result = new Object[pathParams.length];
    for (int i = 0; i < pathParams.length; i++) {
        Class<?> type = pathParams[i].getType();
        if (type.equals(Session.class)) {
            result[i] = session;
        } else if (type.equals(EndpointConfig.class)) {
            result[i] = config;
        } else if (type.equals(Throwable.class)) {
            result[i] = throwable;
        } else if (type.equals(CloseReason.class)) {
            result[i] = closeReason;
        } else {
            String name = pathParams[i].getName();
            String value = pathParameters.get(name);
            try {
                result[i] = Util.coercetoType(type,value);
            } catch (Exception e) {
                throw new DecodeException(value,sm.getString("pojoMethodMapping.decodePathParamFail",value,type),e);
            }
        }
    }
    return result;
}

/**
 * 连接建立成功调用的方法-与前端JS代码对应
 * 
 * @param session 可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
 */
@Onopen
public void onopen(Session session,EndpointConfig config) {
    // 单个会话对象保存
    this.session = session;
    webSocketSet.add(this); // 加入set中
    this.httpSession = (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
    String uId = (String) httpSession.getAttribute("userid"); // 获取当前用户
    String sessionId = httpSession.getId();
    this.userid = uId + "|" + sessionId;
    if (!OnlineUserlist.contains(this.userid)) {
        OnlineUserlist.add(userid); // 将用户名加入在线列表
    }
    routetabMap.put(userid,session); // 将用户名和session绑定到路由表
    System.out.println(userid + " -> 已上线");
    String message = getMessage(userid + " -> 已上线","notice",OnlineUserlist);
    broadcast(message); // 广播
}

@OnClose
   public void unregisterUser(Session websocket,CloseReason reason) throws JSONException,IOException {
String login = websocket.getUserPrincipal().getName();
if (login == null) {
    return;
}

Integer organisationId = Integer
    .valueOf(websocket.getRequestParameterMap().get(AttributeNames.ParaM_ORGANISATION_ID).get(0));
KumaliveDTO kumalive = kumalives.get(organisationId);
if (kumalive == null) {
    return;
}
KumaliveUser user = kumalive.learners.remove(login);
if (user != null) {
    Integer userId = user.userDTO.getUserID();
    if (kumalive.raisedHand != null) {
    kumalive.raisedHand.remove(userId);
    }
    if (userId.equals(kumalive.speaker)) {
    kumalive.speaker = null;
    }
}

sendRefresh(kumalive);
   }

/**连接建立成功调用的方法*/
@Onopen
public void onopen(Session session,EndpointConfig config){
    HttpSession httpSession = (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
    if(StorageUtil.init(httpSession).getLoginMemberId()!=ReturnUtil.NOT_LOGIN_CODE){
        long userId = StorageUtil.init(httpSession).getLoginMemberId();
        mapUS.put(userId,session);
        mapSU.put(session,userId);
        //上线通知由客户端自主发起
        onlineCount++;           //在线数加1
        System.out.println("用户"+userId+"进入WebSocket！当前在线人数为" + onlineCount);
        getUserKey(userId);
    }else{
        try {
            session.close();
            System.out.println("未获取到用户信息，关闭WebSocket！");
        } catch (IOException e) {
            System.out.println("关闭WebSocket失败！");
        }
    }
}

/**
    * Removes Learner websocket from the collection.
    */
   @OnClose
   public void unregisterUser(Session session,CloseReason reason) {
String login = session.getUserPrincipal().getName();
if (login == null) {
    return;
}

Long lessonId = Long.valueOf(session.getRequestParameterMap().get(AttributeNames.ParaM_LESSON_ID).get(0));
Map<String,Session> lessonWebsockets = CommandWebsocketServer.websockets.get(lessonId);
if (lessonWebsockets == null) {
    return;
}

lessonWebsockets.remove(login);
   }

/**
    * Tell learners that the teacher finished a question
    */
   private void downHandPrompt(JSONObject requestJSON,Session websocket) throws IOException,JSONException {
Integer organisationId = Integer
    .valueOf(websocket.getRequestParameterMap().get(AttributeNames.ParaM_ORGANISATION_ID).get(0));
KumaliveDTO kumalive = kumalives.get(organisationId);

User user = getUser(websocket);
Integer userId = user.getUserId();

if (!KumaliveWebsocketServer.getSecurityService().hasOrgRole(organisationId,userId,new String[] { Role.GROUP_MANAGER,Role.MONITOR },"kumalive down hand prompt",false)) {
    String warning = "User " + userId + " is not a monitor of organisation " + organisationId;
    logger.warn(warning);
    return;
}

kumalive.raiseHandPrompt = false;
kumalive.raisedHand.clear();
if (logger.isDebugEnabled()) {
    logger.debug("Teacher " + userId + " finished a question in Kumalive " + kumalive.id);
}

sendRefresh(kumalive);
   }

public void broadcast(@Observes @leaderDataQualifier String leaderboard) {
    for (final Session s : CLIENTS) {
        if (s != null && s.isopen()) {
            /**
             * Asynchronous push
             */
            s.getAsyncRemote().sendText(leaderboard,new SendHandler() {
                @Override
                public void onResult(SendResult result) {
                    if (result.isOK()) {
                        //Logger.getLogger(MeetupGroupsLiveleaderboardEndpoint.class.getName()).log(Level.INFO," sent to client {0}",s.getId());
                    } else {
                        Logger.getLogger(MeetupGroupsLiveleaderboardEndpoint.class.getName()).log(Level.SEVERE,"Could not send to client " + s.getId(),result.getException());
                    }
                }
            });
        }

    }

}

/**
 * 
 * Close websocket client connection.
 * @param session
 */
public void closeWebSocketConnection(Session session){
    try {
        Thread.sleep(DELAY);
    } catch (InterruptedException e1) {
    }
    if (session != null  && session.isopen()) {
        try {
            CloseReason closeReason = new CloseReason(CloseCodes.norMAL_CLOSURE,"Closed");
            session.close(closeReason);
            logger.info("Session closed");
        } catch (IOException e) {
            logger.error("Fail to close connection ",e);
        }

    }

}

@Test
public void testClientDropsConnection() throws Exception {
    Tomcat tomcat = getTomcatInstance();
    // No file system docBase required
    Context ctx = tomcat.addContext("",uri);
    // Break point A required on following line
    session.close();
}

@Override
public final void onError(Session session,Throwable throwable) {

    if (methodMapping.getonError() == null) {
        log.error(sm.getString("pojoEndpointBase.onError",pojo.getClass().getName()),throwable);
    } else {
        try {
            methodMapping.getonError().invoke(
                    pojo,methodMapping.getonErrorArgs(pathParameters,session,throwable));
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("pojoEndpointBase.onErrorFail",t);
        }
    }
}

/**
    * When user leaves the activity.
    */
   @OnClose
   public void unregisterUser(Session websocket,CloseReason reason) {
Long toolContentID = Long
    .valueOf(websocket.getRequestParameterMap().get(AttributeNames.ParaM_TOOL_CONTENT_ID).get(0));
websockets.get(toolContentID).remove(websocket);

if (log.isDebugEnabled()) {
    // If there was something wrong with the connection,put it into logs.
    log.debug("User " + websocket.getUserPrincipal().getName() + " left Dokumaran with Tool Content ID: "
        + toolContentID
        + (!(reason.getCloseCode().equals(CloseCodes.GOING_AWAY)
            || reason.getCloseCode().equals(CloseCodes.norMAL_CLOSURE))
                ? ". Abnormal close. Code: " + reason.getCloseCode() + ". Reason: "
                    + reason.getReasonPhrase()
                : ""));
}
   }

public static synchronized void updateStatus2(Student student) {
    log.info("updateStatus2");
    for (Session s : sessions) {
        if (s.isopen()) {
            try {
                String studentUpdate = jsonStudentUpdate(student);
                s.getBasicRemote().sendText(studentUpdate);
                log.log(Level.INFO,"[StatusEndpoint] {0} is Now {1}",new Object[]{student.getName(),student.getStatus()});
                /* Send update */
            } catch (IOException e) {
                log.log(Level.INFO,"[StatusEndpoint] {0}",e.getMessage());
            }
        }
    }
}

/**
    * Registeres the Learner for processing.
    */
   @Onopen
   public void registerUser(Session websocket) throws JSONException,IOException {
Long toolSessionId = Long
    .valueOf(websocket.getRequestParameterMap().get(AttributeNames.ParaM_TOOL_SESSION_ID).get(0));
Set<Session> sessionWebsockets = websockets.get(toolSessionId);
if (sessionWebsockets == null) {
    sessionWebsockets = ConcurrentHashMap.newKeySet();
    websockets.put(toolSessionId,sessionWebsockets);
}
sessionWebsockets.add(websocket);

if (log.isDebugEnabled()) {
    log.debug("User " + websocket.getUserPrincipal().getName()
        + " entered leader Selection with toolSessionId: " + toolSessionId);
}
   }

@OnClose
public void onClose(Session session) throws InterruptedException {
    ClientSession clientSession = sessions.get(session.getId());

    if (clientSession != null) {
        clientSession.onClose();
        sessions.remove(session.getId());
    }

    System.out.printf("webSocket %s session closed.",session.getId());
}

@Test
public void testWebSocket() throws IOException {
    final EchoEndpoint endpoint = new EchoEndpoint();
    final Session session = getSession();
    endpoint.onopen(session);
    assertEquals("hello",endpoint.onMessage("hello",session));
    endpoint.onClose(session);
}

@Override
public void onopen(Session session,EndpointConfig config) {
    logger.debug("@onopen");

    wsClientSession = session;
    wsClientSession.addMessageHandler(this);    

    sendSubscribeRequest();
}

private Session getSession() {
    final Basic basicRemote = mock(Basic.class);

    final Session session = mock(Session.class);
    when(session.getBasicRemote()).thenReturn(basicRemote);
    return session;
}

Set<Session> getopenSessions(Endpoint endpoint) {
    HashSet<Session> result = new HashSet<Session>();
    synchronized (endPointSessionMapLock) {
        Set<WsSession> sessions = endpointSessionMap.get(endpoint);
        if (sessions != null) {
            result.addAll(sessions);
        }
    }
    return result;
}

/**
    * Save score for a learner
    */
   private void score(JSONObject requestJSON,JSONException {
Integer organisationId = Integer
    .valueOf(websocket.getRequestParameterMap().get(AttributeNames.ParaM_ORGANISATION_ID).get(0));

User user = getUser(websocket);
Integer userId = user.getUserId();

if (!KumaliveWebsocketServer.getSecurityService().hasOrgRole(organisationId,"kumalive score",false)) {
    String warning = "User " + userId + " is not a monitor of organisation " + organisationId;
    logger.warn(warning);
    return;
}
Long rubricId = requestJSON.getLong("rubricId");
Integer learnerId = requestJSON.getInt(AttributeNames.ParaM_USER_ID);
KumaliveWebsocketServer.getKumaliveService().scoreKumalive(rubricId,learnerId,Long.valueOf(requestJSON.getString("batch")),Short.valueOf(requestJSON.getString("score")));

KumaliveDTO kumalive = kumalives.get(organisationId);
if (logger.isDebugEnabled()) {
    logger.debug("Teacher " + userId + " marked rubric " + rubricId + " for learner " + learnerId
        + " in Kumalive " + kumalive.id);
}

sendRefresh(kumalive);
   }

@OnMessage
public void echoTextMessage(Session session,String msg,boolean last) {
    try {
        session.getBasicRemote().sendText(msg,last);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}

private void doTestPerMessageDefalteClient(String msg,int count) throws Exception {
    Tomcat tomcat = getTomcatInstance();
    // Must have a real docBase - just use temp
    Context ctx =
        tomcat.addContext("",System.getProperty("java.io.tmpdir"));
    ctx.addApplicationListener(TesterEchoServer.Config.class.getName());
    Tomcat.addServlet(ctx,"default");

    tomcat.start();

    Extension perMessageDeflate = new WsExtension(PerMessageDeflate.NAME);
    List<Extension> extensions = new ArrayList<Extension>(1);
    extensions.add(perMessageDeflate);

    ClientEndpointConfig clientConfig =
            ClientEndpointConfig.Builder.create().extensions(extensions).build();

    WebSocketContainer wsContainer =
            ContainerProvider.getWebSocketContainer();
    Session wsSession = wsContainer.connectToServer(
            TesterProgrammaticEndpoint.class,clientConfig,new URI("ws://" + getHostName() + ":" + getPort() +
                    TesterEchoServer.Config.PATH_ASYNC));
    CountDownLatch latch = new CountDownLatch(count);
    BasicText handler = new BasicText(latch,msg);
    wsSession.addMessageHandler(handler);
    for (int i = 0; i < count; i++) {
        wsSession.getBasicRemote().sendText(msg);
    }

    boolean latchResult = handler.getLatch().await(10,TimeUnit.SECONDS);

    Assert.assertTrue(latchResult);

    ((WsWebSocketContainer) wsContainer).destroy();
}

@OnMessage
public void echoBinaryMessage(Session session,ByteBuffer bb,boolean last) {
    try {
        if (session.isopen()) {
            session.getBasicRemote().sendBinary(bb,last);
        }
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}

@OnMessage(maxMessageSize = MAX_SIZE)
public void echoTextMessage(Session session,String msg) {
    try {
        session.getBasicRemote().sendText(msg);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}

@Override
public void launchJob(String xmlPath,String paramFile,String userFunctionspropertyFile,Job job,DefaultGEFCanvas gefCanvas,List<String> externalFiles,List<String> subJobList) {
    Session session=null;

    if(isExecutionTrackingOn()){
        HydrographServerConnection hydrographServerConnection = new HydrographServerConnection();
        session = hydrographServerConnection.connectToServer(job,job.getUniqueJobId(),webSocketLocalHost);
    if(hydrographServerConnection.getSelection() == 1){
        TrackingdisplayUtils.INSTANCE.closeWebSocketConnection(session);
        return;
    }
    } 

    String projectName = xmlPath.split("/",2)[0];
    IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
    job.setJobProjectDirectory(project.getLocation().toOsstring());

    String gradleCommand;
    job.setJobStatus(JobStatus.RUNNING);
    JobManager.INSTANCE.enableRunJob(false);

    enableLockedResources(gefCanvas);
    gradleCommand = getExecututeJobCommand(xmlPath,paramFile,userFunctionspropertyFile,job);
    executeCommand(job,project,gradleCommand,gefCanvas);

    if(job.getJobStatus().equalsIgnoreCase(JobStatus.RUNNING)){
        job.setJobStatus(JobStatus.SUCCESS);
    }

    if (job.getCanvasName().equals(JobManager.INSTANCE.getActiveCanvas())) {
        JobManager.INSTANCE.enableRunJob(true);
    }

    refreshProject(gefCanvas);
    JobManager.INSTANCE.removeJob(job.getCanvasName());
    ViewExecutionHistoryUtility.INSTANCE.addTrackingJobs(job.getConsoleName(),job);
    TrackingdisplayUtils.INSTANCE.closeWebSocketConnection(session);
}

/**
 * 随机线程
 * 
 * @param wsPacket
 */
public void userMessageReceiveHandle(WsPacket wsPacket) {
    Session session = (Session) wsPacket.session;
    OnlineUser onlineUser = OnlineUserManager.getonlineUserBySessionId(session.getId());
    if (onlineUser == null) {
        WSManager.log.warn("发消息的非在线用户，直接返回");
        return;
    }
    UserMessageReceiveC builder1 = (UserMessageReceiveC) wsPacket.getData();
    boolean result = ChatAction.updateChat(builder1.getMessageIdList());
}

@Override
public void onopen(Session session,EndpointConfig endpointConfig) {

    ServerEndpointConfig sec = (ServerEndpointConfig) endpointConfig;

    Object pojo;
    try {
        pojo = sec.getConfigurator().getEndpointInstance(
                sec.getEndpointClass());
    } catch (InstantiationException e) {
        throw new IllegalArgumentException(sm.getString(
                "pojoEndpointServer.getPojoInstanceFail",sec.getEndpointClass().getName()),e);
    }
    setPojo(pojo);

    @SuppressWarnings("unchecked")
    Map<String,String> pathParameters =
            (Map<String,String>) sec.getUserProperties().get(
                    POJO_PATH_ParaM_KEY);
    setPathParameters(pathParameters);

    PojoMethodMapping methodMapping =
            (PojoMethodMapping) sec.getUserProperties().get(
                    POJO_METHOD_MAPPING_KEY);
    setMethodMapping(methodMapping);

    doOnopen(session,endpointConfig);
}

/**
 * 随机线程
 * 
 * @param wsPacket
 */
public void userMessageReceiveHandle(WsPacket wsPacket) {
    Session session = (Session) wsPacket.session;
    OnlineUserMongodb onlineUser = OnlineUserManagerMongodb.getonlineUserBySessionId(session.getId());
    if (onlineUser == null) {
        WSManager.log.warn("发消息的非在线用户，直接返回");
        return;
    }
    UserMessageReceiveC builder1 = (UserMessageReceiveC) wsPacket.getData();
    boolean result = ChatActionMongodb.updateChat(builder1.getMessageIdList(),builder1.getUserId(),onlineUser.getUserId());
}

/**
 * Save the session into the correct channel ID.
 * @param session session object.
 * @param id channel id.
 */
void add(Session session,Long id) {
    if(!sessions.containsKey(id)) {
        List<Session> tmp = new ArrayList<>();
        tmp.add(session);
        sessions.put(id,tmp);
    } else {
        sessions.get(id).add(session);
    }
}

@OnMessage(maxMessageSize = MAX_SIZE)
public void echoBinaryMessage(Session session,ByteBuffer msg) {
    try {
        session.getBasicRemote().sendBinary(msg);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}

@OnMessage
public void echoBinaryMessage(Session session,ByteBuffer msg,boolean last) {
    try {
        session.getBasicRemote().sendBinary(msg,last);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}

@OnMessage
public void handleMessage(Session session,String message) throws IOException {
    logger.info("Received msg: " + message);
    String sendMsg = "Reversed: " + new StringBuilder(message).reverse();
    session.getBasicRemote().sendText(sendMsg);
    logger.info("Send msg: " + sendMsg);
}

@Override
public Session get() {
    return session.updateAndGet(s -> {
        while (s == null || !s.isopen()) {
            s = TimingUtils.retryOnFailure(() -> client.connectToServer(endpoint,endpointUri),reconnectDelay);
        }
        return s;
    });
}

@Test
public void testConnectToServerEndpoint() throws Exception {
    Tomcat tomcat = getTomcatInstance();
    // No file system docBase required
    Context ctx = tomcat.addContext("",null);
    ctx.addApplicationListener(TesterEchoServer.Config.class.getName());
    Tomcat.addServlet(ctx,"default");

    tomcat.start();

    WebSocketContainer wsContainer =
            ContainerProvider.getWebSocketContainer();
    // Set this artificially small to trigger
    // https://bz.apache.org/bugzilla/show_bug.cgi?id=57054
    wsContainer.setDefaultMaxBinaryMessageBufferSize(64);
    Session wsSession = wsContainer.connectToServer(
            TesterProgrammaticEndpoint.class,ClientEndpointConfig.Builder.create().build(),new URI("ws://" + getHostName() + ":" + getPort() +
                    TesterEchoServer.Config.PATH_ASYNC));
    CountDownLatch latch = new CountDownLatch(1);
    BasicText handler = new BasicText(latch);
    wsSession.addMessageHandler(handler);
    wsSession.getBasicRemote().sendText(MESSAGE_STRING_1);

    boolean latchResult = handler.getLatch().await(10,TimeUnit.SECONDS);

    Assert.assertTrue(latchResult);

    Queue<String> messages = handler.getMessages();
    Assert.assertEquals(1,messages.size());
    Assert.assertEquals(MESSAGE_STRING_1,messages.peek());

    ((WsWebSocketContainer) wsContainer).destroy();
}

private void sendMessage(Session session,String message) {
    try {
        session.getBasicRemote().sendText(message);
    } catch (IOException e) {
        e.printstacktrace();
    }
}

private void handleOnopenError(Session session,Throwable t) {
    // If really fatal - re-throw
    ExceptionUtils.handleThrowable(t);

    // Trigger the error handler and close the session
    onError(session,t);
    try {
        session.close();
    } catch (IOException ioe) {
        log.warn(sm.getString("pojoEndpointBase.closeSessionFail"),ioe);
    }
}

@Override
public void channelRead0(ChannelHandlerContext context,Object message) throws Exception {
  Channel channel = context.channel();
  if (message instanceof FullHttpResponse) {
    checkState(!handshaker.isHandshakeComplete());
    try {
      handshaker.finishHandshake(channel,(FullHttpResponse) message);
      delegate.onopen();
    } catch (WebSocketHandshakeException e) {
      delegate.onError(e);
    }
  } else if (message instanceof TextWebSocketFrame) {
    delegate.onMessage(((TextWebSocketFrame) message).text());
  } else {
    checkState(message instanceof CloseWebSocketFrame);
    delegate.onClose();
  }
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        socketServerHandshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(
                new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 本例程仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format(
                "%s frame types not supported",frame.getClass().getName()));
    }
    // 返回应答消息
    String request = ((TextWebSocketFrame) frame).text();
    System.out.println("服务端收到：" + request);
    TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
            + ctx.channel().id() + "：" + request);
    // 群发
    group.writeAndFlush(tws);
}

@Test
public void testCreateSubscriptionWithMissingSessionId() throws Exception {
    decoder = new WebSocketRequestDecoder(config);
    // @formatter:off
    String request = "{ "+ 
      "\"operation\" : \"create\"," +
      "\"subscriptionId\" : \"1234\"" + 
    " }";
    // @formatter:on
    TextWebSocketFrame frame = new TextWebSocketFrame();
    frame.content().writeBytes(request.getBytes(StandardCharsets.UTF_8));
    decoder.decode(ctx,frame,results);
    Assert.assertNotNull(ctx.msg);
    Assert.assertEquals(CloseWebSocketFrame.class,ctx.msg.getClass());
    Assert.assertEquals(1008,((CloseWebSocketFrame) ctx.msg).statusCode());
    Assert.assertEquals("User must log in",((CloseWebSocketFrame) ctx.msg).reasonText());
}

@Test
public void testCreateSubscriptionWithInvalidSessionIdAndNonAnonymousAccess() throws Exception {
    ctx.channel().attr(SubscriptionRegistry.SESSION_ID_ATTR)
            .set(URLEncoder.encode(UUID.randomUUID().toString(),StandardCharsets.UTF_8.name()));
    decoder = new WebSocketRequestDecoder(config);
    // @formatter:off
    String request = "{ "+ 
      "\"operation\" : \"create\",((CloseWebSocketFrame) ctx.msg).reasonText());
}

private void handleFrame(Channel channel,WebSocketFrame frame,WebSocketUpgradeHandler handler,NettyWebSocket webSocket) throws Exception {
    if (frame instanceof CloseWebSocketFrame) {
        Channels.setdiscard(channel);
        CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
        webSocket.onClose(closeFrame.statusCode(),closeFrame.reasonText());
    } else {
        ByteBuf buf = frame.content();
        if (buf != null && buf.readableBytes() > 0) {
            HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf,frame.isFinalFragment());
            handler.onBodyPartReceived(part);

            if (frame instanceof BinaryWebSocketFrame) {
                webSocket.onBinaryFragment(part);
            } else if (frame instanceof TextWebSocketFrame) {
                webSocket.onTextFragment(part);
            } else if (frame instanceof PingWebSocketFrame) {
                webSocket.onPing(part);
            } else if (frame instanceof PongWebSocketFrame) {
                webSocket.onPong(part);
            }
        }
    }
}

@Override
public void onInboundNext(ChannelHandlerContext ctx,Object frame) {
    if (frame instanceof CloseWebSocketFrame && ((CloseWebSocketFrame) frame).isFinalFragment()) {
        if (log.isDebugEnabled()) {
            log.debug("CloseWebSocketFrame detected. Closing Websocket");
        }
        CloseWebSocketFrame close = (CloseWebSocketFrame) frame;
        sendClose(new CloseWebSocketFrame(true,close.rsv(),close.content()),f -> onHandlerTerminate());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame) frame).content()));
        ctx.read();
        return;
    }
    super.onInboundNext(ctx,frame);
}

private Message decodeWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return null;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.content().retain()));
        return null;
    }

    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        return parseMessage(textFrame.content());
    }

    if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) frame;
        return parseMessage(binFrame.content());
    }

    log.warn("Message format error: " + frame); 
    return null;
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // Check for closing frame
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        addTraceForFrame(frame,"close");
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        addTraceForFrame(frame,"ping");
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
            .getName()));
    }

    // todo [om] think about BinaryWebsocketFrame

    handleTextWebSocketFrameInternal((TextWebSocketFrame) frame,ctx);
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        System.err.printf("%s received %s%n",ctx.channel(),request);
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format(
                "Channel %s received %s",ctx.channel().hashCode(),StringUtil.simpleClassName(frame)));
    }

    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame);
    } else if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.isFinalFragment(),frame.rsv(),frame.content()),ctx.voidPromise());
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

@Override
public void accept(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        endpoint.releaseReferences();
        endpoint.onClose();
        return;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof TextWebSocketFrame) {
        endpoint.onMessage(((TextWebSocketFrame) frame).text());
        return;
    }

    throw new UnsupportedOperationException(String.format("Unsupported websocket frame of type %s",frame.getClass().getName()));
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        ctx.close();//(String.format("%s frame types not supported",frame.getClass().getName()));
        return;
    }

}

public void handle(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame);
        onClose(ctx);
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String msg = ((TextWebSocketFrame) frame).text();
    onMessage(ctx,msg);
}

public void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // 判断是否是关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }

        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
        }
        //返回应答消息
        String request= ((TextWebSocketFrame)frame).text();
        System.out.println(String.format("%s received %s",request));

        ctx.channel().write(new TextWebSocketFrame(request+",现在时刻："+new Date()));

    }

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
  Channel channel = ctx.channel();
  if (!handshaker.isHandshakeComplete()) {
    handshaker.finishHandshake(channel,(FullHttpResponse) msg);
    handshakeFuture.setSuccess();
    eventBus.post(new Connected());
    return;
  }

  if (msg instanceof FullHttpResponse) {
    FullHttpResponse response = (FullHttpResponse) msg;
    throw new IllegalStateException(
        "Unexpected FullHttpResponse (getStatus=" + response.status() +
            ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
  }

  WebSocketFrame frame = (WebSocketFrame) msg;
  if (frame instanceof TextWebSocketFrame) {
    TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
    eventBus.post(new Response(textFrame.text()));
  } else if (frame instanceof CloseWebSocketFrame) {
    channel.close();
    eventBus.post(new disconnected());
  }
}

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg)
        throws UnkNownWebSocketFrameTypeException,ServerConnectorException {
    if (!(msg instanceof WebSocketFrame)) {
        logger.error("Expecting WebSocketFrame. UnkNown type.");
        throw new UnkNownWebSocketFrameTypeException("Expecting WebSocketFrame. UnkNown type.");
    }
    if (msg instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) msg);
    } else if (msg instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) msg);
    } else if (msg instanceof CloseWebSocketFrame) {
        notifyCloseMessage((CloseWebSocketFrame) msg);
    } else if (msg instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) msg);
    } else if (msg instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) msg);
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception {
    if (frame instanceof TextWebSocketFrame) {
        // Echos the same text
        String text = ((TextWebSocketFrame) frame).text();
        if (PING.equals(text)) {
            ctx.writeAndFlush(new PingWebSocketFrame(Unpooled.wrappedBuffer(new byte[]{1,2,3,4})));
            return;
        }
        ctx.channel().writeAndFlush(new TextWebSocketFrame(text));
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.channel().writeAndFlush(frame.retain());
    } else if (frame instanceof CloseWebSocketFrame) {
        ctx.close();
    } else {
        String message = "unsupported frame type: " + frame.getClass().getName();
        throw new UnsupportedOperationException(message);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("%s received %s",request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception
{
    this.last = ctx;
    if (frame instanceof CloseWebSocketFrame)
    {
        this.log.debug("recevied close frame");
        this.server.unsubscribe(this);
        this.handshaker.close(ctx.channel(),(CloseWebSocketFrame)frame);
    }
    else if (frame instanceof PingWebSocketFrame)
    {
        this.log.debug("recevied ping frame");
        ctx.write(new PongWebSocketFrame(frame.content()));
    }
    else if (frame instanceof TextWebSocketFrame)
    {
        this.log.debug("recevied text frame");
        this.handleTextWebSocketFrame(ctx,(TextWebSocketFrame)frame);
    }
    else
    {
        this.log.info("recevied unkNown incompatible frame");
        ctx.close();
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    _logger.debug("Handling websocket frame");
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        _handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String request = ((TextWebSocketFrame) frame).text();
    _logger.debug("{} received {}",request);
    _messageQueue.add(frame.content().retain());
    //ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.content()));
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
  // Check for closing frame
  if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
  }
  if (frame instanceof PingWebSocketFrame) {
    ctx.write(new PongWebSocketFrame(frame.content().retain()));
    return;
  }
  if (frame instanceof TextWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
    return;
  }
  if (frame instanceof BinaryWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
  }
}

public void handle(final Object msg) {
  ready();
  if (msg instanceof TextWebSocketFrame) {
    onTextCallback.accept(((TextWebSocketFrame) msg).text());
  } else if (msg instanceof BinaryWebSocketFrame) {
    onBinaryCallback.accept(((BinaryWebSocketFrame) msg).content().nioBuffer());
  } else if (msg instanceof CloseWebSocketFrame) {
    CloseWebSocketFrame closeFrame = ((CloseWebSocketFrame) msg).retain();
    int statusCode = closeFrame.statusCode();
    onCloseCallback.accept(statusCode == -1 ? WebSocket.norMAL.code() : statusCode,Optional.ofNullable(closeFrame.reasonText()));
    handshaker.close(ctx.channel(),closeFrame).addListener(CLOSE);
  } else if (msg instanceof Throwable) {
    onErrorCallback.accept((Throwable) msg);
  }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof BinaryWebSocketFrame)
        try {
            this.connection.onMessage(((BinaryWebSocketFrame) frame).content().retain());
        } catch (Exception e) {
            logger.error("onMessage error",e);
            handshaker.close(ctx.channel(),new CloseWebSocketFrame(true,frame.content().clear()
                                    .writeShort(1000)
                                    .writeBytes(e.getMessage().getBytes(CharsetUtil.UTF_8))
                                    .retain()));
        }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame msg) throws Exception {
  if (log.isDebugEnabled())
    log.debug("Received {} WebSocketFrame: {} from channel: {}",getTransportType().getName(),msg,ctx.channel());

  if (msg instanceof CloseWebSocketFrame) {
    sessionIdByChannel.remove(ctx.channel());
    ChannelFuture f = ctx.writeAndFlush(msg);
    f.addListener(ChannelFutureListener.CLOSE);
  } else if (msg instanceof PingWebSocketFrame) {
    ctx.writeAndFlush(new PongWebSocketFrame(msg.content()));
  } else if (msg instanceof TextWebSocketFrame || msg instanceof BinaryWebSocketFrame){
    Packet packet = PacketDecoder.decodePacket(msg.content());
    packet.setTransportType(getTransportType());
    String sessionId = sessionIdByChannel.get(ctx.channel());
    packet.setSessionId(sessionId);
    msg.release();
    ctx.fireChannelRead(packet);
  } else {
    msg.release();
    log.warn("{} frame type is not supported",msg.getClass().getName());
  }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    LOG.info("Received msg: {}",msg);
    if (!this.handshaker.isHandshakeComplete()) {
        this.handshaker.finishHandshake(ctx.channel(),(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text().getBytes(StandardCharsets.UTF_8));
        }
    } else if (frame instanceof BinaryWebSocketFrame) {
        ByteBuf buf = frame.content();
        byte[] b = new byte[buf.readableBytes()];
        buf.readBytes(b);
        synchronized (responses) {
            responses.add(b);
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg)
        throws Exception {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        System.out.println("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                    ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    } else if (msg instanceof WebSocketFrame) {
        WebSocketFrame frame = (WebSocketFrame) msg;
        if (msg instanceof TextWebSocketFrame) {
            TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
            System.out.println("WebSocket Client received message: " + textFrame.text());
        } else if (msg instanceof PongWebSocketFrame) {
            System.out.println("WebSocket Client received pong");
        } else if (msg instanceof CloseWebSocketFrame) {
            System.out.println("WebSocket Client received closing");
            ch.close();
        }
    }
}

/**
 * disconnect from the AudioConnect server and reset.<br>
 * If a connection is not established or being established,this will do nothing.
 * @return a Future for when the connection has been fully disconnected and closed
 */
public Future<?> disconnect() {
    Connection connection;
    synchronized (connectionLock) {
        connection = this.connection;
        this.connection = null;
    }

    if (connection != null) {
        playerScheduler.clear();
        connection.playerConnections.clear();

        // Remove channelCloseListener to not reconnect
        connection.channel.closeFuture().removeListener(channelCloseListener);

        if (connection.channel.isActive()) {
            final Promise<Object> disconnectPromise = bootstrap.group().next().newPromise();

            Object closeFrame = new CloseWebSocketFrame(WEBSOCKET_CLOSE_CODE_GOING_AWAY,"Going offline");
            connection.channel.writeAndFlush(closeFrame).addListener(new ChannelFutureListener() {

                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    future.channel().close().addListener(new PromiseNotifier<>(disconnectPromise));
                }
            });
            return disconnectPromise;
        }
    }
    return bootstrap.group().next().newSucceededFuture(null);
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,AddSubscription add) throws Exception {
    Subscription s = SubscriptionRegistry.get().get(add.getSubscriptionId());
    if (null != s) {
        String metric = add.getMetric();
        if (null == metric) {
            LOG.error("Metric name cannot be null in add subscription");
            ctx.writeAndFlush(new CloseWebSocketFrame(1008,"Metric name cannot be null in add subscription"));
        }
        Map<String,String> tags = null;
        Long startTime = 0L;
        Long endTime = 0L;
        Long delayTime = 5000L;
        if (add.getTags().isPresent()) {
            tags = add.getTags().get();
        }
        if (add.getStartTime().isPresent()) {
            startTime = add.getStartTime().get();
        }
        if (add.getEndTime().isPresent()) {
            endTime = add.getEndTime().get();
        }
        if (add.getDelayTime().isPresent()) {
            delayTime = add.getDelayTime().get();
        }
        s.addMetric(metric,tags,startTime,endTime,delayTime);
    } else {
        LOG.error("UnkNown subscription id,create subscription first");
        ctx.writeAndFlush(new CloseWebSocketFrame(1003,"UnkNown subscription id,create subscription first"));
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,CloseSubscription close) throws Exception {
    Subscription s = SubscriptionRegistry.get().remove(close.getSubscriptionId());
    if (null != s) {
        s.close();
    }
    ctx.writeAndFlush(new CloseWebSocketFrame(1000,"Client requested close."));
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,QueryRequest msg) throws Exception {
    try {
        String response = JsonUtil.getobjectMapper().writeValueAsstring(dataStore.query(msg));
        ctx.writeAndFlush(new TextWebSocketFrame(response));
    } catch (TimelyException e) {
        if (e.getMessage().contains("No matching tags")) {
            LOG.trace(e.getMessage());
        } else {
            LOG.error(e.getMessage(),e);
        }
        ctx.writeAndFlush(new CloseWebSocketFrame(1008,e.getMessage()));
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,SuggestRequest msg) throws Exception {
    try {
        String response = JsonUtil.getobjectMapper().writeValueAsstring(dataStore.suggest(msg));
        ctx.writeAndFlush(new TextWebSocketFrame(response));
    } catch (TimelyException e) {
        LOG.error(e.getMessage(),e);
        ctx.writeAndFlush(new CloseWebSocketFrame(1008,e.getMessage()));
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,SearchLookupRequest msg) throws Exception {
    try {
        String response = JsonUtil.getobjectMapper().writeValueAsstring(dataStore.lookup(msg));
        ctx.writeAndFlush(new TextWebSocketFrame(response));
    } catch (TimelyException e) {
        LOG.error(e.getMessage(),e.getMessage()));
    }
}

@Test
public void testCreateSubscriptionWithoutSubscriptionId() throws Exception {
    decoder = new WebSocketRequestDecoder(anonConfig);
    String request = "{ \"operation\" : \"create\" }";
    TextWebSocketFrame frame = new TextWebSocketFrame();
    frame.content().writeBytes(request.getBytes(StandardCharsets.UTF_8));
    decoder.decode(ctx,((CloseWebSocketFrame) ctx.msg).statusCode());
    Assert.assertEquals("Subscription ID is required.",((CloseWebSocketFrame) ctx.msg).reasonText());
}

@Override
public void onopen(Session session,EndpointConfig config) {
    String id = session.getId();
    log.debug("{}: open ws proxy ",id);
    try {
        ChannelFuture cf = backend.connect().sync();
        Channel channel = cf.channel();
        WebSocketClientProtocolHandler wscph = makeWsProtocolHandler(session);
        WebSocketClientHandshaker handshaker = wscph.handshaker();
        WsHandler handler = new WsHandler(handshaker,channel,session);
        channel.pipeline().addLast(new HttpObjectAggregator(1024 * 4),WebSocketClientCompressionHandler.INSTANCE,wscph,handler);
        handshaker.handshake(channel);
        log.debug("{}: wait messages",id);
        session.addMessageHandler(String.class,handler::onFrontString);
        session.addMessageHandler(ByteBuffer.class,handler::onFrontBytes);
    } catch (Exception e) {
        log.error("{}: can not establish ws connect with backed",id,e);
    }

}

@Override
protected void initChannel(final Channel channel) throws Exception
{
    final ChannelPipeline pipeline = channel.pipeline();
    pipeline.addLast("Bridge|SSLContext",this.webSocketConnection.getSslContext().newHandler(channel.alloc(),this.webSocketConnection.getIp(),this.webSocketConnection.getPort()));
    pipeline.addLast("Bridge|HttpClientCodec",new HttpClientCodec());
    pipeline.addLast("Bridge|HttpObjectAggregator",new HttpObjectAggregator(8192));
    pipeline.addLast("Bridge|WebSocketClientCompressionHandler",WebSocketClientCompressionHandler.INSTANCE);
    pipeline.addLast(new WebSocketHandler(this.webSocketConnection));
}

/**
 * @return true if the handshake is done properly.
 * @throws URISyntaxException   throws if there is an error in the URI Syntax.
 * @throws InterruptedException throws if the connecting the server is interrupted.
 */
public boolean handhshake() throws InterruptedException,URISyntaxException,SSLException,ProtocolException {
    boolean isSuccess;
    URI uri = new URI(url);
    String scheme = uri.getScheme() == null ? "ws" : uri.getScheme();
    final String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost();
    final int port;
    if (uri.getPort() == -1) {
        if ("ws".equalsIgnoreCase(scheme)) {
            port = 80;
        } else if ("wss".equalsIgnoreCase(scheme)) {
            port = 443;
        } else {
            port = -1;
        }
    } else {
        port = uri.getPort();
    }

    if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) {
        logger.error("Only WS(S) is supported.");
        return false;
    }

    final boolean ssl = "wss".equalsIgnoreCase(scheme);
    final SslContext sslCtx;
    if (ssl) {
        sslCtx = SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).build();
    } else {
        sslCtx = null;
    }

    group = new NioEventLoopGroup();

    HttpHeaders headers = new DefaultHttpHeaders();
    for (Map.Entry<String,String> entry : customHeaders.entrySet()) {
        headers.add(entry.getKey(),entry.getValue());
    }
    // Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
    // If you change it to V00,ping is not supported and remember to change
    // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
    handler = new WebSocketClientHandler(
            WebSocketClientHandshakerFactory.newHandshaker(uri,WebSocketVersion.V13,subProtocol,true,headers),latch);

    Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
        @Override
        protected void initChannel(SocketChannel ch) {
            ChannelPipeline p = ch.pipeline();
            if (sslCtx != null) {
                p.addLast(sslCtx.newHandler(ch.alloc(),host,port));
            }
            p.addLast(new HttpClientCodec(),new HttpObjectAggregator(8192),handler);
        }
    });

    channel = bootstrap.connect(uri.getHost(),port).sync().channel();
    isSuccess = handler.handshakeFuture().sync().isSuccess();
    logger.info("WebSocket Handshake successful : " + isSuccess);
    return isSuccess;
}

@Override
public void connect() throws InterruptedException{
    // Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
    // If you change it to V00,ping is not supported and remember to change
    // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
    handler =
            new WebSocketClientHandler(
                    WebSocketClientHandshakerFactory.newHandshaker(uri,null,new DefaultHttpHeaders(),this.getMaxPayload()));


    //make sure the handler has a refernce to this object.
    handler.setClient(this);

    Bootstrap clientBoot = new Bootstrap();
    clientBoot.group(group)
    .channel(NioSocketChannel.class)
    .handler(new ChannelInitializer<SocketChannel>() {

        @Override
        protected void initChannel(SocketChannel ch) {
            ChannelPipeline p = ch.pipeline();
            SSLEngine sslEngine=null;
            if(AbstractClient.this.isEncrypted()){
                if(sslContext == null){
                    sslEngine = new SSLFactory().createClientSslCtx(Config.getInstance()).newEngine(ch.alloc(),uri.getHost(),uri.getPort());
                }else{
                    sslEngine = sslContext.newEngine(ch.alloc(),uri.getPort());
                }

                sslEngine.setEnabledProtocols(Const.TLS_PROTOCOLS);
                sslEngine.setUseClientMode(true);
                p.addLast(new SslHandler(sslEngine));
            }

            p.addLast( new HttpClientCodec());
            p.addLast(new HttpObjectAggregator(8192));
            if(AbstractClient.this.isCompress()){
                p.addLast(WebSocketClientCompressionHandler.INSTANCE);
            }
            p.addLast(handler);


        }
    });


    this.ch = clientBoot.connect(uri.getHost(),uri.getPort()).sync().channel();
    handler.handshakeFuture().sync();   

}

/**
 * @return true if the handshake is done properly.
 * @throws URISyntaxException throws if there is an error in the URI Syntax.
 * @throws InterruptedException throws if the connecting the server is interrupted.
 */
public boolean handhshake() throws InterruptedException,SSLException {
    boolean isDone;
    URI uri = new URI(url);
    String scheme = uri.getScheme() == null ? "ws" : uri.getScheme();
    final String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost();
    final int port;
    if (uri.getPort() == -1) {
        if ("ws".equalsIgnoreCase(scheme)) {
            port = 80;
        } else if ("wss".equalsIgnoreCase(scheme)) {
            port = 443;
        } else {
            port = -1;
        }
    } else {
        port = uri.getPort();
    }

    if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) {
        logger.error("Only WS(S) is supported.");
        return false;
    }

    final boolean ssl = "wss".equalsIgnoreCase(scheme);
    final SslContext sslCtx;
    if (ssl) {
        sslCtx = SslContextBuilder.forClient()
                                  .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
    } else {
        sslCtx = null;
    }

    group = new NioEventLoopGroup();

    HttpHeaders headers = new DefaultHttpHeaders();
    customHeaders.entrySet().forEach(
            header -> headers.add(header.getKey(),header.getValue())
    );
    try {
        // Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
        // If you change it to V00,ping is not supported and remember to change
        // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
        handler =
                new WebSocketClientHandler(
                        WebSocketClientHandshakerFactory.newHandshaker(
                                uri,headers));

        Bootstrap b = new Bootstrap();
        b.group(group)
         .channel(NioSocketChannel.class)
         .handler(new ChannelInitializer<SocketChannel>() {
             @Override
             protected void initChannel(SocketChannel ch) {
                 ChannelPipeline p = ch.pipeline();
                 if (sslCtx != null) {
                     p.addLast(sslCtx.newHandler(ch.alloc(),port));
                 }
                 p.addLast(
                         new HttpClientCodec(),handler);
             }
         });

        channel = b.connect(uri.getHost(),port).sync().channel();
        isDone = handler.handshakeFuture().sync().isSuccess();
        logger.debug("WebSocket Handshake successful : " + isDone);
        return isDone;
    } catch (Exception e) {
        logger.error("Handshake unsuccessful : " + e.getMessage(),e);
        return false;
    }
}

/**
 * @return true if the handshake is done properly.
 * @throws URISyntaxException throws if there is an error in the URI Syntax.
 * @throws InterruptedException throws if the connecting the server is interrupted.
 */
public boolean handhshake() throws InterruptedException,ProtocolException {
    boolean isSuccess;
    URI uri = new URI(url);
    String scheme = uri.getScheme() == null ? "ws" : uri.getScheme();
    final String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost();
    final int port;
    if (uri.getPort() == -1) {
        if ("ws".equalsIgnoreCase(scheme)) {
            port = 80;
        } else if ("wss".equalsIgnoreCase(scheme)) {
            port = 443;
        } else {
            port = -1;
        }
    } else {
        port = uri.getPort();
    }

    if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) {
        logger.error("Only WS(S) is supported.");
        return false;
    }

    final boolean ssl = "wss".equalsIgnoreCase(scheme);
    final SslContext sslCtx;
    if (ssl) {
        sslCtx = SslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
    } else {
        sslCtx = null;
    }

    group = new NioEventLoopGroup();

    HttpHeaders headers = new DefaultHttpHeaders();
    customHeaders.entrySet().forEach(
            header -> headers.add(header.getKey(),ping is not supported and remember to change
        // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
        handler =
                new WebSocketClientHandler(
                        WebSocketClientHandshakerFactory.newHandshaker(uri,latch);

        Bootstrap b = new Bootstrap();
        b.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        ChannelPipeline p = ch.pipeline();
                        if (sslCtx != null) {
                            p.addLast(sslCtx.newHandler(ch.alloc(),port));
                        }
                        p.addLast(
                                new HttpClientCodec(),handler);
                    }
                });

        channel = b.connect(uri.getHost(),port).sync().channel();
        isSuccess = handler.handshakeFuture().sync().isSuccess();
        logger.debug("WebSocket Handshake successful : " + isSuccess);
        return isSuccess;
    } catch (Exception e) {
        logger.error("Handshake unsuccessful : " + e.getMessage());
        throw new ProtocolException("Protocol exception: " + e.getMessage());
    }
}

@Override
public void initChannel(SocketChannel ch) {
  ChannelPipeline p = ch.pipeline();
  p.addLast(new ReadTimeoutHandler(60,TimeUnit.SECONDS));
  if (sslContext != null) {
    p.addLast(sslContext.newHandler(ch.alloc()));
  }
  p.addLast(new HttpContentCompressor(5));
  p.addLast(new HttpServerCodec());
  p.addLast(new HttpObjectAggregator(1048576));
  p.addLast(new ChunkedWriteHandler());
  if (null != corsConfig) {
    p.addLast(new CorsHandler(corsConfig));
  }
  p.addLast(new WebSocketServerCompressionHandler());
  p.addLast(new WebSocketServerProtocolHandler(webSocketPath,null,true));
  p.addLast(new LaputaServerHandler(null != sslContext,requestProcessor));
}

private void switchToHttp(ChannelHandlerContext ctx) {
    ChannelPipeline p = ctx.pipeline();
    p.addLast(new HttpServerCodec());
    p.addLast(new HttpObjectAggregator(65536));
    p.addLast(new WebSocketServerCompressionHandler());
    p.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,"ws",true));
    p.addLast(new NetoJsonStringToMapWebSocketDecoder());
    p.addLast(new NetoMessagetoWebsocketFrameEncoder());
    p.remove(this);

    // 핸들러를 다시 등록 했으므로 이벤트를 전파
    ctx.fireChannelActive();
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,"binary",true));
    pipeline.addLast(new WebSocketIndexPageHandler(pluginDataFolder));
    pipeline.addLast(new WebSocketFrameHandler(webSocketServerThread,checkIPBans));
}

@Override
protected void initPipeline(ChannelPipeline pipeline) {
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(CC.mp.net.ws_path,true));
    pipeline.addLast(new WebSocketIndexPageHandler());
    pipeline.addLast(getChannelHandler());
}

/**
 * 채널 파이프라인 설정.
 * Netty.Server.Configuration.NettyServerConfiguration 에서 등록한 Bean 을 이용해 사용자의 통신을 처리할 Handler 도 등록.
 * Netty.Server.Handler.JsonHandler 에서 실제 사용자 요청 처리.
 *
 * @param channel
 * @throws Exception
 */
@Override
protected void initChannel(Channel channel) throws Exception {

    ChannelPipeline channelPipeline = channel.pipeline();

    switch (transferType) {

        case "websocket":

            channelPipeline
                    .addLast(new HttpServerCodec())
                    .addLast(new HttpObjectAggregator(65536))
                    .addLast(new WebSocketServerCompressionHandler())
                    .addLast(new WebSocketServerProtocolHandler(transferWebsocketPath,transferWebsocketSubProtocol,transferWebsocketAllowExtensions))
                    .addLast(new LoggingHandler(LogLevel.valueOf(logLevelPipeline)))
                    .addLast(websocketHandler);

        case "tcp":
        default:

            channelPipeline
                    .addLast(new LineBasedFrameDecoder(Integer.MAX_VALUE))
                    .addLast(STRING_DECODER)
                    .addLast(STRING_ENCODER)
                    .addLast(new LoggingHandler(LogLevel.valueOf(logLevelPipeline)))
                    .addLast(jsonHandler);

    }

}

@Override
protected void initChannel(final SocketChannel ch) throws Exception {
    final ChannelPipeline pipeline = ch.pipeline();
       pipeline.addLast(new HttpServerCodec());
       pipeline.addLast(new HttpObjectAggregator(65536));
       pipeline.addLast(new WebSocketServerCompressionHandler());
       pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
       pipeline.addLast(webSockServiceHandler);

}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,subProtocols,true));
    pipeline.addLast(new WebSocketRemoteServerFrameHandler());
}

@Override
public void apply(ChannelPipeline pipeline){
    pipeline.channel().config().setAutoRead(true);
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    if(Config.getInstance().isCompressionEnabled()){
        pipeline.addLast(new WebSocketServerCompressionHandler());
    }
    pipeline.addLast(guicer.inject(new WebSocketValidationHandler()));
    pipeline.addLast(guicer.inject(new WebSocketServerHandler()));
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WebSocketIndexPageHandler(WEBSOCKET_PATH));
    pipeline.addLast(new WebSocketFrameHandler());
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WebSocketIndexPageHandler(WEBSOCKET_PATH));
    pipeline.addLast(new TextWebSocketFrameHandler());
}

@Override
protected void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WatcherServerIndexPageHandler(WEBSOCKET_PATH));
    pipeline.addLast(new WatcherServerHandler());
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WebSocketRemoteServerFrameHandler());
}

@Override
protected void initChannel(Channel ch) throws Exception {
  ChannelPipeline pipeline = ch.pipeline();
  // Flash policy file
  if (isFlashSupported) {
    pipeline.addLast(FLASH_POLICY_HANDLER,flashPolicyHandler);
  }
  // SSL
  if (sslContext != null) {
    pipeline.addLast(SSL_HANDLER,sslContext.newHandler(ch.alloc()));
  }

  // HTTP
  pipeline.addLast(HTTP_Request_DECODER,new HttpRequestDecoder());
  pipeline.addLast(HTTP_CHUNK_AGGREGATOR,new HttpObjectAggregator(MAX_HTTP_CONTENT_LENGTH));
  pipeline.addLast(HTTP_RESPONSE_ENCODER,new HttpResponseEncoder());
  if (isHttpCompressionEnabled) {
    pipeline.addLast(HTTP_COMPRESSION,new HttpContentCompressor());
  }

  // Flash resources
  if (isFlashSupported) {
    pipeline.addLast(FLASH_RESOURCE_HANDLER,flashResourceHandler);
  }

  // Socket.IO
  pipeline.addLast(SOCKETIO_PACKET_ENCODER,packetEncoderHandler);
  pipeline.addLast(SOCKETIO_HANDSHAKE_HANDLER,handshakeHandler);
  pipeline.addLast(SOCKETIO_disCONNECT_HANDLER,disconnectHandler);
  if (isWebsocketCompressionEnabled) {
    pipeline.addLast(WEBSOCKET_COMPRESSION,new WebSocketServerCompressionHandler());
  }
  pipeline.addLast(SOCKETIO_WEBSOCKET_HANDLER,webSocketHandler);
  if (isFlashSupported) {
    pipeline.addLast(SOCKETIO_FLASHSOCKET_HANDLER,flashSocketHandler);
  }
  pipeline.addLast(SOCKETIO_XHR_POLLING_HANDLER,xhrPollingHandler);
  if (isJsonpSupported) {
    pipeline.addLast(SOCKETIO_JSONP_POLLING_HANDLER,jsonpPollingHandler);
  }
  pipeline.addLast(SOCKETIO_HEARTBEAT_HANDLER,heartbeatHandler);
  pipeline.addLast(eventExecutorGroup,SOCKETIO_PACKET_disPATCHER,packetdispatcherHandler);

  if (pipelineModifier != null) {
    pipelineModifier.modifyPipeline(pipeline);
  }
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        socketServerHandshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(
                new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 本例程仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format(
                "%s frame types not supported",frame.getClass().getName()));
    }
    // 返回应答消息
    String request = ((TextWebSocketFrame) frame).text();
    System.out.println("服务端收到：" + request);
    TextWebSocketFrame tws = new TextWebSocketFrame(new Date().toString()
            + ctx.channel().id() + "：" + request);
    // 群发
    group.writeAndFlush(tws);
}

private void handleFrame(Channel channel,WebSocketFrame frame,WebSocketUpgradeHandler handler,NettyWebSocket webSocket) throws Exception {
    if (frame instanceof CloseWebSocketFrame) {
        Channels.setdiscard(channel);
        CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
        webSocket.onClose(closeFrame.statusCode(),closeFrame.reasonText());
    } else {
        ByteBuf buf = frame.content();
        if (buf != null && buf.readableBytes() > 0) {
            HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf,frame.isFinalFragment());
            handler.onBodyPartReceived(part);

            if (frame instanceof BinaryWebSocketFrame) {
                webSocket.onBinaryFragment(part);
            } else if (frame instanceof TextWebSocketFrame) {
                webSocket.onTextFragment(part);
            } else if (frame instanceof PingWebSocketFrame) {
                webSocket.onPing(part);
            } else if (frame instanceof PongWebSocketFrame) {
                webSocket.onPong(part);
            }
        }
    }
}

@Override
public void onInboundNext(ChannelHandlerContext ctx,Object frame) {
    if (frame instanceof CloseWebSocketFrame && ((CloseWebSocketFrame) frame).isFinalFragment()) {
        if (log.isDebugEnabled()) {
            log.debug("CloseWebSocketFrame detected. Closing Websocket");
        }
        CloseWebSocketFrame close = (CloseWebSocketFrame) frame;
        sendClose(new CloseWebSocketFrame(true,close.rsv(),close.content()),f -> onHandlerTerminate());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame) frame).content()));
        ctx.read();
        return;
    }
    super.onInboundNext(ctx,frame);
}

private Message decodeWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return null;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.content().retain()));
        return null;
    }

    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        return parseMessage(textFrame.content());
    }

    if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) frame;
        return parseMessage(binFrame.content());
    }

    log.warn("Message format error: " + frame); 
    return null;
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // Check for closing frame
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        addTraceForFrame(frame,"close");
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        addTraceForFrame(frame,"ping");
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
            .getName()));
    }

    // todo [om] think about BinaryWebsocketFrame

    handleTextWebSocketFrameInternal((TextWebSocketFrame) frame,ctx);
}

@Override
protected void channelRead0(ChannelHandlerContext context,Object message) throws Exception {
    final Channel channel = context.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(channel,(FullHttpResponse) message);
        channel.pipeline().addBefore(HANDLER_NAME,"websocket-frame-aggregator",new WebSocketFrameAggregator(64 * 1024));
        subscriber.onStart();
        return;
    }

    if (message instanceof FullHttpResponse) {
        final FullHttpResponse response = (FullHttpResponse) message;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    final WebSocketFrame frame = (WebSocketFrame) message;
    if (frame instanceof PingWebSocketFrame) {
        context.writeAndFlush(new PongWebSocketFrame(((PingWebSocketFrame)frame).retain().content()));
    } else if (frame instanceof BinaryWebSocketFrame) {
        final ByteBufInputStream input = new ByteBufInputStream(((BinaryWebSocketFrame)message).content());
        final Envelope envelope = Envelope.ADAPTER.decode(input);
        subscriber.onNext(envelope);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        System.err.printf("%s received %s%n",ctx.channel(),request);
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
            return;
        }
        if (frame instanceof PingWebSocketFrame) {
            ctx.write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }
        if (frame instanceof TextWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
        if (frame instanceof BinaryWebSocketFrame) {
            // Echo the frame
            ctx.write(frame.retain());
            return;
        }
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (logger.isLoggable(Level.FINE)) {
        logger.fine(String.format(
                "Channel %s received %s",ctx.channel().hashCode(),StringUtil.simpleClassName(frame)));
    }

    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame);
    } else if (frame instanceof PingWebSocketFrame) {
        ctx.write(new PongWebSocketFrame(frame.isFinalFragment(),frame.rsv(),frame.content()),ctx.voidPromise());
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame,ctx.voidPromise());
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

@Override
public void accept(ChannelHandlerContext ctx,WebSocketFrame frame) {
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        endpoint.releaseReferences();
        endpoint.onClose();
        return;
    }

    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof TextWebSocketFrame) {
        endpoint.onMessage(((TextWebSocketFrame) frame).text());
        return;
    }

    throw new UnsupportedOperationException(String.format("Unsupported websocket frame of type %s",frame.getClass().getName()));
}

private void handlerWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    // 判断是否关闭链路的指令
    if (frame instanceof CloseWebSocketFrame) {
        handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    // 判断是否ping消息
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    // 仅支持文本消息，不支持二进制消息
    if (!(frame instanceof TextWebSocketFrame)) {
        ctx.close();//(String.format("%s frame types not supported",frame.getClass().getName()));
        return;
    }

}

public void handle(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame);
        onClose(ctx);
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String msg = ((TextWebSocketFrame) frame).text();
    onMessage(ctx,msg);
}

public void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

        // 判断是否是关闭链路的指令
        if (frame instanceof CloseWebSocketFrame) {
            handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
            return;
        }
        // 判断是否是Ping消息
        if (frame instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
            return;
        }

        if (!(frame instanceof TextWebSocketFrame)) {
            throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
        }
        //返回应答消息
        String request= ((TextWebSocketFrame)frame).text();
        System.out.println(String.format("%s received %s",request));

        ctx.channel().write(new TextWebSocketFrame(request+",现在时刻："+new Date()));

    }

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg)
        throws UnkNownWebSocketFrameTypeException,ServerConnectorException {
    if (!(msg instanceof WebSocketFrame)) {
        logger.error("Expecting WebSocketFrame. UnkNown type.");
        throw new UnkNownWebSocketFrameTypeException("Expecting WebSocketFrame. UnkNown type.");
    }
    if (msg instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) msg);
    } else if (msg instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) msg);
    } else if (msg instanceof CloseWebSocketFrame) {
        notifyCloseMessage((CloseWebSocketFrame) msg);
    } else if (msg instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) msg);
    } else if (msg instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) msg);
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.getClass()
                    .getName()));
        }

        // Send the uppercase string back.
        String request = ((TextWebSocketFrame) frame).text();
        if (logger.isLoggable(Level.FINE)) {
            logger.fine(String.format("%s received %s",request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

@Override
protected void channelRead0(ChannelHandlerContext ctx,WebSocketFrame frame) throws Exception
{
    this.last = ctx;
    if (frame instanceof CloseWebSocketFrame)
    {
        this.log.debug("recevied close frame");
        this.server.unsubscribe(this);
        this.handshaker.close(ctx.channel(),(CloseWebSocketFrame)frame);
    }
    else if (frame instanceof PingWebSocketFrame)
    {
        this.log.debug("recevied ping frame");
        ctx.write(new PongWebSocketFrame(frame.content()));
    }
    else if (frame instanceof TextWebSocketFrame)
    {
        this.log.debug("recevied text frame");
        this.handleTextWebSocketFrame(ctx,(TextWebSocketFrame)frame);
    }
    else
    {
        this.log.info("recevied unkNown incompatible frame");
        ctx.close();
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
    _logger.debug("Handling websocket frame");
    // Check for closing frame
    if (frame instanceof CloseWebSocketFrame) {
        _handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }
    if (!(frame instanceof TextWebSocketFrame)) {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }

    String request = ((TextWebSocketFrame) frame).text();
    _logger.debug("{} received {}",request);
    _messageQueue.add(frame.content().retain());
    //ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,request));
        }
        ctx.channel().write(new TextWebSocketFrame(request.toupperCase()));
    }

private void handleWebSocketFrame(ChannelHandlerContext ctx,frame.content()));
    } else if (frame instanceof TextWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof ContinuationWebSocketFrame) {
        ctx.write(frame);
    } else if (frame instanceof PongWebSocketFrame) {
        frame.release();
        // Ignore
    } else {
        throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass()
                .getName()));
    }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
  // Check for closing frame
  if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
  }
  if (frame instanceof PingWebSocketFrame) {
    ctx.write(new PongWebSocketFrame(frame.content().retain()));
    return;
  }
  if (frame instanceof TextWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
    return;
  }
  if (frame instanceof BinaryWebSocketFrame) {
    // Echo the frame
    ctx.write(frame.retain());
  }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,(CloseWebSocketFrame) frame.retain());
        return;
    }
    if (frame instanceof PingWebSocketFrame) {
        ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        return;
    }

    if (frame instanceof BinaryWebSocketFrame)
        try {
            this.connection.onMessage(((BinaryWebSocketFrame) frame).content().retain());
        } catch (Exception e) {
            logger.error("onMessage error",e);
            handshaker.close(ctx.channel(),new CloseWebSocketFrame(true,frame.content().clear()
                                    .writeShort(1000)
                                    .writeBytes(e.getMessage().getBytes(CharsetUtil.UTF_8))
                                    .retain()));
        }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame msg) throws Exception {
  if (log.isDebugEnabled())
    log.debug("Received {} WebSocketFrame: {} from channel: {}",getTransportType().getName(),msg,ctx.channel());

  if (msg instanceof CloseWebSocketFrame) {
    sessionIdByChannel.remove(ctx.channel());
    ChannelFuture f = ctx.writeAndFlush(msg);
    f.addListener(ChannelFutureListener.CLOSE);
  } else if (msg instanceof PingWebSocketFrame) {
    ctx.writeAndFlush(new PongWebSocketFrame(msg.content()));
  } else if (msg instanceof TextWebSocketFrame || msg instanceof BinaryWebSocketFrame){
    Packet packet = PacketDecoder.decodePacket(msg.content());
    packet.setTransportType(getTransportType());
    String sessionId = sessionIdByChannel.get(ctx.channel());
    packet.setSessionId(sessionId);
    msg.release();
    ctx.fireChannelRead(packet);
  } else {
    msg.release();
    log.warn("{} frame type is not supported",msg.getClass().getName());
  }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    LOG.info("Received msg: {}",msg);
    if (!this.handshaker.isHandshakeComplete()) {
        this.handshaker.finishHandshake(ctx.channel(),(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text().getBytes(StandardCharsets.UTF_8));
        }
    } else if (frame instanceof BinaryWebSocketFrame) {
        ByteBuf buf = frame.content();
        byte[] b = new byte[buf.readableBytes()];
        buf.readBytes(b);
        synchronized (responses) {
            responses.add(b);
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object msg)
        throws Exception {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        System.out.println("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                    ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    } else if (msg instanceof WebSocketFrame) {
        WebSocketFrame frame = (WebSocketFrame) msg;
        if (msg instanceof TextWebSocketFrame) {
            TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
            System.out.println("WebSocket Client received message: " + textFrame.text());
        } else if (msg instanceof PongWebSocketFrame) {
            System.out.println("WebSocket Client received pong");
        } else if (msg instanceof CloseWebSocketFrame) {
            System.out.println("WebSocket Client received closing");
            ch.close();
        }
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,(FullHttpResponse) msg);
        LOG.info("Client connected.");
        this.connected = true;
        this.handshakeFuture.setSuccess();
        return;
    }
    if (msg instanceof FullHttpResponse) {
        throw new IllegalStateException("Unexpected response: " + msg.toString());
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        synchronized (responses) {
            responses.add(((TextWebSocketFrame) frame).text());
        }
    } else if (frame instanceof PingWebSocketFrame) {
        LOG.info("Returning pong message");
        ctx.writeAndFlush(new PongWebSocketFrame());
    } else if (frame instanceof CloseWebSocketFrame) {
        LOG.info("Received message from server to close the channel.");
        ctx.close();
    } else {
        LOG.warn("Unhandled frame type received: " + frame.getClass());
    }
}

@Override
protected void channelRead0(final ChannelHandlerContext ctx,final Object msg) throws Exception {
    final Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        // web socket client connected
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        handshakeFuture.setSuccess();
        return;
    }

    if (msg instanceof FullHttpResponse) {
        final FullHttpResponse response = (FullHttpResponse) msg;
        throw new Exception("Unexpected FullHttpResponse (getStatus=" + response.getStatus() + ",content="
                + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    // a close frame doesn't mean much here.  errors raised from closed channels will mark the host as dead
    final WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        ctx.fireChannelRead(frame.retain(2));
    } else if (frame instanceof PongWebSocketFrame) {
    } else if (frame instanceof BinaryWebSocketFrame) {
        ctx.fireChannelRead(frame.retain(2));
    } else if (frame instanceof CloseWebSocketFrame)
        ch.close();

}

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {

    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        handshakeFuture.setSuccess();

        //connection is opened.
        client.onopen(handshaker);

        return;
    }

    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.status() +
                ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        client.onMessage(textFrame.text());

    } else if (frame instanceof PongWebSocketFrame) {
        /*
         * placeholder.  maybe add onPong method to the RhinoClient
         */
    } else if (frame instanceof CloseWebSocketFrame) {
        client.onClose();
        ch.close();
    }
}

@Override
public void channelRead0(ChannelHandlerContext ctx,Object msg) throws Exception {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        System.out.println("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        return;
    }

    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.status() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        System.out.println("WebSocket Client received message: " + textFrame.text());
    } else if (frame instanceof PongWebSocketFrame) {
        System.out.println("WebSocket Client received pong");
    } else if (frame instanceof CloseWebSocketFrame) {
        System.out.println("WebSocket Client received closing");
        ch.close();
    }
}

protected void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {
   logger.debug("Received incoming frame [{}]",frame.getClass().getName());
   // Check for closing frame
   if (frame instanceof CloseWebSocketFrame) {
      if (frameBuffer != null) {
          handleMessageCompleted(ctx,frameBuffer.toString());
      }
      handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
      return;
   }

   if (frame instanceof PingWebSocketFrame) {
      ctx.channel().writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
      return;
   }

   if (frame instanceof PongWebSocketFrame) {
      logger.info("Pong frame received");
      return;
   }

   if (frame instanceof TextWebSocketFrame) {
      frameBuffer = new StringBuilder();
      frameBuffer.append(((TextWebSocketFrame)frame).text());
   } else if (frame instanceof ContinuationWebSocketFrame) {
      if (frameBuffer != null) {
         frameBuffer.append(((ContinuationWebSocketFrame)frame).text());
      } else {
         logger.warn("Continuation frame received without initial frame.");
      }
   } else {
      throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
   }

   // Check if Text or Continuation Frame is final fragment and handle if needed.
   if (frame.isFinalFragment()) {
      handleMessageCompleted(ctx,frameBuffer.toString());
      frameBuffer = null;
   }
}

private void handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

// 判断是否是关闭链路的指令
if (frame instanceof CloseWebSocketFrame) {
    handshaker.close(ctx.channel(),(CloseWebSocketFrame) frame.retain());
    return;
}
// 判断是否是Ping消息
if (frame instanceof PingWebSocketFrame) {
    ctx.channel().write(
        new PongWebSocketFrame(frame.content().retain()));
    return;
}
// 本例程仅支持文本消息，不支持二进制消息
if (!(frame instanceof TextWebSocketFrame)) {
    throw new UnsupportedOperationException(String.format(
        "%s frame types not supported",frame.getClass().getName()));
}

// 返回应答消息
String request = ((TextWebSocketFrame) frame).text();
if (logger.isLoggable(Level.FINE)) {
    logger.fine(String.format("%s received %s",request));
}
ctx.channel().write(
    new TextWebSocketFrame(request
        + ",欢迎使用Netty WebSocket服务，现在时刻："
        + new java.util.Date().toString()));
   }

@Override
public void channelRead0(ChannelHandlerContext ctx,(FullHttpResponse) msg);
        System.out.println("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        return;
    }

    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.getStatus() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        System.out.println("WebSocket Client received message: " + textFrame.text());
    } else if (frame instanceof PongWebSocketFrame) {
        System.out.println("WebSocket Client received pong");
    } else if (frame instanceof CloseWebSocketFrame) {
        System.out.println("WebSocket Client received closing");
        ch.close();
    }
}

@Override
public void channelRead0(ChannelHandlerContext ctx,(FullHttpResponse) msg);
        logger.debug("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        return;
    }

    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.status() +
                ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }

    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        TextWebSocketFrame textFrame = (TextWebSocketFrame) frame;
        logger.debug("WebSocket Client received text message: " + textFrame.text());
        textReceived = textFrame.text();
    } else if (frame instanceof BinaryWebSocketFrame) {
        BinaryWebSocketFrame binaryFrame = (BinaryWebSocketFrame) frame;
        bufferReceived = binaryFrame.content().nioBuffer();
        logger.debug("WebSocket Client received  binary message: " + bufferReceived.toString());
    } else if (frame instanceof PongWebSocketFrame) {
        logger.debug("WebSocket Client received pong");
        PongWebSocketFrame pongFrame = (PongWebSocketFrame) frame;
        bufferReceived = pongFrame.content().nioBuffer();
    } else if (frame instanceof CloseWebSocketFrame) {
        logger.debug("WebSocket Client received closing");
        ch.close();
    }
}

private void notifyPongMessage(PongWebSocketFrame pongWebSocketFrame) throws ServerConnectorException {
    //Control message for WebSocket is Pong Message
    ByteBuf byteBuf = pongWebSocketFrame.content();
    ByteBuffer byteBuffer = byteBuf.nioBuffer();
    WebSocketMessageImpl webSocketControlMessage =
            new WebSocketControlMessageImpl(WebSocketControlSignal.PONG,byteBuffer);
    webSocketControlMessage = setupCommonProperties(webSocketControlMessage);
    connectorFuture.notifyWSListener((WebSocketControlMessage) webSocketControlMessage);
}

@Override
public void channelRead0(ChannelHandlerContext ctx,URISyntaxException,ServerConnectorException {
    Channel ch = ctx.channel();
    if (!handshaker.isHandshakeComplete()) {
        handshaker.finishHandshake(ch,(FullHttpResponse) msg);
        log.debug("WebSocket Client connected!");
        handshakeFuture.setSuccess();
        channelSession = WebSocketUtil.getSession(ctx,isSecure,requestedUri);
        return;
    }

    if (msg instanceof FullHttpResponse) {
        FullHttpResponse response = (FullHttpResponse) msg;
        throw new IllegalStateException(
                "Unexpected FullHttpResponse (getStatus=" + response.status() +
                        ",content=" + response.content().toString(CharsetUtil.UTF_8) + ')');
    }
    WebSocketFrame frame = (WebSocketFrame) msg;
    if (frame instanceof TextWebSocketFrame) {
        notifyTextMessage((TextWebSocketFrame) frame,ctx);
    } else if (frame instanceof BinaryWebSocketFrame) {
        notifyBinaryMessage((BinaryWebSocketFrame) frame,ctx);
    } else if (frame instanceof PongWebSocketFrame) {
        notifyPongMessage((PongWebSocketFrame) frame,ctx);
    } else if (frame instanceof PingWebSocketFrame) {
        notifyPingMessage((PingWebSocketFrame) frame,ctx);
    } else if (frame instanceof CloseWebSocketFrame) {
        if (channelSession != null) {
            channelSession.setIsOpen(false);
        }
        notifyCloseMessage((CloseWebSocketFrame) frame,ctx);
        ch.close();
    } else {
        throw new UnkNownWebSocketFrameTypeException("Cannot identify the WebSocket frame type");
    }
}

private void notifyPongMessage(PongWebSocketFrame pongWebSocketFrame,ChannelHandlerContext ctx)
        throws ServerConnectorException {
    //Control message for WebSocket is Pong Message
    ByteBuf byteBuf = pongWebSocketFrame.content();
    ByteBuffer byteBuffer = byteBuf.nioBuffer();
    WebSocketMessageImpl webSocketControlMessage =
            new WebSocketControlMessageImpl(WebSocketControlSignal.PONG,byteBuffer);
    webSocketControlMessage = setupCommonProperties(webSocketControlMessage,ctx);
    connectorListener.onMessage((WebSocketControlMessage) webSocketControlMessage);
}

private boolean handleWebSocketFrame(ChannelHandlerContext ctx,WebSocketFrame frame) {

      // Check for closing frame
      if (frame instanceof CloseWebSocketFrame) {
         this.handshaker.close(ctx.channel(),((CloseWebSocketFrame) frame).retain());
         return false;
      } else if (frame instanceof PingWebSocketFrame) {
         ctx.writeAndFlush(new PongWebSocketFrame(frame.content().retain()));
         return false;
      } else if (!(frame instanceof TextWebSocketFrame) && !(frame instanceof BinaryWebSocketFrame)) {
         throw new UnsupportedOperationException(String.format("%s frame types not supported",frame.getClass().getName()));
      }
      return true;
   }

/**
 *
 * @param context the context to add the web socket endpoints to
 * @param rtEventResource The instance of the websocket endpoint to return
 * @throws DeploymentException
 */
private static void setWebSocketEndpoints(ServletContextHandler context,EventsResource rtEventResource)
        throws DeploymentException,servletexception {

    ServerContainer wsContainer = WebSocketServerContainerInitializer.configureContext(context);

    ServerEndpointConfig serverConfig =
            ServerEndpointConfig.Builder
                                .create(EventsResource.class,EventsResource.RT_EVENT_ENDPOINT)
                                .configurator(new Configurator() {
                                    @Override
                                    public <T> T getEndpointInstance(Class<T> endpointClass)
                                            throws InstantiationException {
                                        return endpointClass.cast(rtEventResource);
                                    }
                                }).build();

    wsContainer.addEndpoint(serverConfig);
}

public static void configureEndpoint(String endpointPath,Class endpointClass,Class handshakeHandlerClass,luceeApp app) throws ClassNotFoundException,illegalaccessexception,InstantiationException,DeploymentException,PageException {

    ServerEndpointConfig serverEndpointConfig = ServerEndpointConfig.Builder.create(endpointClass,endpointPath).configurator(
                    (ServerEndpointConfig.Configurator) handshakeHandlerClass.newInstance()).build();

    try {

        ServerContainer serverContainer = (ServerContainer) app.getServletContext().getAttribute(
                "javax.websocket.server.ServerContainer");
        serverContainer.addEndpoint(serverEndpointConfig);
    }
    catch (DeploymentException ex) {

        app.log(Log.LEVEL_DEBUG,"Failed to register endpoint " + endpointPath + ": " + ex.getMessage(),app.getName(),"websocket");
    }
    // System.out.println(Configurator.class.getName() + " >>> exit configureEndpoint()");
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(Async.class);
        sc.addEndpoint(Basic.class);
        sc.addEndpoint(BasiclimitLow.class);
        sc.addEndpoint(BasiclimitHigh.class);
        sc.addEndpoint(RootEcho.class);
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce.getServletContext().getAttribute(
            Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            Bug58624ServerEndpoint.class,PATH).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            TesterEchoServer.Basic.class,"/{param}").build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce.getServletContext().getAttribute(
            Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    List<Class<? extends Encoder>> encoders = new ArrayList<Class<? extends Encoder>>();
    encoders.add(Bug58624Encoder.class);
    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            Bug58624Endpoint.class,PATH).encoders(encoders).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce
            .getServletContext()
            .getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            getEndpointClass(),PATH).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(ServerEndpointConfig.Builder.create(
                ConstantTxEndpoint.class,PATH).build());
        if (TestWsWebSocketContainer.timeoutOnContainer) {
            sc.setAsyncSendTimeout(TIMEOUT_MS);
        }
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(Async.class);
        sc.addEndpoint(Basic.class);
        sc.addEndpoint(BasiclimitLow.class);
        sc.addEndpoint(BasiclimitHigh.class);
        sc.addEndpoint(RootEcho.class);
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce.getServletContext().getAttribute(
            Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            Bug58624ServerEndpoint.class,PATH).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            TesterEchoServer.Basic.class,"/{param}").build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce.getServletContext().getAttribute(
            Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    List<Class<? extends Encoder>> encoders = new ArrayList<Class<? extends Encoder>>();
    encoders.add(Bug58624Encoder.class);
    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            Bug58624Endpoint.class,PATH).encoders(encoders).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc = (ServerContainer) sce
            .getServletContext()
            .getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            getEndpointClass(),PATH).build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(ServerEndpointConfig.Builder.create(
                ConstantTxEndpoint.class,PATH).build());
        if (TestWsWebSocketContainer.timeoutOnContainer) {
            sc.setAsyncSendTimeout(TIMEOUT_MS);
        }
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public void contextinitialized(final ServletContextEvent servletContextEvent) {
    super.contextinitialized(servletContextEvent);
    final ServerContainer serverContainer = (ServerContainer) servletContextEvent.getServletContext()
            .getAttribute("javax.websocket.server.ServerContainer");

    if (serverContainer != null) {
        try {
            serverContainer.addEndpoint(ServerEndpointConfig.Builder
                    .create(SubscriptionEndpoint.class,"/ContextManager/{" + PATH_NAME + "}").build());
            // serverContainer.addEndpoint(ServerEndpointConfig.Builder
            // .create(ExtendedSubscriptionEndpoint.class,// "/ContextManager/{contextParticipantId}")
            // .configurator(new WebSocketsConfigurator()).build());
        } catch (final DeploymentException e) {
            throw new RuntimeException(e.getMessage(),e);
        }
    }
}

protected void addEndpoint(final Class<?> cls) {

    final ServerContainer container = getServerContainer();

    if (container == null) {
      LOG.warn("ServerContainer is null. Skip registration of websocket endpoint {}",cls);
      return;
    }

    try {
      LOG.debug("Register endpoint {}",cls);

      final ServerEndpointConfig config = createEndpointConfig(cls);
      container.addEndpoint(config);

    } catch (final DeploymentException e) {
      addError(e);
    }
  }

@Override
public void upgradeInternal(ServerHttpRequest httpRequest,ServerHttpResponse httpResponse,String selectedProtocol,List<Extension> selectedExtensions,Endpoint endpoint)
        throws HandshakeFailureException {

    HttpServletRequest request = getHttpServletRequest(httpRequest);
    HttpServletResponse response = getHttpServletResponse(httpResponse);

    StringBuffer requestUrl = request.getRequestURL();
    String path = request.getRequestURI();  // shouldn't matter
    Map<String,String> pathParams = Collections.<String,String> emptyMap();

    ServerEndpointRegistration endpointConfig = new ServerEndpointRegistration(path,endpoint);
    endpointConfig.setSubprotocols(Collections.singletonList(selectedProtocol));
    endpointConfig.setExtensions(selectedExtensions);

    try {
        ServerContainer container = getContainer(request);
        upgradeMethod.invoke(container,request,response,endpointConfig,pathParams);
    }
    catch (Exception ex) {
        throw new HandshakeFailureException(
                "Servlet request Failed to upgrade to WebSocket for " + requestUrl,ex);
    }
}

/**
 * Creates a new {@link ComputeRealtimeServer}
 *
 * @param config
 *            The chatalytics config
 * @return A newly created {@link ComputeRealtimeServer}
 */
public ComputeRealtimeServer createComputeRealtimeServer() {
    Server server = new Server(config.computeConfig.rtComputePort);
    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setcontextpath("/");

    ServletHolder jerseyServlet = context.addServlet(ServletContainer.class,"/*");
    jerseyServlet.setinitParameter(PackagesResourceConfig.PROPERTY_PACKAGES,StatusResource.class.getPackage().toString());
    server.setHandler(context);
    ServerContainer wscontainer;
    try {
        wscontainer = WebSocketServerContainerInitializer.configureContext(context);
        wscontainer.addEndpoint(RealtimeResource.class);
    } catch (servletexception | DeploymentException e) {
        throw new RuntimeException("Can't instantiate websocket. Reason: " + e.getMessage());
    }

    return new ComputeRealtimeServer(server);
}

@Override
public void contextinitialized(ServletContextEvent contextEvent) {
    ServletContext servletContext = contextEvent.getServletContext();
    mdwMain = new MdwMain();
    String container = NamingProvider.TOMCAT; // Todo
    if (ApplicationContext.isspringBoot()) {
        ServerContainer serverContainer = (ServerContainer)servletContext.getAttribute("javax.websocket.server.ServerContainer");
        try {
            serverContainer.addEndpoint(WebSocketMessenger.class);
        }
        catch (Exception ex) {
            ex.printstacktrace();
        }
        mdwMain.startup(container,SpringBootApplication.getBootDir().toString(),servletContext.getcontextpath());
    }
    else {
        mdwMain.startup(container,servletContext.getRealPath("/"),servletContext.getcontextpath());
    }
}

/**
 * Initialize a websocket server
 */
public static void start() {
    if(isRunning()){
        return;
    }
    server = new Server();
    connector = new ServerConnector(server);
    connector.setPort(8787);
    server.addConnector(connector);

    ServletContextHandler context = new ServletContextHandler(
            ServletContextHandler.SESSIONS);
    context.setcontextpath("/");
    server.setHandler(context);

    try {
        ServerContainer wscontainer = WebSocketServerContainerInitializer
                .configureContext(context);
        wscontainer.addEndpoint(WebsocketEndpoint.class);
        synchronized (server) {
            server.start();
        }
    } catch (Throwable t) {
        t.printstacktrace(System.err);
    }
}

public WebsocketContainer(WebsocketConfiguration configuration,ServerContainer serverContainer) {
    this.serverContainer = serverContainer;

    Optional<Long> longVal = Optional.fromNullable(configuration.getMaxSessionIdleTimeout());
    if (longVal.isPresent()) {
        this.serverContainer.setDefaultMaxSessionIdleTimeout(longVal.get());
    }
    longVal = Optional.fromNullable(configuration.getAsyncSendTimeout());
    if (longVal.isPresent()) {
        this.serverContainer.setAsyncSendTimeout(longVal.get());
    }
    Optional<Integer> intVal = Optional.fromNullable(configuration.getMaxBinaryMessageBufferSize());
    if (intVal.isPresent()) {
        this.serverContainer.setDefaultMaxBinaryMessageBufferSize(intVal.get());
    }
    intVal = Optional.fromNullable(configuration.getMaxTextMessageBufferSize());
    if (intVal.isPresent()) {
        this.serverContainer.setDefaultMaxTextMessageBufferSize(intVal.get());
    }
}

@Override
protected void startServer(int port,final Action<ServerWebSocket> websocketAction) throws
  Exception {
  server = new Server();
  ServerConnector connector = new ServerConnector(server);
  connector.setPort(port);
  server.addConnector(connector);
  ServletContextHandler handler = new ServletContextHandler();
  server.setHandler(handler);
  ServerContainer container = WebSocketServerContainerInitializer.configureContext(handler);
  ServerEndpointConfig config = ServerEndpointConfig.Builder.create(AsityServerEndpoint.class,TEST_URI)
  .configurator(new Configurator() {
    @Override
    public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
      return endpointClass.cast(new AsityServerEndpoint().onwebsocket(websocketAction));
    }
  })
  .build();
  container.addEndpoint(config);
  server.start();
}

@Override
public void contextinitialized(ServletContextEvent servletContextEvent) {

  ServletContext context = servletContextEvent.getServletContext();

  final ServerContainer serverContainer = (ServerContainer) context
          .getAttribute("javax.websocket.server.ServerContainer");

  try {

    context.setAttribute("protocol",new MetadataProtocol());

    //attach the WebSockets Endpoint to the web container
    serverContainer.addEndpoint(WebSocketEndpoint.class);

    logger.log(Level.INFO,"HOPSWORKS DEPLOYED");
  } catch (DeploymentException ex) {
    logger.log(Level.SEVERE,ex.getMessage(),ex);
  }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
  // initialize DiqubeServletConfig
  WebApplicationContext ctx = WebApplicationContextUtils.getrequiredWebApplicationContext(sce.getServletContext());
  ctx.getBean(DiqubeServletConfig.class).initialize(sce.getServletContext());

  // register our Websocket Endpoint
  ServerContainer serverContainer = (ServerContainer) sce.getServletContext().getAttribute(ATTR_SERVER_CONTAINER);

  ServerEndpointConfig sec =
      ServerEndpointConfig.Builder.create(WebSocketEndpoint.class,WebSocketEndpoint.ENDPOINT_URL_MAPPING).build();
  sec.getUserProperties().put(WebSocketEndpoint.PROP_BEAN_CONTEXT,ctx);

  try {
    serverContainer.addEndpoint(sec);
  } catch (DeploymentException e) {
    throw new RuntimeException("DeploymentException when deploying Websocket endpoint",e);
  }
}

public static void main(String[] args) throws Exception {
    SLF4JBridgeHandler.removeHandlersForRootLogger();
    SLF4JBridgeHandler.install();
    Server server = new Server(9090);
    ClassList classlist = Configuration.ClassList.setServerDefault(server);
    classlist.addBefore("org.eclipse.jetty.webapp.JettyWebXmlConfiguration","org.eclipse.jetty.annotations.AnnotationConfiguration");
    WebAppContext webapp = new WebAppContext();
    webapp.setParentLoaderPriority(true);
    webapp.setConfigurationdiscovered(true);
    webapp.setcontextpath("/");
    webapp.setResourceBase("src/main/webapp");
    webapp.setWar("src/main/webapp");       
    ServletHolder servletHolder = webapp.addServlet(DemoUIServlet.class,"/*");
    servletHolder.setAsyncSupported(true);
    servletHolder.setinitParameter("org.atmosphere.cpr.asyncSupport",JSR356AsyncSupport.class.getName());
    server.setHandler(webapp);
    ServerContainer webSocketServer = WebSocketServerContainerInitializer.configureContext(webapp);
    webSocketServer.setDefaultMaxSessionIdleTimeout(10000000);        
    server.start();
    log.info("browse http://localhost:9090 to see the demo");
    server.join();
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            TesterEchoServer.Basic.class,"/{param}").build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(ServerEndpointConfig.Builder.create(
                ConstantTxEndpoint.class,PATH).build());
        if (TestWsWebSocketContainer.timoutOnContainer) {
            sc.setAsyncSendTimeout(TIMEOUT_MS);
        }
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

public void addProcessEventsEndpoint(ServletContextEvent ce) {
    log.info("deploying process-engine-events websockets server endpoint");
    ServletContext sc = ce.getServletContext();

    final ServerContainer server_container
            = (ServerContainer) ce.getServletContext().getAttribute("javax.websocket.server.ServerContainer");

    try {
        ServerEndpointConfig config
                = ServerEndpointConfig.Builder.create(ProcessEngineEventsWebsocket.class,"/process-engine-events").build();
        config.getUserProperties().put("servlet.context",sc);
        server_container.addEndpoint(config);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
protected void startServer() throws Exception {
    server = new Server();
    ServerConnector connector = new ServerConnector(server);
    connector.setPort(port);
    server.addConnector(connector);
    ServletContextHandler handler = new ServletContextHandler();
    server.setHandler(handler);
    ServerContainer container = WebSocketServerContainerInitializer.configureContext(handler);
    ServerEndpointConfig config = ServerEndpointConfig.Builder.create(VibeServerEndpoint.class,"/test")
    .configurator(new Configurator() {
        @Override
        public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
            return endpointClass.cast(new VibeServerEndpoint().onwebsocket(performer.serverAction()));
        }
    })
    .build();
    container.addEndpoint(config);
    server.start();
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);

    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);

    ServerEndpointConfig sec = ServerEndpointConfig.Builder.create(
            TesterEchoServer.Basic.class,"/{param}").build();

    try {
        sc.addEndpoint(sec);
    } catch (DeploymentException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(ServerEndpointConfig.Builder.create(
                ConstantTxEndpoint.class,PATH).build());
        if (TestWsWebSocketContainer.timoutOnContainer) {
            sc.setAsyncSendTimeout(TIMEOUT_MS);
        }
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
protected void registerBinder(ResourceConfig configuration) {
    super.registerBinder(configuration);
    if (webSocketEnabled) {
        webSocketServerContainer = new WebSocketServerContainer(getApplication());
        configuration.register(new AbstractBinder() {
            @Override
            protected void configure() {
                bindFactory((supplier<ServerContainer>) () -> webSocketServerContainer)
                        .to(ServerContainer.class)
                        .to(WebSocketServerContainer.class);
                bind(TyrusWebSocketEndpointProvider.class)
                        .to(WebSocketEndpointProvider.class);
            }
        });
    }
}

public void start() {
    server = new Server();
    ServerConnector connector = new ServerConnector(server);
    connector.setPort(port);
    server.addConnector(connector);

    ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
    context.setcontextpath("/");
    server.setHandler(context);

    ServerContainer wscontainer = WebSocketServerContainerInitializer.configureContext(context);

    try {
        wscontainer.addEndpoint(new RPDEndpointConfig());
        server.start();
        server.join();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public void register(Class<?> webSocketPojo) {
    ServerContainer container = (ServerContainer) servletContext.getAttribute("javax.websocket.server.ServerContainer");

    EndpointConfigImpl clientConfig = configurationBuilder.configure(webSocketPojo);
    WebSocketConfig config = (WebSocketConfig) servletContext.getAttribute(WebSocketConfig.class.getName());
    config.registerEndpointConfig(clientConfig);

    WebSocket annotation = webSocketPojo.getAnnotation(WebSocket.class);
    if (annotation == null) {
        throw new WebSocketConfigException(webSocketPojo + " must be annotated with " + WebSocket.class);
    }

    ServerEndpointConfig serverConfig = ServerEndpointConfig.Builder.create(WebSocketClientJsr356.class,annotation.value())
                                                                        .configurator(new EndPointConfigurator(clientConfig))
                                                                        .subprotocols(getSubProtocols(webSocketPojo))
                                                                        .build();
    try {
        container.addEndpoint(serverConfig);
    } catch (DeploymentException e) {
        throw new WebSocketConfigException("Could not add websocket for " + webSocketPojo,e);
    }
}

@Override
public void enable(ServletContext servletContext) {
    logger.info("Enabling feature");

    Module module = (Module) servletContext.getAttribute(Module.class.getName());
    ServerContainer serverContainer = (ServerContainer) servletContext.getAttribute(ServerContainer.class.getName());

    ServerEndpointConfig endpointConfig = ServerEndpointConfig.Builder.create(DaggerEndpoint.class,"/{anyPath}")
        .configurator(new DaggerEndpointConfigurator(module))
        .build();

    try {
        serverContainer.addEndpoint(endpointConfig);
    } catch (DeploymentException e) {
        logger.error("Error configuring websocket endpoint",e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc = (ServerContainer) sce.getServletContext()
            .getAttribute(Constants.
                    SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(SubProtocolsEndpoint.class);
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        sc.addEndpoint(pojoClazz);
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public void contextinitialized(ServletContextEvent sce) {
    super.contextinitialized(sce);
    ServerContainer sc =
            (ServerContainer) sce.getServletContext().getAttribute(
                    Constants.SERVER_CONTAINER_SERVLET_CONTEXT_ATTRIBUTE);
    try {
        // Reset blocking state
        BlockingPojo.resetBlock();
        sc.addEndpoint(BlockingPojo.class);
    } catch (DeploymentException e) {
        throw new IllegalStateException(e);
    }
}

@Before
public void setup() {
    Robolectric.getBackgroundThreadScheduler().reset();
    Robolectric.getForegroundThreadScheduler().reset();
    ShadowLog.stream = System.out;
    activity = Robolectric.buildActivity(MockMainActivity.class).create().start().resume().visible().get();
    shadowOf(activity).grantPermissions("android.permission.INTERNET");
    server= new MockWebServer();
    try {
        server.start();
        HttpUrl url= server.url("/");
        UTConstants.REQUEST_BASE_URL_UT_V2 = url.toString();
        System.out.println(UTConstants.REQUEST_BASE_URL_UT_V2);
        ShadowSettings.setTestURL(url.toString());
        TestResponsesUT.setTestURL(url.toString());
    } catch (IOException e) {
        System.out.print("IOException");
    }
    bgScheduler = Robolectric.getBackgroundThreadScheduler();
    uiScheduler = Robolectric.getForegroundThreadScheduler();
    Robolectric.flushBackgroundThreadScheduler();
    Robolectric.flushForegroundThreadScheduler();
    bgScheduler.pause();
    uiScheduler.pause();
}

@Before
    public void setup() {
        activity = Robolectric.buildActivity(MockMainActivity.class).create().get();
//        activity = Robolectric.setupActivity(MockMainActivity.class);
        shadowOf(activity).grantPermissions("android.permission.INTERNET");
        server = new MockWebServer();
        try {
            server.start();
            successfulMockServerStarted = true;
        } catch (IOException e) {
            e.printstacktrace();
        }
        FakeHttp.getFakeHttpLayer().interceptHttpRequests(true);
        FakeHttp.getFakeHttpLayer().interceptResponseContent(true);
        bgScheduler = Robolectric.getBackgroundThreadScheduler();
        uiScheduler = Robolectric.getForegroundThreadScheduler();
        Robolectric.flushBackgroundThreadScheduler();
        Robolectric.flushForegroundThreadScheduler();
        bgScheduler.pause();
        uiScheduler.pause();
    }

@Before
public void setup() throws IOException {
    mockWebServer = new MockWebServer();
    mockWebServer.start();

    ObjectMapper objectMapper = new ObjectMapper().disable(
            MapperFeature.AUTO_DETECT_CREATORS,MapperFeature.AUTO_DETECT_FIELDS,MapperFeature.AUTO_DETECT_GETTERS,MapperFeature.AUTO_DETECT_IS_GETTERS)
            .configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS,true);

    DeltaApi deltaApi = new Retrofit.Builder()
            .baseUrl(mockWebServer.url("").toString())
            .addConverterFactory(JacksonConverterFactory.create(objectMapper))
            .build()
            .create(DeltaApi.class);

    apiclient = new Deltaapiclient(deltaApi);
}

@Before
public void setup() throws IOException {
    MockWebServer mockWebServer = new MockWebServer();
    mockWebServer.start();

    JacksonConverterFactory converterFactory = JacksonConverterFactory.create(new ObjectMapper());

    mockDeltaApi = new Retrofit.Builder()
            .baseUrl(mockWebServer.url(MOCK_HOST).toString())
            .addConverterFactory(converterFactory)
            .build().create(MockDeltaApi.class);

    CreateIdentityRequest createIdentityRequest =
            new CreateIdentityRequest(SIGNING_PUBLIC_KEY,ENCRYPTION_PUBLIC_KEY,null,null);
    Call<CreateIdentityResponse> call
            = mockDeltaApi.register(REQUEST_DATE,"example.server",IDENTITY_ID,"sampleQueryParamValue",createIdentityRequest);
    request = call.request()
            .newBuilder() // fix as okhttp removes content-type header
            .addHeader(HttpHeaders.CONTENT_TYPE,MediaType.JSON_UTF_8.toString())
            .build();
}

public void testGetListUserByGroup() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/admin-list-user-by-group.json"))
            .setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final UserPage up = baseApi.adminApi().listUsersByGroup(localContext,2);
        assertthat(up).isNotNull();
        assertthat(up.errors()).isEmpty();
        assertthat(up.size() == 2).isTrue();
        assertthat(up.values().get(0).slug().equals("bob123")).isTrue();

        final Map<String,?> queryParams = ImmutableMap.of("context",localContext,limitKeyword,2,startKeyword,0);
        assertSent(server,getmethod,restApiPath + BitbucketApiMetadata.API_VERSION
                + "/admin/groups/more-members",queryParams);
    } finally {
        server.shutdown();
    }
}

public void testGetListUserByGroupOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/admin-list-user-by-group-error.json"))
            .setResponseCode(401));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final UserPage up = baseApi.adminApi().listUsersByGroup(localContext,2);
        assertthat(up).isNotNull();
        assertthat(up.errors()).isNotEmpty();

        final Map<String,queryParams);
    } finally {
        server.shutdown();
    }
}

public void testGetStatusOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/build-status-error.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final StatusPage statusPage = baseApi.buildStatusApi().status(commitHash,100);
        assertthat(statusPage).isNotNull();
        assertthat(statusPage.values()).isEmpty();
        assertthat(statusPage.errors().size() == 1).isTrue();

        final Map<String,?> queryParams = ImmutableMap.of("limit",100,"start","GET",restBuildStatusPath + BitbucketApiMetadata.API_VERSION
                + commitPath,queryParams);
    } finally {
        server.shutdown();
    }
}

public void testGetSummary() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/build-summary.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Summary summary = baseApi.buildStatusApi().summary(commitHash);
        assertthat(summary).isNotNull();
        assertthat(summary.Failed() == 1).isTrue();
        assertthat(summary.inProgress() == 2).isTrue();
        assertthat(summary.successful() == 3).isTrue();

        assertSent(server,restBuildStatusPath + BitbucketApiMetadata.API_VERSION
                + "/commits/stats/306bcf274566f2e89f75ae6f7faf10beff38382012");
    } finally {
        server.shutdown();
    }
}

public void testAddBuildStatus() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/build-status-post.json")).setResponseCode(204));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final CreateBuildStatus cbs = CreateBuildStatus.create(CreateBuildStatus.STATE.SUCCESSFUL,"REPO-MASTER","REPO-MASTER-42","https://bamboo.example.com/browse/REPO-MASTER-42","Changes by John Doe");
        final RequestStatus success = baseApi.buildStatusApi().add(commitHash,cbs);
        assertthat(success).isNotNull();
        assertthat(success.value()).isTrue();
        assertthat(success.errors()).isEmpty();

        assertSent(server,"POST",restBuildStatusPath + BitbucketApiMetadata.API_VERSION
                + commitPath);
    } finally {
        server.shutdown();
    }
}

public void testAddBuildStatusOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/errors.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final CreateBuildStatus cbs = CreateBuildStatus.create(CreateBuildStatus.STATE.SUCCESSFUL,cbs);
        assertthat(success).isNotNull();
        assertthat(success.value()).isFalse();
        assertthat(success.errors()).isNotEmpty();

        assertSent(server,restBuildStatusPath + BitbucketApiMetadata.API_VERSION
                + commitPath);
    } finally {
        server.shutdown();
    }
}

public void testGetCommit() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/commit.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Commit commit = baseApi.commitsApi().get(projectKey,repoKey,commitHash,null);
        assertthat(commit).isNotNull();
        assertthat(commit.errors().isEmpty()).isTrue();
        assertthat(commit.id().equalsIgnoreCase(commitHash)).isTrue();

        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION
                + "/projects/" + projectKey + "/repos/" + repoKey + "/commits/" + commitHash);
    } finally {
        server.shutdown();
    }
}

public void testGetCommitNonExistent() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/commit-error.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Commit commit = baseApi.commitsApi().get(projectKey,null);
        assertthat(commit).isNotNull();
        assertthat(commit.errors().size() > 0).isTrue();

        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION
                + "/projects/" + projectKey + "/repos/" + repoKey + "/commits/" + commitHash);
    } finally {
        server.shutdown();
    }
}

public void testGetPullRequestChanges() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/pull-request-changes.json"))
            .setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final ChangePage changePage = baseApi.commitsApi().listChanges(projectKey,12,null);
        assertthat(changePage).isNotNull();
        assertthat(changePage.errors()).isEmpty();
        assertthat(changePage.values()).hasSize(1);

        final Map<String,?> queryParams = ImmutableMap.of(limitKeyword,12);
        assertSent(server,restApiPath + BitbucketApiMetadata.API_VERSION
                + "/projects/PRJ/repos/myrepo/commits/abcdef0123abcdef4567abcdef8987abcdef6543/changes",queryParams);
    } finally {
        server.shutdown();
    }
}

public void testGetPullRequestChangesOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/commit-error.json"))
            .setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final ChangePage changePage = baseApi.commitsApi().listChanges(projectKey,1,12);
        assertthat(changePage).isNotNull();
        assertthat(changePage.errors()).isNotEmpty();

        final Map<String,queryParams);
    } finally {
        server.shutdown();
    }
}

public void testListCommits() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/pull-request-commits.json"))
            .setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final CommitPage pcr = baseApi.commitsApi().list(projectKey,true,null);
        assertthat(pcr).isNotNull();
        assertthat(pcr.errors()).isEmpty();
        assertthat(pcr.values()).hasSize(1);
        assertthat(pcr.totalCount()).isEqualTo(1);

        final Map<String,?> queryParams = ImmutableMap.of("withCounts",1);
        assertSent(server,restApiPath + BitbucketApiMetadata.API_VERSION
                + "/projects/PRJ/repos/myrepo/commits",queryParams);
    } finally {
        server.shutdown();
    }
}

public void testListCommitsOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/commit-error.json"))
            .setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final CommitPage pcr = baseApi.commitsApi().list(projectKey,null);
        assertthat(pcr).isNotNull();
        assertthat(pcr.errors()).isNotEmpty();

        final Map<String,queryParams);
    } finally {
        server.shutdown();
    }
}

public void testCreateProject() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project.json"))
            .setResponseCode(201));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String projectKey = "HELLO";
        final CreateProject createProject = CreateProject.create(projectKey,null);
        final Project project = baseApi.projectApi().create(createProject);

        assertthat(project).isNotNull();
        assertthat(project.errors()).isEmpty();
        assertthat(project.key()).isEqualToIgnoringCase(projectKey);
        assertthat(project.name()).isEqualToIgnoringCase(projectKey);
        assertthat(project.links()).isNotNull();
        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION + localPath);
    } finally {
        server.shutdown();
    }
}

public void testCreateProjectWithIllegalName() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project-create-fail.json"))
            .setResponseCode(400));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String projectKey = "9999";
        final CreateProject createProject = CreateProject.create(projectKey,null);
        final Project project = baseApi.projectApi().create(createProject);

        assertthat(project).isNotNull();
        assertthat(project.errors()).isNotEmpty();
        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION + localPath);
    } finally {
        server.shutdown();
    }
}

public void testGetProject() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project.json"))
            .setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String projectKey = "HELLO";
        final Project project = baseApi.projectApi().get(projectKey);

        assertthat(project).isNotNull();
        assertthat(project.errors()).isEmpty();
        assertthat(project.key()).isEqualToIgnoringCase(projectKey);
        assertthat(project.links()).isNotNull();
        assertSent(server,localMethod,restBasePath + BitbucketApiMetadata.API_VERSION + localPath + "/" + projectKey);
    } finally {
        server.shutdown();
    }
}

public void testGetProjectNonExistent() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project-not-exist.json"))
            .setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String projectKey = "HelloWorld";
        final Project project = baseApi.projectApi().get(projectKey);

        assertthat(project).isNotNull();
        assertthat(project.errors()).isNotEmpty();
        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION + localPath + "/" + projectKey);
    } finally {
        server.shutdown();
    }
}

public void testDeleteProject() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setResponseCode(204));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String projectKey = "HELLO";
        final RequestStatus success = baseApi.projectApi().delete(projectKey);
        assertthat(success).isNotNull();
        assertthat(success.value()).isTrue();
        assertthat(success.errors()).isEmpty();
        assertSent(server,"DELETE","/rest/api/" + BitbucketApiMetadata.API_VERSION + "/projects/" + projectKey);
    } finally {
        server.shutdown();
    }
}

public void testDeleteProjectNonExistent() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project-not-exist.json"))
            .setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String projectKey = "NOTEXIST";
        final RequestStatus success = baseApi.projectApi().delete(projectKey);
        assertthat(success).isNotNull();
        assertthat(success.value()).isFalse();
        assertthat(success.errors()).isNotEmpty();
        assertSent(server,"/rest/api/" + BitbucketApiMetadata.API_VERSION + "/projects/" + projectKey);
    } finally {
        server.shutdown();
    }
}

public void testGetProjectList() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project-page-full.json"))
            .setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final ProjectPage projectPage = baseApi.projectApi().list(null,null);

        assertthat(projectPage).isNotNull();
        assertthat(projectPage.errors()).isEmpty();

        assertthat(projectPage.size()).isLessthanorEqualTo(projectPage.limit());
        assertthat(projectPage.start()).isEqualTo(0);
        assertthat(projectPage.isLastPage()).isTrue();

        assertthat(projectPage.values()).hasSize(projectPage.size());
        assertthat(projectPage.values()).hasOnlyElementsOfType(Project.class);
        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION + localPath);
    } finally {
        server.shutdown();
    }
}

public void testGetProjectListNonExistent() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse()
            .setBody(payloadFromresource("/project-not-exist.json"))
            .setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final ProjectPage projectPage = baseApi.projectApi().list(null,null);

        assertthat(projectPage).isNotNull();
        assertthat(projectPage.errors()).isNotEmpty();
        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION + localPath);
    } finally {
        server.shutdown();
    }
}

public void testListConditions() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/default-reviwers-list.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final List<Condition> conditions = baseApi.defaultReviewersApi().listConditions(projectKey,repoKey);
        assertthat(conditions).isNotNull();
        assertthat(conditions.size()).isEqualTo(3);

        assertSent(server,defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + reposPath + repoKey + "/conditions");
    } finally {
        server.shutdown();
    }
}

public void testCreateCondition() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/default-reviwers-create.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Long requiredApprover = 1L;
        final Matcher matcherSrc = Matcher.create(Matcher.MatcherId.ANY,true);
        final Matcher matcherDst = Matcher.create(Matcher.MatcherId.ANY,true);
        final List<User> listUser = new ArrayList<>();
        listUser.add(User.create(projectKey,testemail,projectKey,normalKeyword));
        final CreateCondition condition = CreateCondition.create(null,matcherSrc,matcherDst,listUser,requiredApprover);

        final Condition returnCondition = baseApi.defaultReviewersApi().createCondition(projectKey,condition);
        assertthat(returnCondition).isNotNull();
        assertthat(returnCondition.errors()).isEmpty();
        assertthat(returnCondition.id()).isEqualTo(3L);

        assertSent(server,defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + reposPath + repoKey + "/condition");
    } finally {
        server.shutdown();
    }
}

public void testCreateConditionOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/repository-not-exist.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Long requiredApprover = 1L;
        final Matcher matcherSrc = Matcher.create(Matcher.MatcherId.ANY,"123456",condition);
        assertthat(returnCondition).isNotNull();
        assertthat(returnCondition.errors()).isNotEmpty();
        assertthat(returnCondition.errors().size()).isEqualTo(1);

        assertSent(server,defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + "/repos/123456/condition");
    } finally {
        server.shutdown();
    }
}

public void testUpdateCondition() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/default-reviwers-create.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Long requiredApprover = 1L;
        final Matcher matcherSrc = Matcher.create(Matcher.MatcherId.ANY,normalKeyword));
        final CreateCondition condition = CreateCondition.create(10L,requiredApprover);

        final Condition returnCondition = baseApi.defaultReviewersApi().updateCondition(projectKey,10L,"PUT",defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + reposPath + repoKey + "/condition/10");
    } finally {
        server.shutdown();
    }
}

public void testUpdateConditionOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/repository-not-exist.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Long requiredApprover = 1L;
        final Matcher matcherSrc = Matcher.create(Matcher.MatcherId.ANY,defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + "/repos/123456/condition/10");
    } finally {
        server.shutdown();
    }
}

public void testDeleteCondition() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final RequestStatus success = baseApi.defaultReviewersApi().deleteCondition(projectKey,10L);
        assertthat(success).isNotNull();
        assertthat(success.value()).isTrue();
        assertthat(success.errors()).isEmpty();
        assertSent(server,defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + reposPath + repoKey + "/condition/10");
    } finally {
        server.shutdown();
    }
}

public void testDeleteConditionOnError() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/repository-not-exist.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final RequestStatus success = baseApi.defaultReviewersApi().deleteCondition(projectKey,10L);
        assertthat(success).isNotNull();
        assertthat(success.value()).isFalse();
        assertthat(success.errors()).isNotEmpty();
        assertSent(server,defaultReviewersPath + BitbucketApiMetadata.API_VERSION
                + projectsPath + projectKey + reposPath + repoKey + "/condition/10");
    } finally {
        server.shutdown();
    }
}

public void testCreateBranch() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/branch.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final String branchName = "dev-branch";
        final String commitHash = "8d351a10fb428c0c1239530256e21cf24f136e73";

        final CreateBranch createBranch = CreateBranch.create(branchName,null);
        final Branch branch = baseApi.branchApi().create(projectKey,createBranch);
        assertthat(branch).isNotNull();
        assertthat(branch.errors().isEmpty()).isTrue();
        assertthat(branch.id().endsWith(branchName)).isTrue();
        assertthat(commitHash.equalsIgnoreCase(branch.latestChangeset())).isTrue();
        assertSent(server,localRestPath + BitbucketApiMetadata.API_VERSION
                + localProjectsPath + projectKey + localReposPath + repoKey + localBranchesPath);
    } finally {
        server.shutdown();
    }
}

public void testListBranchesNonExistent() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/branch-list-error.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final BranchPage branch = baseApi.branchApi().list(projectKey,1);
        assertthat(branch).isNotNull();
        assertthat(branch.errors().size() > 0).isTrue();
        final List<Veto> vetoes = branch.errors().get(0).vetoes();
        assertthat(vetoes.size() > 0).isTrue();
        assertthat(vetoes.get(0).summaryMessage()).isEqualTo("some short message");
        assertthat(vetoes.get(0).detailedMessage()).isEqualTo("some detailed message");
        final Map<String,"/rest/api/" + BitbucketApiMetadata.API_VERSION
                + localProjectsPath + projectKey + localReposPath + repoKey + "/branches",queryParams);
    } finally {
        server.shutdown();
    }
}

public void testGetBranchModel() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/branch-model.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final BranchModel branchModel = baseApi.branchApi().model(projectKey,repoKey);
        assertthat(branchModel).isNotNull();
        System.out.println(branchModel.errors());
        assertthat(branchModel.errors().isEmpty()).isTrue();
        assertthat(branchModel.types().size() > 0).isTrue();
        assertSent(server,localgetmethod,localRestPath + BitbucketApiMetadata.API_VERSION
                + localProjectsPath + projectKey + localReposPath + repoKey + "/branchmodel");
    } finally {
        server.shutdown();
    }
}

public void testDeleteBranch() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setResponseCode(204));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final RequestStatus success = baseApi.branchApi().delete(projectKey,"refs/heads/some-branch-name");
        assertthat(success).isNotNull();
        assertthat(success.value()).isTrue();
        assertthat(success.errors()).isEmpty();
        assertSent(server,localDeleteMethod,localRestPath + BitbucketApiMetadata.API_VERSION
                + localProjectsPath + projectKey + localReposPath + repoKey + "/branches");
    } finally {
        server.shutdown();
    }
}

public void testGetDefaultBranch() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/branch-default.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final Branch branch = baseApi.branchApi().getDefault(projectKey,repoKey);
        assertthat(branch).isNotNull();
        assertthat(branch.errors().isEmpty()).isTrue();
        assertthat(branch.id()).isNotNull();
        assertSent(server,restBasePath + BitbucketApiMetadata.API_VERSION
                + localProjectsPath + projectKey + localReposPath + repoKey + localBranchesPath + "/default");
    } finally {
        server.shutdown();
    }
}

public void testUpdateDefaultBranch() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setResponseCode(204));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final RequestStatus success = baseApi.branchApi().updateDefault(projectKey,"refs/heads/my-new-default-branch");
        assertthat(success).isNotNull();
        assertthat(success.value()).isTrue();
        assertthat(success.errors()).isEmpty();
        assertSent(server,"/rest/api/" + BitbucketApiMetadata.API_VERSION
                + localProjectsPath + projectKey + localReposPath + repoKey + "/branches/default");
    } finally {
        server.shutdown();
    }
}

public void testListBranchePermissions() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/branch-permission-list.json")).setResponseCode(200));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final BranchRestrictionPage branch = baseApi.branchApi().listBranchRestriction(projectKey,1);
        assertthat(branch).isNotNull();
        assertthat(branch.errors().isEmpty()).isTrue();
        assertthat(branch.values().size() > 0).isTrue();
        assertthat(839L == branch.values().get(0).id()).isTrue();
        assertthat(2 == branch.values().get(0).accessKeys().size()).isTrue();

        final Map<String,?> queryParams = ImmutableMap.of(localLimit,branchPermissionsPath
                + localProjectsPath + projectKey + localReposPath + repoKey + "/restrictions",queryParams);
    } finally {
        server.shutdown();
    }
}

public void testListBranchesPermissionsNonExistent() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setBody(payloadFromresource("/branch-permission-list-error.json")).setResponseCode(404));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final BranchRestrictionPage branch = baseApi.branchApi().listBranchRestriction(projectKey,1);
        assertthat(branch).isNotNull();
        assertthat(branch.errors().size() > 0).isTrue();

        final Map<String,queryParams);
    } finally {
        server.shutdown();
    }
}

public void testUpdateBranchesPermissions() throws Exception {
    final MockWebServer server = mockWebServer();

    server.enqueue(new MockResponse().setResponseCode(204));
    try (final BitbucketApi baseApi = api(server.getUrl("/"))) {

        final List<String> groupPermission = new ArrayList<>();
        groupPermission.add("Test12354");
        final List<Long> listAccessKey = new ArrayList<>();
        listAccessKey.add(123L);
        final List<BranchRestriction> listBranchPermission = new ArrayList<>();
        listBranchPermission.add(BranchRestriction.createWithId(839L,BranchRestrictionEnumType.FAST_FORWARD_ONLY,Matcher.create(Matcher.MatcherId.RELEASE,true),new ArrayList<User>(),groupPermission,listAccessKey));

        final RequestStatus success = baseApi.branchApi().createBranchRestriction(projectKey,listBranchPermission);
        assertthat(success).isNotNull();
        assertthat(success.value()).isTrue();
        assertthat(success.errors()).isEmpty();
        assertSent(server,branchPermissionsPath
                + localProjectsPath + projectKey + localReposPath + repoKey + "/restrictions");
    } finally {
        server.shutdown();
    }
}

@Override
public void initChannel(SocketChannel ch) {
  ChannelPipeline p = ch.pipeline();
  p.addLast(new ReadTimeoutHandler(60,TimeUnit.SECONDS));
  if (sslContext != null) {
    p.addLast(sslContext.newHandler(ch.alloc()));
  }
  p.addLast(new HttpContentCompressor(5));
  p.addLast(new HttpServerCodec());
  p.addLast(new HttpObjectAggregator(1048576));
  p.addLast(new ChunkedWriteHandler());
  if (null != corsConfig) {
    p.addLast(new CorsHandler(corsConfig));
  }
  p.addLast(new WebSocketServerCompressionHandler());
  p.addLast(new WebSocketServerProtocolHandler(webSocketPath,null,true));
  p.addLast(new LaputaServerHandler(null != sslContext,requestProcessor));
}

private void switchToHttp(ChannelHandlerContext ctx) {
    ChannelPipeline p = ctx.pipeline();
    p.addLast(new HttpServerCodec());
    p.addLast(new HttpObjectAggregator(65536));
    p.addLast(new WebSocketServerCompressionHandler());
    p.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,"ws",true));
    p.addLast(new NetoJsonStringToMapWebSocketDecoder());
    p.addLast(new NetoMessagetoWebsocketFrameEncoder());
    p.remove(this);

    // 핸들러를 다시 등록 했으므로 이벤트를 전파
    ctx.fireChannelActive();
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,"binary",true));
    pipeline.addLast(new WebSocketIndexPageHandler(pluginDataFolder));
    pipeline.addLast(new WebSocketFrameHandler(webSocketServerThread,checkIPBans));
}

@Override
protected void initPipeline(ChannelPipeline pipeline) {
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(CC.mp.net.ws_path,true));
    pipeline.addLast(new WebSocketIndexPageHandler());
    pipeline.addLast(getChannelHandler());
}

/**
 * 채널 파이프라인 설정.
 * Netty.Server.Configuration.NettyServerConfiguration 에서 등록한 Bean 을 이용해 사용자의 통신을 처리할 Handler 도 등록.
 * Netty.Server.Handler.JsonHandler 에서 실제 사용자 요청 처리.
 *
 * @param channel
 * @throws Exception
 */
@Override
protected void initChannel(Channel channel) throws Exception {

    ChannelPipeline channelPipeline = channel.pipeline();

    switch (transferType) {

        case "websocket":

            channelPipeline
                    .addLast(new HttpServerCodec())
                    .addLast(new HttpObjectAggregator(65536))
                    .addLast(new WebSocketServerCompressionHandler())
                    .addLast(new WebSocketServerProtocolHandler(transferWebsocketPath,transferWebsocketSubProtocol,transferWebsocketAllowExtensions))
                    .addLast(new LoggingHandler(LogLevel.valueOf(logLevelPipeline)))
                    .addLast(websocketHandler);

        case "tcp":
        default:

            channelPipeline
                    .addLast(new LineBasedFrameDecoder(Integer.MAX_VALUE))
                    .addLast(STRING_DECODER)
                    .addLast(STRING_ENCODER)
                    .addLast(new LoggingHandler(LogLevel.valueOf(logLevelPipeline)))
                    .addLast(jsonHandler);

    }

}

@Override
protected void initChannel(final SocketChannel ch) throws Exception {
    final ChannelPipeline pipeline = ch.pipeline();
       pipeline.addLast(new HttpServerCodec());
       pipeline.addLast(new HttpObjectAggregator(65536));
       pipeline.addLast(new WebSocketServerCompressionHandler());
       pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
       pipeline.addLast(webSockServiceHandler);

}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,subProtocols,true));
    pipeline.addLast(new WebSocketRemoteServerFrameHandler());
}

@Override
public void apply(ChannelPipeline pipeline){
    pipeline.channel().config().setAutoRead(true);
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    if(Config.getInstance().isCompressionEnabled()){
        pipeline.addLast(new WebSocketServerCompressionHandler());
    }
    pipeline.addLast(guicer.inject(new WebSocketValidationHandler()));
    pipeline.addLast(guicer.inject(new WebSocketServerHandler()));
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WebSocketIndexPageHandler(WEBSOCKET_PATH));
    pipeline.addLast(new WebSocketFrameHandler());
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WebSocketIndexPageHandler(WEBSOCKET_PATH));
    pipeline.addLast(new TextWebSocketFrameHandler());
}

@Override
protected void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WatcherServerIndexPageHandler(WEBSOCKET_PATH));
    pipeline.addLast(new WatcherServerHandler());
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    if (sslCtx != null) {
        pipeline.addLast(sslCtx.newHandler(ch.alloc()));
    }
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new WebSocketServerCompressionHandler());
    pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH,true));
    pipeline.addLast(new WebSocketRemoteServerFrameHandler());
}

@Override
protected void initChannel(Channel ch) throws Exception {
  ChannelPipeline pipeline = ch.pipeline();
  // Flash policy file
  if (isFlashSupported) {
    pipeline.addLast(FLASH_POLICY_HANDLER,flashPolicyHandler);
  }
  // SSL
  if (sslContext != null) {
    pipeline.addLast(SSL_HANDLER,sslContext.newHandler(ch.alloc()));
  }

  // HTTP
  pipeline.addLast(HTTP_Request_DECODER,new HttpRequestDecoder());
  pipeline.addLast(HTTP_CHUNK_AGGREGATOR,new HttpObjectAggregator(MAX_HTTP_CONTENT_LENGTH));
  pipeline.addLast(HTTP_RESPONSE_ENCODER,new HttpResponseEncoder());
  if (isHttpCompressionEnabled) {
    pipeline.addLast(HTTP_COMPRESSION,new HttpContentCompressor());
  }

  // Flash resources
  if (isFlashSupported) {
    pipeline.addLast(FLASH_RESOURCE_HANDLER,flashResourceHandler);
  }

  // Socket.IO
  pipeline.addLast(SOCKETIO_PACKET_ENCODER,packetEncoderHandler);
  pipeline.addLast(SOCKETIO_HANDSHAKE_HANDLER,handshakeHandler);
  pipeline.addLast(SOCKETIO_disCONNECT_HANDLER,disconnectHandler);
  if (isWebsocketCompressionEnabled) {
    pipeline.addLast(WEBSOCKET_COMPRESSION,new WebSocketServerCompressionHandler());
  }
  pipeline.addLast(SOCKETIO_WEBSOCKET_HANDLER,webSocketHandler);
  if (isFlashSupported) {
    pipeline.addLast(SOCKETIO_FLASHSOCKET_HANDLER,flashSocketHandler);
  }
  pipeline.addLast(SOCKETIO_XHR_POLLING_HANDLER,xhrPollingHandler);
  if (isJsonpSupported) {
    pipeline.addLast(SOCKETIO_JSONP_POLLING_HANDLER,jsonpPollingHandler);
  }
  pipeline.addLast(SOCKETIO_HEARTBEAT_HANDLER,heartbeatHandler);
  pipeline.addLast(eventExecutorGroup,SOCKETIO_PACKET_disPATCHER,packetdispatcherHandler);

  if (pipelineModifier != null) {
    pipelineModifier.modifyPipeline(pipeline);
  }
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    if (!req.getDecoderResult().isSuccess()
            || (!"websocket".equals(req.headers().get("Upgrade")))) {
        sendHttpResponse(ctx,req,new DefaultFullHttpResponse(
                HttpVersion.HTTP_1_1,HttpResponseStatus.BAD_REQUEST));
        return;
    }
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            "ws://localhost:7777/websocket",null,false);
    socketServerHandshaker = wsFactory.newHandshaker(req);
    if (socketServerHandshaker == null) {
        WebSocketServerHandshakerFactory
                .sendUnsupportedWebSocketVersionResponse(ctx.channel());
    } else {
        socketServerHandshaker.handshake(ctx.channel(),req);
    }
}

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg) throws Exception {
    if(msg instanceof FullHttpRequest){
        FullHttpRequest req = (FullHttpRequest) msg; 

        //check if websocket upgrade encountered
        if(req.headers().contains("Upgrade") || req.headers().contains("upgrade")) {
            WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                    getWebSocketLocation(req,ctx),true,1024 * 1024 * 1024);
            handshaker = wsFactory.newHandshaker(req);
            if (handshaker == null) {
                WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
            } else {
                handshaker.handshake(ctx.channel(),req);
            }
            return;
        }
    }

    super.channelRead(ctx,msg);
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) throws Exception {

// 如果HTTP解码失败，返回HHTP异常
if (!req.getDecoderResult().isSuccess()
    || (!"websocket".equals(req.headers().get("Upgrade")))) {
    sendHttpResponse(ctx,new DefaultFullHttpResponse(HTTP_1_1,BAD_REQUEST));
    return;
}

// 构造握手响应返回，本机测试
WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
    "ws://localhost:8080/websocket",false);
handshaker = wsFactory.newHandshaker(req);
if (handshaker == null) {
    WebSocketServerHandshakerFactory
        .sendUnsupportedWebSocketVersionResponse(ctx.channel());
} else {
    handshaker.handshake(ctx.channel(),req);
}
   }

private void handleHttpRequest(ChannelHandlerContext ctx,HttpRequest req)
        throws Exception {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        sendHttpResponse(ctx,BAD_REQUEST));
        return;
    }

    // Allow only GET methods.
    if (req.getmethod() != GET) {
        sendHttpResponse(ctx,FORBIDDEN));
        return;
    }

    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            getWebSocketLocation(req),false,Integer.MAX_VALUE);
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
    }
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    if (!req.getDecoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) {
        sendHttpResponse(ctx,new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,HttpResponseStatus.BAD_REQUEST));
        return;
    }
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://websocket.url",false);
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        IPusherClient conn=(IPusherClient)ctx.channel();
        String uri=req.getUri();
        handshaker.handshake(ctx.channel(),req);
        onopen(conn,uri);
    }
}

public void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    if (!req.getDecoderResult().isSuccess() || !"websocket".equals(req.headers().get("Upgrade"))) {
        sendHttpResponse(ctx,HttpResponseStatus.BAD_REQUEST));
        return;
    }

    // 构造握手响应返回，本机测试
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://localhost:8080/websocket",false);

    handshaker = wsFactory.newHandshaker(req);

    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
    }
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) throws Exception {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        sendHttpResponse(ctx,false);
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
    }
}

public void doHandshake(ChannelHandlerContext ctx,FullHttpRequest message)
{
    WebSocketServerHandshakerFactory handshakerFactory = new WebSocketServerHandshakerFactory("ws://" + message.headers().get(HOST) + "/" + WEBSOCKET_ROUTE,false);
    this.handshaker = handshakerFactory.newHandshaker(message);
    if (handshaker == null)
    {
        this.log.info("client is incompatible!");
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        return;
    }
    this.log.debug("handshaking Now...");
    this.handshaker.handshake(ctx.channel(),message).addListener((ChannelFutureListener) future -> {
        if (future.isSuccess())
        {
            log.debug("Success!");
        }
        else
        {
            log.debug("Failed!");
        }
    });
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
  if (HttpUtil.is100ContinueExpected(req)) {
    ctx.write(new DefaultFullHttpResponse(HTTP_1_1,CONTINUE));
  }

  if (webSocketPath.equals(req.uri())) {
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
        getWebSocketLocation(req),MAX_FRAME_PAYLOAD_LENGTH
    );

    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
      WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());

    } else {
      handshaker.handshake(ctx.channel(),req);
    }
    return;
  }

  requestProcessor.handleRequest(ctx,req);
}

private void handshake(final ChannelHandlerContext ctx,final FullHttpRequest req,final String requestPath) {
  WebSocketServerHandshakerFactory wsFactory =
      new WebSocketServerHandshakerFactory(getWebSocketLocation(req),maxWebSocketFrameSize);
  WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
  if (handshaker != null) {
    handshaker.handshake(ctx.channel(),req).addListener(
        new ChannelFutureListener() {
          @Override
          public void operationComplete(ChannelFuture future) throws Exception {
            final String sessionId = PipelineUtils.getSessionId(requestPath);
            if (future.isSuccess()) {
              ctx.channel().pipeline().addBefore(
                  SocketIOChannelInitializer.soCKETIO_WEBSOCKET_HANDLER,SocketIOChannelInitializer.WEBSOCKET_FRAME_AGGREGATOR,new WebSocketFrameAggregator(maxWebSocketFrameSize));
              connect(ctx,sessionId);
            } else {
              log.error("Can't handshake: {}",sessionId,future.cause());
            }
          }
        });
  } else {
    WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
  }
}

@Override
public void handleHttpRequest(final ChannelHandlerContext ctx,FullHttpRequest request) throws Exception {
  if ("/api".equals(request.getUri().substring(0,4))) {

    getorCreateTraveler(request);

    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            getWebSocketLocation(request),false);
    handshaker = wsFactory.newHandshaker(request);
    if (handshaker == null) {
      WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
      handshaker.handshake(ctx.channel(),request).addListener(new GenericFutureListener<ChannelFuture>() {
        @Override
        public void operationComplete(ChannelFuture future) throws Exception {
          nettyTraveler.registerWebsocket(ctx);
        }
      });
    }
  } else {
    super.handleHttpRequest(ctx,request);
  }
}

/**
 * handle WebSocket request,then,the the RPC Could happen in WebSocket.
 * 
 * @param ctx
 * @param request
 */
protected void handleWebSocket(final ChannelHandlerContext ctx,FullHttpRequest request) {
    if (logger.isDebugEnabled()) {
        logger.debug("handleWebSocket request: uri={}",request.uri());
    }
    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(request.uri(),true);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(request);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        return;
    }
    ChannelFutureListener callback = websocketHandshakeListener(ctx,request);
    ChannelFuture future = handshaker.handshake(ctx.channel(),request);
    if (callback != null) {
        future.addListener(callback);
    }
    ChannelPipeline pipe = ctx.pipeline();
    if (pipe.get(WebsocketFrameHandler.class) == null) {
        pipe.addAfter(ctx.name(),"wsFrameHandler",new WebsocketFrameHandler(handshaker));
        ChannelHandler handlerAws = pipe.get(AwsProxyProtocolDecoder.class);
        if (handlerAws != null) {
            pipe.remove(handlerAws);
        }
        pipe.remove(ctx.name());// Remove current Handler
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,FullHttpRequest req) throws Exception {
    if (!req.decoderResult().isSuccess()) {
        sendHttpResponse(ctx,BAD_REQUEST));
        return;
    }
    // Allow only GET methods.
    if (req.method() != GET) {
        sendHttpResponse(ctx,FORBIDDEN));
        return;
    }

    /**
     * 当且仅当uri为指定path的时候,进行websocket通讯的升级
     * */
    if (uri.equals(req.uri())
            //CONNECTION 字段的值为 UPGRADE,firefox上存在多个值的情况
            && req.headers().get(HttpHeaderNames.CONNECTION).contains(HttpHeaderValues.UPGRADE)
            //UPGRADE 字段的值为 WEBSOCKET
            && HttpHeaderValues.WEBSOCKET.contentEqualsIgnoreCase(req.headers().get(HttpHeaderNames.UPGRADE))
            ) {
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                uri,subprotocols,5 * 1024 * 1024);
        WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            //不支持的协议
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            //握手结束后补充如下协议
            handshaker.handshake(ctx.channel(),req);
        }
        return;
    }
    //错误的情况
    sendHttpResponse(ctx,NOT_FOUND));
}

/**
 * Handle hand shake.
 *
 * @param ctx the ctx
 * @param req the req
 */
private void handleHandShake(ChannelHandlerContext ctx,FullHttpRequest req) {
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(getWebSocketLocation(req),(int) Config.getInstance().getMaxSize());
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
        dominoServer.onopen(this.newWrapper(ctx),req);
    }
}

/**
 * Handler to open the websocket for the real-time message websocket
 * 
 * @param ChannelHandlerContext,*            FullHttpRequest
 * @return void
 */
public void handle(ChannelHandlerContext ctx,HttpRequest req) throws Exception {
    String uri = req.getUri();
    uri = uri.substring(1);
    String[] tokens = uri.split("/");
    String publisherId;

    if (tokens.length < 5) {
        LoggingService.logWarning(MODULE_NAME," Missing ID or ID value in URL ");
        return;
    } else {
        publisherId = tokens[4].trim().split("\\?")[0];
    }

    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(getWebSocketLocation(req),req);
    }

    Hashtable<String,ChannelHandlerContext> messageSocketMap = WebSocketMap.messageWebsocketMap;
    messageSocketMap.put(publisherId,ctx);
    StatusReporter.setLocalApiStatus().setopenConfigSocketsCount(WebSocketMap.messageWebsocketMap.size());
    MessageBus.getInstance().enableRealTimeReceiving(publisherId);

    LoggingService.logInfo(MODULE_NAME,"Handshake end....");
    return;
}

/**
 * Handler to open the websocket for the real-time control signals
 * 
 * @param ChannelHandlerContext,HttpRequest req) throws Exception {
    String uri = req.getUri();
    uri = uri.substring(1);
    String[] tokens = uri.split("/");

    String id;

    if (tokens.length < 5) {
        LoggingService.logWarning(MODULE_NAME," Missing ID or ID value in URL ");
        return;
    } else {
        id = tokens[4].trim();
    }

    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(getWebSocketLocation(req),req);
    }

    WebSocketMap.addWebsocket('C',id,ctx);
    StatusReporter.setLocalApiStatus().setopenConfigSocketsCount(WebSocketMap.controlWebsocketMap.size());

    return;
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        logger.warn(String.format("Bad request: %s",req.getUri()));
        sendHttpResponse(ctx,BAD_REQUEST));
        return;
    }

    // Allow only GET methods.
    if (req.getmethod() != GET) {
        logger.warn(String.format("Unsupported HTTP method: %s",req.getmethod()));
        sendHttpResponse(ctx,FORBIDDEN));
        return;
    }

    // enable subclasses to do additional processing
    if (!additionalHttpRequestHandler(ctx,req)) {
        return;
    }

    // Handshake
    WebSocketServerHandshakerFactory wsFactory
        = new WebSocketServerHandshakerFactory(getWebSocketLocation(req),true);

    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
        WebsocketSinkServer.channels.add(ctx.channel());
    }
}

private void handleWebSocketRequest(@NotNull final ChannelHandlerContext context,@NotNull FullHttpRequest request,@NotNull final QueryStringDecoder uriDecoder) {
  WebSocketServerHandshakerFactory factory = new WebSocketServerHandshakerFactory("ws://" + request.headers().getAsstring(HttpHeaderNames.HOST) + uriDecoder.path(),NettyUtil.MAX_CONTENT_LENGTH);
  WebSocketServerHandshaker handshaker = factory.newHandshaker(request);
  if (handshaker == null) {
    WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(context.channel());
    return;
  }

  if (!context.channel().isopen()) {
    return;
  }

  final Client client = new WebSocketClient(context.channel(),handshaker);
  context.attr(ClientManager.CLIENT).set(client);
  handshaker.handshake(context.channel(),request).addListener(new ChannelFutureListener() {
    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
      if (future.isSuccess()) {
        ClientManager clientManager = WebSocketHandshakeHandler.this.clientManager.getValue();
        clientManager.addClient(client);
        MessageChannelHandler messageChannelHandler = new MessageChannelHandler(clientManager,getMessageServer());
        BuiltInServer.replaceDefaultHandler(context,messageChannelHandler);
        ChannelHandlerContext messageChannelHandlerContext = context.pipeline().context(messageChannelHandler);
        context.pipeline().addBefore(messageChannelHandlerContext.name(),"webSocketFrameAggregator",new WebSocketFrameAggregator(NettyUtil.MAX_CONTENT_LENGTH));
        messageChannelHandlerContext.attr(ClientManager.CLIENT).set(client);
        connected(client,uriDecoder.parameters());
      }
    }
  });
}

public DefaultWebSocketHttpResponse(HttpVersion version,HttpResponseStatus status,Processor<WebSocketFrame,WebSocketFrame> processor,WebSocketServerHandshakerFactory handshakerFactory) {
    super(version,status);
    this.processor = processor;
    this.handshakerFactory = handshakerFactory;
}

public DefaultWebSocketHttpResponse(HttpVersion version,boolean validateHeaders,status,validateHeaders);
    this.processor = processor;
    this.handshakerFactory = handshakerFactory;
}

@Override
public boolean call(NettyHandler handler,ChannelHandlerContext ctx,FullHttpRequest req,Map<String,String> params) throws IOException {
    WebSocketServerHandshaker handshaker = new WebSocketServerHandshakerFactory(
                                                String.format("ws://%s%s",req.headers().get(Names.HOST),pattern),true
                                            ).newHandshaker(req);

    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        WebSocket ws = getCallback().newInstance(new WrappedRequest<>(req,params,sessions));

        if (ws instanceof WebSocket) {
            Channel ch = handshaker.handshake(ctx.channel(),req).channel();
            handler.onWsFrame(new WsBridge(handshaker,ch,ws));
            ws.onopen();
        } else {
            FullHttpResponse forbidden = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,HttpResponseStatus.FORBIDDEN);
            ByteBufUtil.writeUtf8(forbidden.content(),"Forbidden.");

            ctx.writeAndFlush(forbidden);
            ctx.close();
        }
    }

    return true;
}

@Override
public void handle(RakamHttpRequest request) {
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            getWebSocketLocation(request),true);
    handshaker = wsFactory.newHandshaker(request.getRequest());
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(request.context().channel());
    } else {
        HttpRequest request1 = request.getRequest();
        DefaultFullHttpRequest defaultFullHttpRequest = new DefaultFullHttpRequest(request1.getProtocolVersion(),request1.getmethod(),request1.getUri());
        defaultFullHttpRequest.headers().set(request1.headers());
        handshaker.handshake(request.context().channel(),defaultFullHttpRequest);
        onopen(new WebSocketRequest(request));
    }
}

/**
 * Handles incoming http request pointing. Parts of the code were copied from {@linkplain http://netty.io} web socket server example. 
 * The origins may be found at: {@linkplain https://github.com/netty/netty/blob/4.0/example/src/main/java/io/netty/example/http/websocketx/server/WebSocketServerHandler.java} 
 * @param ctx
 * @param req
 */
private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {

    // handle bad requests as indicated by decoder
       if (!req.getDecoderResult().isSuccess()) {
           sendHttpResponse(ctx,BAD_REQUEST));
           return;
       }

       // allow only GET methods to comply with REST spec as this is not about modifying content
       // but receiving it ;-)
       if (req.getmethod() != GET) {
           sendHttpResponse(ctx,FORBIDDEN));
           return;
       }

       // Handshake
       String wsLocation = "ws://" + req.headers().get(HOST) + WEBSOCKET_PATH;
       WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
               wsLocation,true);
       handshaker = wsFactory.newHandshaker(req);
       if (handshaker == null) {
           WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
       } else {
           handshaker.handshake(ctx.channel(),req);
       }
   }

@Override
public HandshakeFuture handshake() {
    WebSocketServerHandshakerFactory wsFactory =
            new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),true);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(httpRequest);
    return handleHandshake(handshaker,0);
}

@Override
public HandshakeFuture handshake(String[] subProtocols,boolean allowExtensions) {
    WebSocketServerHandshakerFactory wsFactory =
            new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),getSubProtocolsCSV(subProtocols),allowExtensions);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(httpRequest);
    return handleHandshake(handshaker,boolean allowExtensions,int idleTimeout) {
    WebSocketServerHandshakerFactory wsFactory =
            new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),idleTimeout);
}

@Override
public void cancelHandShake(int closeCode,String closeReason) {
    try {
        WebSocketServerHandshakerFactory wsFactory =
                new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),getSubProtocol(),true);
        WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(httpRequest);
        ChannelFuture channelFuture =
                handshaker.close(ctx.channel(),new CloseWebSocketFrame(closeCode,closeReason));
        channelFuture.channel().close();
    } finally {
        isCancelled = true;
    }
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) throws Exception {
   // Allow only GET methods.
   if (req.method() != GET) {
      sendHttpResponse(ctx,FORBIDDEN));
      return;
   }

   // Handshake
   String supportedProtocolsCSV = StringUtil.joinStringList(supportedProtocols,",");
   WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(this.getWebSocketLocation(req),supportedProtocolsCSV,maxFramePayloadLength);
   this.httpRequest = req;
   this.handshaker = wsFactory.newHandshaker(req);
   if (this.handshaker == null) {
      WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
   } else {
      ChannelFuture handshake = this.handshaker.handshake(ctx.channel(),req);
      handshake.addListener(new ChannelFutureListener() {

         @Override
         public void operationComplete(ChannelFuture future) throws Exception {
            if (future.isSuccess()) {
               // we need to insert an encoder that takes the underlying ChannelBuffer of a StompFrame.toActiveMQBuffer and
               // wrap it in a binary web socket frame before letting the wsencoder send it on the wire
               future.channel().pipeline().addAfter("wsencoder","binary-websocket-encoder",BINARY_WEBSOCKET_ENCODER);
            } else {
               // Handshake Failed,fire an exceptionCaught event
               future.channel().pipeline().fireExceptionCaught(future.cause());
            }
         }
      });
   }
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    // Handle a bad request.
    if (!req.decoderResult().isSuccess()) {
        sendHttpResponse(ctx,BAD_REQUEST));
        return;
    }

    // Allow only GET methods.
    if (req.method() != GET) {
        sendHttpResponse(ctx,FORBIDDEN));
        return;
    }

    if ("/favicon.ico".equals(req.uri())) {
        FullHttpResponse res = new DefaultFullHttpResponse(HTTP_1_1,NOT_FOUND);
        sendHttpResponse(ctx,res);
        return;
    }
    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            getWebSocketLocation(req),true);
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
        ctx.writeAndFlush(new TextWebSocketFrame("{\"session\" : \"" + ctx.channel().id().asShortText() + "\"}"));
    }
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req)
        throws Exception {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        sendHttpResponse(ctx,BAD_REQUEST));
        req.release();
        return;
    }

    // Allow only GET methods.
    if (req.getmethod() != GET) {
        sendHttpResponse(ctx,FORBIDDEN));
        req.release();
        return;
    }

    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            getWebSocketLocation(req),Integer.MAX_VALUE);
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
    } else {
        handshaker.handshake(ctx.channel(),req);
    }
    req.release();
}

public ChannelHandler serverHandshake(ChannelHandlerContext ctx,FullHttpRequest msg)
{

    this.ctx = ctx;
    // Handshake
    WebSocketServerHandshaker handshaker;
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(getWebSocketLocation(msg),true);
    handshaker = wsFactory.newHandshaker(msg);
    if (handshaker == null)
    {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    }
    else
    {
        ChannelPromise promise = ctx.channel().newPromise();
        promise.addListener(future -> {
            if (promise.isSuccess())
            {
                this.notifyopen();
            }
            else
            {
                this.notifyError();
            }
        });
        handshaker.handshake(ctx.channel(),msg,promise);
    }

    return new MyChannelHandler((ctx1,frame) -> {
        handshaker.close(ctx1.channel(),(CloseWebSocketFrame) frame.retain());
    });
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        sendErrorResponse(ctx,BAD_REQUEST);
        return;
    }
    // Allow only GET methods.
    if (req.getmethod() != GET) {
        sendErrorResponse(ctx,FORBIDDEN);
        return;
    }

    String path = req.getUri();
    System.out.println("Server => Request: " + path);
    try {
        if (path.equals("/ws")) {
            isWebSocket = true;
            String wsLocation = getWebSocketLocation(ctx,req);
            WebSocketServerHandshaker handshaker = new WebSocketServerHandshakerFactory(
                    wsLocation,64 * 1024).newHandshaker(req);
            if (handshaker == null) {
                WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel())
                                                .addListener(ChannelFutureListener.CLOSE);
            } else {
                handshaker.handshake(ctx.channel(),req);
                // Push the initial state to the client.
                // Do it from the server thread were it's safe
                bossGroup.execute(() -> {
                    ctx.writeAndFlush(makeWebSocketEventFrame("stateChanged",lastState));
                });
                wsConnections.add(ctx.channel());
            }
        } 
        else {
            handleStaticFileRequest(ctx,path);
        }
    } catch (Throwable e) {
        sendErrorResponse(ctx,BAD_REQUEST);
    }
}

private void handleWebSocketHandshake(ChannelHandlerContext ctx,FullHttpRequest req){
    String location = "ws://" + req.headers().get(HOST) + req.getUri();

    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
            location,false);
    _handshaker = wsFactory.newHandshaker(req);
    if (_handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
    } else {
        _handshaker.handshake(ctx.channel(),req);
    }

}

private void handleHttpRequest(ChannelHandlerContext ctx,req);
    }
    req.release();
}

@SuppressWarnings("unchecked")
@Override
public <T> T upgrade(final Class<T> type) throws Exception {
  if (type == NativeWebSocket.class) {
    String protocol = ifSecure("wss","ws");
    String webSocketURL = protocol + "://" + req.headers().get(HttpHeaderNames.HOST) + path;

    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
        webSocketURL,wsMaxMessageSize);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
    NettyWebSocket result = new NettyWebSocket(ctx,handshaker,(ws) -> {
      handshaker.handshake(ctx.channel(),(FullHttpRequest) req)
          .addListener(FIRE_EXCEPTION_ON_FAILURE)
          .addListener(payload -> ws.connect())
          .addListener(FIRE_EXCEPTION_ON_FAILURE);
    });
    ctx.channel().attr(NettyWebSocket.KEY).set(result);
    return (T) result;
  } else if (type == Sse.class) {
    NettySse sse = new NettySse(ctx);
    return (T) sse;
  } else if (type == NativePushPromise.class) {
    return (T) new NettyPush(ctx,req.headers().getInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text()),header("host").orElse(ip()),ifSecure("https","http"));
  }
  throw new UnsupportedOperationException("Not Supported: " + type);
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    if (!req.decoderResult().isSuccess()) {
        sendHttpResponse(ctx,BAD_REQUEST));
        return;
    }

    if (req.method() != GET) {
        sendHttpResponse(ctx,FORBIDDEN));
        return;
    }

    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(req.uri(),false);
    handshaker = wsFactory.newHandshaker(req);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        return;
    }

    try {
        Channel ch = ctx.channel();
        this.connection = this.newConnection(ctx,req);
        handshaker.handshake(ch,req);
    } catch (Exception e) {
        logger.error("handshake error",e);
        sendHttpResponse(ctx,UNAUTHORIZED));
    }
}

@Override
@SuppressWarnings("PMD.OnlyOneReturn")
public void channelRead(ChannelHandlerContext ctx,Object msg) throws Exception {
    if (msg instanceof FullHttpRequest) {
        FullHttpRequest req = (FullHttpRequest) msg;

        // Handle a bad request.
        if (!req.decoderResult().isSuccess()) {
            sendHttpResponse(ctx,BAD_REQUEST));
            return;
        }

        // Allow only GET methods.
        if (req.method() != GET) {
            sendHttpResponse(ctx,FORBIDDEN));
            return;
        }

        // Handshake
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                getWebSocketLocation(req),false);
        WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(),req);
        }
    } else {
        ctx.fireChannelRead(msg);
    }
}

protected void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) throws Exception {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        httpFileHandler.sendError(ctx,HttpResponseStatus.BAD_REQUEST);
        return;
    }

    // If you're going to do normal HTTP POST authentication before upgrading the
    // WebSocket,the recommendation is to handle it right here
    if (req.getmethod() == HttpMethod.POST) {
        httpFileHandler.sendError(ctx,HttpResponseStatus.FORBIDDEN);
        return;
    }

    // Allow only GET methods.
    if (req.getmethod() != HttpMethod.GET) {
        httpFileHandler.sendError(ctx,HttpResponseStatus.FORBIDDEN);
        return;
    }

    // Send the demo page and favicon.ico
    if ("/".equals(req.getUri())) {
        httpFileHandler.sendRedirect(ctx,"/index.html");
        return;
    }

    // check for websocket upgrade request
    String upgradeHeader = req.headers().get("Upgrade");
    if (upgradeHeader != null && "websocket".equalsIgnoreCase(upgradeHeader)) {
        // Handshake. Ideally you'd want to configure your websocket uri
        String url = "ws://" + req.headers().get("Host") + "/marketdata";
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(url,false);
        handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        }
        else {
            handshaker.handshake(ctx.channel(),req);
        }
    }
    else {
        boolean handled = handleREST(ctx,req);
        if (!handled) {
            httpFileHandler.sendFile(ctx,req);
        }
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object req) throws Exception {
    if (req instanceof FullHttpRequest) {
        FullHttpRequest request = (FullHttpRequest) req;
        // ----- Client authenticity check code -----
        // !!!!! WARNING !!!!!
        // THE BELOW SECTION OF CODE CHECKS TO ENSURE THAT CONNECTIONS ARE COMING
        // FROM THE OFFICIAL AGAR.IO CLIENT. IF YOU REMOVE OR MODIFY THE BELOW
        // SECTION OF CODE TO ALLOW CONNECTIONS FROM A CLIENT ON A DIFFERENT DOMAIN,// YOU MAY BE COMMITTING copYRIGHT INFRINGEMENT AND LEgal ACTION MAY BE TAKEN
        // AGAINST YOU. THIS SECTION OF CODE WAS ADDED ON JULY 9,2015 AT THE REQUEST
        // OF THE AGAR.IO DEVELOPERS.
        /*String origin = request.headers().get(HttpHeaders.ORIGIN);
        if (origin != null) {
            switch (origin) {
                case "http://agar.io":
                case "https://agar.io":
                case "http://localhost":
                case "https://localhost":
                case "http://127.0.0.1":
                case "https://127.0.0.1":
                    break;
                default:
                    ctx.channel().close();
                    return;
            }
        }*/
        // -----/Client authenticity check code -----

        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://" + request.headers().get(HttpHeaders.HOST) + "/",true);
        handshaker = wsFactory.newHandshaker(request);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(),request);
        }
    } else if (req instanceof WebSocketFrame) {
        WebSocketFrame frame = (WebSocketFrame) req;

        if (req instanceof CloseWebSocketFrame) {
            if (handshaker != null) {
                handshaker.close(ctx.channel(),((CloseWebSocketFrame) req).retain());
            }
        } else if (req instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        } else {
            ctx.fireChannelRead(frame.retain());
        }
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,Object req) throws Exception {
    if (req instanceof FullHttpRequest) {
        FullHttpRequest request = (FullHttpRequest) req;
        // ----- Client authenticity check code -----
        /*String origin = request.headers().get(HttpHeaders.ORIGIN);
        if (origin != null) {
            switch (origin) {
                case "http://localhost":
                case "https://localhost":
                case "http://127.0.0.1":
                case "https://127.0.0.1":
                    break;
                default:
                    ctx.channel().close();
                    return;
            }
        }*/
        // -----/Client authenticity check code -----

        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://" + request.headers().get(HttpHeaders.HOST) + "/",true);
        mHandshaker = wsFactory.newHandshaker(request);
        if (mHandshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            mHandshaker.handshake(ctx.channel(),request);
        }
    } else if (req instanceof WebSocketFrame) {
        WebSocketFrame frame = (WebSocketFrame) req;

        if (req instanceof CloseWebSocketFrame) {
            if (mHandshaker != null) {
                mHandshaker.close(ctx.channel(),((CloseWebSocketFrame) req).retain());
            }
        } else if (req instanceof PingWebSocketFrame) {
            ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
        } else {
            ctx.fireChannelRead(frame.retain());
        }
    }
}

@SuppressWarnings("unchecked")
@Test
public void close() throws Exception {
  new MockUnit(ChannelHandlerContext.class,WebSocketServerHandshaker.class,Consumer.class)
      .expect(channel)
      .expect(close)
      .expect(unit -> {
        Attribute<NettyWebSocket> attr = unit.mock(Attribute.class);
        attr.set(null);

        Channel ctx = unit.get(Channel.class);
        expect(ctx.attr(NettyWebSocket.KEY)).andReturn(attr);
      })
      .run(unit -> {
        new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(WebSocketServerHandshaker.class),unit.get(Consumer.class)).close(1001,"normal");
      });
}

@SuppressWarnings("unchecked")
@Test
public void closeNoAttr() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(channel)
      .expect(close)
      .expect(unit -> {
        Channel ctx = unit.get(Channel.class);
        expect(ctx.attr(NettyWebSocket.KEY)).andReturn(null);
      })
      .run(unit -> {
        new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),"normal");
      });
}

@SuppressWarnings("unchecked")
@Test
public void resume() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        ChannelConfig chconf = unit.mock(ChannelConfig.class);
        expect(chconf.isAutoRead()).andReturn(false);
        expect(chconf.setAutoRead(true)).andReturn(chconf);

        Channel ch = unit.mock(Channel.class);
        expect(ch.config()).andReturn(chconf);

        ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
        expect(ctx.channel()).andReturn(ch);
      })
      .run(unit -> {
        new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(Consumer.class)).resume();
      });
}

@SuppressWarnings("unchecked")
@Test
public void resumeIgnored() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        ChannelConfig chconf = unit.mock(ChannelConfig.class);
        expect(chconf.isAutoRead()).andReturn(true);

        Channel ch = unit.mock(Channel.class);
        expect(ch.config()).andReturn(chconf);

        ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
        expect(ctx.channel()).andReturn(ch);
      })
      .run(unit -> {
        new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(Consumer.class)).resume();
      });
}

@SuppressWarnings("unchecked")
@Test
public void pause() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        ChannelConfig chconf = unit.mock(ChannelConfig.class);
        expect(chconf.isAutoRead()).andReturn(true);
        expect(chconf.setAutoRead(false)).andReturn(chconf);

        Channel ch = unit.mock(Channel.class);
        expect(ch.config()).andReturn(chconf);

        ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
        expect(ctx.channel()).andReturn(ch);
      })
      .run(unit -> {
        new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(Consumer.class)).pause();
      });
}

@SuppressWarnings("unchecked")
@Test
public void pauseIgnored() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        ChannelConfig chconf = unit.mock(ChannelConfig.class);
        expect(chconf.isAutoRead()).andReturn(false);

        Channel ch = unit.mock(Channel.class);
        expect(ch.config()).andReturn(chconf);

        ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
        expect(ctx.channel()).andReturn(ch);
      })
      .run(unit -> {
        new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(Consumer.class)).pause();
      });
}

@SuppressWarnings("unchecked")
@Test
public void terminate() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class,BiConsumer.class)
          .expect(unit -> {
            BiConsumer<Integer,Optional<String>> callback = unit.get(BiConsumer.class);
            callback.accept(1006,Optional.of("Harsh disconnect"));

            ChannelFuture future = unit.mock(ChannelFuture.class);
            expect(future.addListener(CLOSE)).andReturn(future);

            ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
            expect(ctx.disconnect()).andReturn(future);
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.onCloseMessage(unit.get(BiConsumer.class));
            ws.terminate();
          });
}

@SuppressWarnings("unchecked")
@Test
public void isopen() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        Channel ch = unit.mock(Channel.class);
        expect(ch.isopen()).andReturn(true);

        ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
        expect(ctx.channel()).andReturn(ch);
      })
      .run(unit -> {
        assertEquals(true,new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(Consumer.class)).isopen());
      });
}

@SuppressWarnings("unchecked")
@Test
public void isNoopen() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        Channel ch = unit.mock(Channel.class);
        expect(ch.isopen()).andReturn(false);

        ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
        expect(ctx.channel()).andReturn(ch);
      })
      .run(unit -> {
        assertEquals(false,unit.get(Consumer.class)).isopen());
      });
}

@SuppressWarnings("unchecked")
@Test
public void connect() throws Exception {
  new MockUnit(ChannelHandlerContext.class,CountDownLatch.class,Runnable.class)
          .expect(unit -> {
            CountDownLatch ready = unit.mockConstructor(CountDownLatch.class,new Class[]{int.class },1);
            ready.countDown();

            unit.get(Runnable.class).run();
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.onConnect(unit.get(Runnable.class));
            ws.connect();
          });
}

@SuppressWarnings("unchecked")
@Test
public void hankshake() throws Exception {
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
          .expect(unit -> {

            unit.get(Consumer.class).accept(isA(NettyWebSocket.class));
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.hankshake();
          });
}

@SuppressWarnings("unchecked")
@Test
public void handleTextFrame() throws Exception {
  new MockUnit(ChannelHandlerContext.class,TextWebSocketFrame.class)
          .expect(unit -> {
            CountDownLatch ready = unit.mockConstructor(CountDownLatch.class,1);
            ready.await();

            TextWebSocketFrame frame = unit.get(TextWebSocketFrame.class);
            expect(frame.text()).andReturn("text");

            Consumer<String> callback = unit.get(Consumer.class);
            callback.accept("text");
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.onTextMessage(unit.get(Consumer.class));
            ws.handle(unit.get(TextWebSocketFrame.class));
          });
}

@SuppressWarnings("unchecked")
@Test
public void handleInterruped() throws Exception {
  new MockUnit(ChannelHandlerContext.class,WebSocketFrame.class)
          .expect(unit -> {
            CountDownLatch ready = unit.mockConstructor(CountDownLatch.class,1);
            ready.await();
            expectLastCall().andThrow(new InterruptedException("intentional err"));

            Thread thread = unit.mock(Thread.class);
            thread.interrupt();

            unit.mockStatic(Thread.class);
            expect(Thread.currentThread()).andReturn(thread);
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.handle(unit.get(WebSocketFrame.class));
          });
}

@SuppressWarnings("unchecked")
@Test
public void handleException() throws Exception {
  Throwable cause = new NullPointerException("intentional err");
  new MockUnit(ChannelHandlerContext.class,Consumer.class)
      .expect(unit -> {
        CountDownLatch ready = unit.mockConstructor(CountDownLatch.class,1);
        ready.await();

        Consumer<Throwable> callback = unit.get(Consumer.class);
        callback.accept(cause);
      })
      .run(unit -> {
        NettyWebSocket ws = new NettyWebSocket(
            unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
        ws.onErrorMessage(unit.get(Consumer.class));
        ws.handle(cause);
      });
}

private void handshake(final ChannelHandlerContext ctx,final FullHttpRequest req,final String requestPath) {
  WebSocketServerHandshakerFactory wsFactory =
      new WebSocketServerHandshakerFactory(getWebSocketLocation(req),null,true,maxWebSocketFrameSize);
  WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
  if (handshaker != null) {
    handshaker.handshake(ctx.channel(),req).addListener(
        new ChannelFutureListener() {
          @Override
          public void operationComplete(ChannelFuture future) throws Exception {
            final String sessionId = PipelineUtils.getSessionId(requestPath);
            if (future.isSuccess()) {
              ctx.channel().pipeline().addBefore(
                  SocketIOChannelInitializer.soCKETIO_WEBSOCKET_HANDLER,SocketIOChannelInitializer.WEBSOCKET_FRAME_AGGREGATOR,new WebSocketFrameAggregator(maxWebSocketFrameSize));
              connect(ctx,req,sessionId);
            } else {
              log.error("Can't handshake: {}",sessionId,future.cause());
            }
          }
        });
  } else {
    WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
  }
}

/**
 * handle WebSocket request,then,the the RPC Could happen in WebSocket.
 * 
 * @param ctx
 * @param request
 */
protected void handleWebSocket(final ChannelHandlerContext ctx,FullHttpRequest request) {
    if (logger.isDebugEnabled()) {
        logger.debug("handleWebSocket request: uri={}",request.uri());
    }
    // Handshake
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(request.uri(),true);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(request);
    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        return;
    }
    ChannelFutureListener callback = websocketHandshakeListener(ctx,request);
    ChannelFuture future = handshaker.handshake(ctx.channel(),request);
    if (callback != null) {
        future.addListener(callback);
    }
    ChannelPipeline pipe = ctx.pipeline();
    if (pipe.get(WebsocketFrameHandler.class) == null) {
        pipe.addAfter(ctx.name(),"wsFrameHandler",new WebsocketFrameHandler(handshaker));
        ChannelHandler handlerAws = pipe.get(AwsProxyProtocolDecoder.class);
        if (handlerAws != null) {
            pipe.remove(handlerAws);
        }
        pipe.remove(ctx.name());// Remove current Handler
    }
}

@Override
protected void channelRead0(ChannelHandlerContext ctx,FullHttpRequest req) throws Exception {
    if (!req.decoderResult().isSuccess()) {
        sendHttpResponse(ctx,new DefaultFullHttpResponse(HTTP_1_1,BAD_REQUEST));
        return;
    }
    // Allow only GET methods.
    if (req.method() != GET) {
        sendHttpResponse(ctx,FORBIDDEN));
        return;
    }

    /**
     * 当且仅当uri为指定path的时候,进行websocket通讯的升级
     * */
    if (uri.equals(req.uri())
            //CONNECTION 字段的值为 UPGRADE,firefox上存在多个值的情况
            && req.headers().get(HttpHeaderNames.CONNECTION).contains(HttpHeaderValues.UPGRADE)
            //UPGRADE 字段的值为 WEBSOCKET
            && HttpHeaderValues.WEBSOCKET.contentEqualsIgnoreCase(req.headers().get(HttpHeaderNames.UPGRADE))
            ) {
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                uri,subprotocols,5 * 1024 * 1024);
        WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            //不支持的协议
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            //握手结束后补充如下协议
            handshaker.handshake(ctx.channel(),req);
        }
        return;
    }
    //错误的情况
    sendHttpResponse(ctx,NOT_FOUND));
}

public WebSocketClient(@NotNull Channel channel,@NotNull WebSocketServerHandshaker handshaker) {
  super(channel);

  this.handshaker = handshaker;
}

private void handleWebSocketRequest(@NotNull final ChannelHandlerContext context,@NotNull FullHttpRequest request,@NotNull final QueryStringDecoder uriDecoder) {
  WebSocketServerHandshakerFactory factory = new WebSocketServerHandshakerFactory("ws://" + request.headers().getAsstring(HttpHeaderNames.HOST) + uriDecoder.path(),false,NettyUtil.MAX_CONTENT_LENGTH);
  WebSocketServerHandshaker handshaker = factory.newHandshaker(request);
  if (handshaker == null) {
    WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(context.channel());
    return;
  }

  if (!context.channel().isopen()) {
    return;
  }

  final Client client = new WebSocketClient(context.channel(),handshaker);
  context.attr(ClientManager.CLIENT).set(client);
  handshaker.handshake(context.channel(),request).addListener(new ChannelFutureListener() {
    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
      if (future.isSuccess()) {
        ClientManager clientManager = WebSocketHandshakeHandler.this.clientManager.getValue();
        clientManager.addClient(client);
        MessageChannelHandler messageChannelHandler = new MessageChannelHandler(clientManager,getMessageServer());
        BuiltInServer.replaceDefaultHandler(context,messageChannelHandler);
        ChannelHandlerContext messageChannelHandlerContext = context.pipeline().context(messageChannelHandler);
        context.pipeline().addBefore(messageChannelHandlerContext.name(),"webSocketFrameAggregator",new WebSocketFrameAggregator(NettyUtil.MAX_CONTENT_LENGTH));
        messageChannelHandlerContext.attr(ClientManager.CLIENT).set(client);
        connected(client,uriDecoder.parameters());
      }
    }
  });
}

private void handleWebSocketResponse(ChannelHandlerContext ctx,Outgoing out) {
    WebSocketHttpResponse response = (WebSocketHttpResponse) out.message;
    WebSocketServerHandshaker handshaker = response.handshakerFactory().newHandshaker(lastRequest);

    if (handshaker == null) {
        HttpResponse res = new DefaultFullHttpResponse(
                HttpVersion.HTTP_1_1,HttpResponseStatus.UPGRADE_required);
        res.headers().set(HttpHeaderNames.SEC_WEBSOCKET_VERSION,WebSocketVersion.V13.toHttpHeaderValue());
        HttpUtil.setContentLength(res,0);
        super.unbufferedWrite(ctx,new Outgoing(res,out.promise));
        response.subscribe(new CancelledSubscriber<>());
    } else {
        // First,insert new handlers in the chain after us for handling the websocket
        ChannelPipeline pipeline = ctx.pipeline();
        HandlerPublisher<WebSocketFrame> publisher = new HandlerPublisher<>(ctx.executor(),WebSocketFrame.class);
        HandlerSubscriber<WebSocketFrame> subscriber = new HandlerSubscriber<>(ctx.executor());
        pipeline.addAfter(ctx.executor(),ctx.name(),"websocket-subscriber",subscriber);
        pipeline.addAfter(ctx.executor(),"websocket-publisher",publisher);

        // Now remove ourselves from the chain
        ctx.pipeline().remove(ctx.name());

        // Now do the handshake
        // Wrap the request in an empty request because we don't need the WebSocket handshaker ignoring the body,// we already have handled the body.
        handshaker.handshake(ctx.channel(),new EmptyHttpRequest(lastRequest));

        // And hook up the subscriber/publishers
        response.subscribe(subscriber);
        publisher.subscribe(response);
    }

}

public NettyServerWebSocket(ChannelHandlerContext context,FullHttpRequest req,WebSocketServerHandshaker handshaker) {
  this.context = context;
  this.request = req;
  this.handshaker = handshaker;
}

@Override
public <T> T unwrap(Class<T> clazz) {
  return ChannelHandlerContext.class.isAssignableFrom(clazz) ?
    clazz.cast(context) :
    WebSocketServerHandshaker.class.isAssignableFrom(clazz) ?
      clazz.cast(handshaker) :
      FullHttpRequest.class.isAssignableFrom(clazz) ?
        clazz.cast(request) :
        null;
}

@Test
public void unwrap() throws Throwable {
  websocketAction(new Action<ServerWebSocket>() {
    @Override
    public void on(ServerWebSocket ws) {
      threadAssertTrue(ws.unwrap(ChannelHandlerContext.class) instanceof ChannelHandlerContext);
      threadAssertTrue(ws.unwrap(WebSocketServerHandshaker.class) instanceof
        WebSocketServerHandshaker);
      threadAssertTrue(ws.unwrap(FullHttpRequest.class) instanceof FullHttpRequest);
      resume();
    }
  });
  client.connect(new WebSocketAdapter(),URI.create(uri()));
  await();
}

@Override
public boolean call(NettyHandler handler,ChannelHandlerContext ctx,Map<String,String> params) throws IOException {
    WebSocketServerHandshaker handshaker = new WebSocketServerHandshakerFactory(
                                                String.format("ws://%s%s",req.headers().get(Names.HOST),pattern),true
                                            ).newHandshaker(req);

    if (handshaker == null) {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    } else {
        WebSocket ws = getCallback().newInstance(new WrappedRequest<>(req,params,sessions));

        if (ws instanceof WebSocket) {
            Channel ch = handshaker.handshake(ctx.channel(),req).channel();
            handler.onWsFrame(new WsBridge(handshaker,ch,ws));
            ws.onopen();
        } else {
            FullHttpResponse forbidden = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,HttpResponseStatus.FORBIDDEN);
            ByteBufUtil.writeUtf8(forbidden.content(),"Forbidden.");

            ctx.writeAndFlush(forbidden);
            ctx.close();
        }
    }

    return true;
}

@Override
public HandshakeFuture handshake() {
    WebSocketServerHandshakerFactory wsFactory =
            new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),true);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(httpRequest);
    return handleHandshake(handshaker,0);
}

@Override
public HandshakeFuture handshake(String[] subProtocols,boolean allowExtensions) {
    WebSocketServerHandshakerFactory wsFactory =
            new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),getSubProtocolsCSV(subProtocols),allowExtensions);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(httpRequest);
    return handleHandshake(handshaker,boolean allowExtensions,int idleTimeout) {
    WebSocketServerHandshakerFactory wsFactory =
            new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),idleTimeout);
}

@Override
public void cancelHandShake(int closeCode,String closeReason) {
    try {
        WebSocketServerHandshakerFactory wsFactory =
                new WebSocketServerHandshakerFactory(getWebSocketURL(httpRequest),getSubProtocol(),true);
        WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(httpRequest);
        ChannelFuture channelFuture =
                handshaker.close(ctx.channel(),new CloseWebSocketFrame(closeCode,closeReason));
        channelFuture.channel().close();
    } finally {
        isCancelled = true;
    }
}

@Override
public <T> T unwrap(Class<T> clazz) {
    return ChannelHandlerContext.class.isAssignableFrom(clazz) ? 
        clazz.cast(context) : 
        WebSocketServerHandshaker.class.isAssignableFrom(clazz) ? 
            clazz.cast(handshaker) : 
                FullHttpRequest.class.isAssignableFrom(clazz) ?
                    clazz.cast(request) :
                    null;
}

@Test
public void unwrap() {
    performer.onserver(new Action<ServerWebSocket>() {
        @Override
        public void on(ServerWebSocket ws) {
            assertthat(ws.unwrap(ChannelHandlerContext.class),instanceOf(ChannelHandlerContext.class));
            assertthat(ws.unwrap(WebSocketServerHandshaker.class),instanceOf(WebSocketServerHandshaker.class));
            assertthat(ws.unwrap(FullHttpRequest.class),instanceOf(FullHttpRequest.class));
            performer.start();
        }
    })
    .connect();
}

public ChannelHandler serverHandshake(ChannelHandlerContext ctx,FullHttpRequest msg)
{

    this.ctx = ctx;
    // Handshake
    WebSocketServerHandshaker handshaker;
    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(getWebSocketLocation(msg),true);
    handshaker = wsFactory.newHandshaker(msg);
    if (handshaker == null)
    {
        WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
    }
    else
    {
        ChannelPromise promise = ctx.channel().newPromise();
        promise.addListener(future -> {
            if (promise.isSuccess())
            {
                this.notifyopen();
            }
            else
            {
                this.notifyError();
            }
        });
        handshaker.handshake(ctx.channel(),msg,promise);
    }

    return new MyChannelHandler((ctx1,frame) -> {
        handshaker.close(ctx1.channel(),(CloseWebSocketFrame) frame.retain());
    });
}

private void handleHttpRequest(ChannelHandlerContext ctx,FullHttpRequest req) {
    // Handle a bad request.
    if (!req.getDecoderResult().isSuccess()) {
        sendErrorResponse(ctx,BAD_REQUEST);
        return;
    }
    // Allow only GET methods.
    if (req.getmethod() != GET) {
        sendErrorResponse(ctx,FORBIDDEN);
        return;
    }

    String path = req.getUri();
    System.out.println("Server => Request: " + path);
    try {
        if (path.equals("/ws")) {
            isWebSocket = true;
            String wsLocation = getWebSocketLocation(ctx,req);
            WebSocketServerHandshaker handshaker = new WebSocketServerHandshakerFactory(
                    wsLocation,64 * 1024).newHandshaker(req);
            if (handshaker == null) {
                WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel())
                                                .addListener(ChannelFutureListener.CLOSE);
            } else {
                handshaker.handshake(ctx.channel(),req);
                // Push the initial state to the client.
                // Do it from the server thread were it's safe
                bossGroup.execute(() -> {
                    ctx.writeAndFlush(makeWebSocketEventFrame("stateChanged",lastState));
                });
                wsConnections.add(ctx.channel());
            }
        } 
        else {
            handleStaticFileRequest(ctx,path);
        }
    } catch (Throwable e) {
        sendErrorResponse(ctx,BAD_REQUEST);
    }
}

@SuppressWarnings("unchecked")
@Override
public <T> T upgrade(final Class<T> type) throws Exception {
  if (type == NativeWebSocket.class) {
    String protocol = ifSecure("wss","ws");
    String webSocketURL = protocol + "://" + req.headers().get(HttpHeaderNames.HOST) + path;

    WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
        webSocketURL,wsMaxMessageSize);
    WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
    NettyWebSocket result = new NettyWebSocket(ctx,handshaker,(ws) -> {
      handshaker.handshake(ctx.channel(),(FullHttpRequest) req)
          .addListener(FIRE_EXCEPTION_ON_FAILURE)
          .addListener(payload -> ws.connect())
          .addListener(FIRE_EXCEPTION_ON_FAILURE);
    });
    ctx.channel().attr(NettyWebSocket.KEY).set(result);
    return (T) result;
  } else if (type == Sse.class) {
    NettySse sse = new NettySse(ctx);
    return (T) sse;
  } else if (type == NativePushPromise.class) {
    return (T) new NettyPush(ctx,req.headers().getInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text()),header("host").orElse(ip()),ifSecure("https","http"));
  }
  throw new UnsupportedOperationException("Not Supported: " + type);
}

@SuppressWarnings("unchecked")
@Test
public void handleBinaryFrame() throws Exception {
  new MockUnit(ChannelHandlerContext.class,BinaryWebSocketFrame.class)
          .expect(unit -> {
            CountDownLatch ready = unit.mockConstructor(CountDownLatch.class,1);
            ready.await();

            ByteBuffer nioBuff = ByteBuffer.wrap(new byte[0]);

            ByteBuf buff = unit.mock(ByteBuf.class);
            expect(buff.nioBuffer()).andReturn(nioBuff);

            BinaryWebSocketFrame frame = unit.get(BinaryWebSocketFrame.class);
            expect(frame.content()).andReturn(buff);

            Consumer<ByteBuffer> callback = unit.get(Consumer.class);
            callback.accept(nioBuff);
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.onBinaryMessage(unit.get(Consumer.class));
            ws.handle(unit.get(BinaryWebSocketFrame.class));
          });
}

@SuppressWarnings("unchecked")
@Test
public void handleCloseFrame() throws Exception {
  new MockUnit(ChannelHandlerContext.class,CloseWebSocketFrame.class,BiConsumer.class)
          .expect(unit -> {
            CountDownLatch ready = unit.mockConstructor(CountDownLatch.class,1);
            ready.await();

            CloseWebSocketFrame retain = unit.get(CloseWebSocketFrame.class);
            expect(retain.statusCode()).andReturn(-1);
            expect(retain.reasonText()).andReturn(null);

            CloseWebSocketFrame frame = unit.get(CloseWebSocketFrame.class);
            expect(frame.retain()).andReturn(retain);

            BiConsumer<Integer,Optional<String>> callback = unit.get(BiConsumer.class);
            callback.accept(1000,Optional.empty());

            Channel ch = unit.mock(Channel.class);

            ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
            expect(ctx.channel()).andReturn(ch);

            ChannelFuture future = unit.mock(ChannelFuture.class);
            expect(future.addListener(CLOSE)).andReturn(future);

            WebSocketServerHandshaker handshaker = unit.get(WebSocketServerHandshaker.class);
            expect(handshaker.close(ch,retain)).andReturn(future);
          })
          .run(unit -> {
            NettyWebSocket ws = new NettyWebSocket(
                unit.get(ChannelHandlerContext.class),unit.get(Consumer.class));
            ws.onCloseMessage(unit.get(BiConsumer.class));
            ws.handle(unit.get(CloseWebSocketFrame.class));
          });
}

@SuppressWarnings("unchecked")
@Test
public void handleCloseWithStatusFrame() throws Exception {
  new MockUnit(ChannelHandlerContext.class,1);
            ready.await();

            CloseWebSocketFrame retain = unit.get(CloseWebSocketFrame.class);
            expect(retain.statusCode()).andReturn(1001);
            expect(retain.reasonText()).andReturn("normal");

            CloseWebSocketFrame frame = unit.get(CloseWebSocketFrame.class);
            expect(frame.retain()).andReturn(retain);

            BiConsumer<Integer,Optional<String>> callback = unit.get(BiConsumer.class);
            callback.accept(1001,Optional.of("normal"));

            Channel ch = unit.mock(Channel.class);

            ChannelHandlerContext ctx = unit.get(ChannelHandlerContext.class);
            expect(ctx.channel()).andReturn(ch);

            ChannelFuture future = unit.mock(ChannelFuture.class);
            expect(future.addListener(CLOSE)).andReturn(future);

            WebSocketServerHandshaker handshaker = unit.get(WebSocketServerHandshaker.class);
            expect(handshaker.close(ch,unit.get(Consumer.class));
            ws.onCloseMessage(unit.get(BiConsumer.class));
            ws.handle(unit.get(CloseWebSocketFrame.class));
          });
}

@Override
@SuppressWarnings("PMD.OnlyOneReturn")
public void channelRead(ChannelHandlerContext ctx,Object msg) throws Exception {
    if (msg instanceof FullHttpRequest) {
        FullHttpRequest req = (FullHttpRequest) msg;

        // Handle a bad request.
        if (!req.decoderResult().isSuccess()) {
            sendHttpResponse(ctx,BAD_REQUEST));
            return;
        }

        // Allow only GET methods.
        if (req.method() != GET) {
            sendHttpResponse(ctx,FORBIDDEN));
            return;
        }

        // Handshake
        WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
                getWebSocketLocation(req),false);
        WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
        if (handshaker == null) {
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        } else {
            handshaker.handshake(ctx.channel(),req);
        }
    } else {
        ctx.fireChannelRead(msg);
    }
}

protected WebsocketFrameHandler(WebSocketServerHandshaker handshaker) {
    this.handshaker = handshaker;
}

public WebSocketConnection newConnect(ChannelHandlerContext context,WebSocketServerHandshaker handshaker,String uri,HttpParams param,FullHttpRequest request);

private WsBridge(WebSocketServerHandshaker handshaker,Channel ch,WebSocket endpoint) {
    this.handshaker = handshaker;
    this.endpoint = endpoint;

    endpoint.setChannel(ch);
}