Example #1
0
 /**
  * Sends a response packet from the server to the client.
  *
  * <p>Synchronized so that only one thread can send a client a message at a time.
  *
  * @param packet the response packet
  */
 public synchronized void sendResponse(Packet packet) {
   try {
     session.getRemote().sendString(packet.getJson().toString());
   } catch (IOException ioe) {
     System.out.println(
         "Sending response failed, session id = " + session.getRemoteAddress().toString());
   }
 }
 @OnWebSocketMessage
 public void onText(Session session, String message) {
   if (session.isOpen()) {
     System.out.printf("Echoing back message [%s]%n", message);
     // echo the message back
     session.getRemote().sendString(message, null);
   }
 }
 /* Socket message envoyé */
 public void sendMessage(String str) {
   try {
     session.getRemote().sendString(str);
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
  @Override
  public void onWebSocketConnect(Session sess) {

    connected = true;
    final String spath = getFirstValue(sess, "path");
    final String sset = getFirstValue(sess, "dataset");
    final boolean writing = Boolean.parseBoolean(getFirstValue(sess, "writingExpected"));
    final Path path = Paths.get(spath);
    try {
      WatchService myWatcher = path.getFileSystem().newWatchService();

      QueueReader fileWatcher = new QueueReader(myWatcher, sess, spath, sset, writing);

      // We may only monitor a directory
      if (Files.isDirectory(path)) {
        path.register(myWatcher, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);
      } else {
        path.getParent().register(myWatcher, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);
      }

      Thread th = new Thread(fileWatcher, path.getFileName() + " Watcher");
      th.setDaemon(true);
      th.setPriority(Thread.MAX_PRIORITY - 2);
      th.start();
      if (diagInfo != null) diagInfo.record("Start Thread", th.getName());

    } catch (Exception ne) {
      logger.error("Cannot watch " + path, ne);
      try {
        sess.getRemote().sendString(ne.getMessage());
      } catch (IOException e) {
        logger.warn("Cannot write to remote " + sess, e);
      }
    }
  }
Example #5
0
  public void send(final WebSocketMessage message, final boolean clearSessionId) {

    // return session status to client
    message.setSessionValid(isAuthenticated());

    // whether to clear the token (all command except LOGIN (for now) should absolutely do this!)
    if (clearSessionId) {

      message.setSessionId(null);
    }

    // set callback
    message.setCallback(callback);
    if (isAuthenticated() || "STATUS".equals(message.getCommand())) {

      String msg = gson.toJson(message, WebSocketMessage.class);

      logger.log(
          Level.FINE,
          "############################################################ SENDING \n{0}",
          msg);

      try {

        session.getRemote().sendString(msg);

      } catch (Throwable t) {
        logger.log(Level.WARNING, "Unable to send websocket message to remote client");
      }

    } else {

      logger.log(Level.WARNING, "NOT sending message to unauthenticated client.");
    }
  }
    @Override
    public void onWebSocketText(String message) {
      LOG.debug("onWebSocketText({})", message);
      calls.incrementAndGet();
      if (message.equalsIgnoreCase("openSessions")) {
        Collection<WebSocketSession> sessions = container.getOpenSessions();

        StringBuilder ret = new StringBuilder();
        ret.append("openSessions.size=").append(sessions.size()).append('\n');
        int idx = 0;
        for (WebSocketSession sess : sessions) {
          ret.append('[').append(idx++).append("] ").append(sess.toString()).append('\n');
        }
        session.getRemote().sendStringByFuture(ret.toString());
        session.close(StatusCode.NORMAL, "ContainerSocket");
      } else if (message.equalsIgnoreCase("calls")) {
        session.getRemote().sendStringByFuture(String.format("calls=%,d", calls.get()));
      }
    }
Example #7
0
 @Override
 public void close() {
   logger.trace(
       "WebSocket.close() for AtmosphereResource {}",
       resource() != null ? resource().uuid() : "null");
   try {
     webSocketConnection.close();
   } catch (IOException e) {
     logger.trace("Close error", e);
   }
 }
Example #8
0
  @Override
  public void onWebSocketConnect(final Session session) {

    logger.log(Level.INFO, "New connection with protocol {0}", session.getProtocolVersion());

    this.session = session;

    syncController.registerClient(this);

    pagePath = request.getQueryString();
  }
Example #9
0
  @Test
  public void testBatchModeAuto() throws Exception {
    URI uri = URI.create("ws://localhost:" + connector.getLocalPort());

    final CountDownLatch latch = new CountDownLatch(1);
    WebSocketAdapter adapter =
        new WebSocketAdapter() {
          @Override
          public void onWebSocketText(String message) {
            latch.countDown();
          }
        };
    try (Session session = client.connect(adapter, uri).get()) {
      RemoteEndpoint remote = session.getRemote();

      Future<Void> future = remote.sendStringByFuture("batch_mode_on");
      // The write is aggregated and therefore completes immediately.
      future.get(1, TimeUnit.MICROSECONDS);

      // Wait for the echo.
      Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    }
  }
  @Override
  public void initializeNativeSession(Session session) {
    super.initializeNativeSession(session);

    this.id = ObjectUtils.getIdentityHexString(getNativeSession());
    this.uri = session.getUpgradeRequest().getRequestURI();

    this.headers = new HttpHeaders();
    this.headers.putAll(getNativeSession().getUpgradeRequest().getHeaders());
    this.headers = HttpHeaders.readOnlyHttpHeaders(headers);

    this.acceptedProtocol = session.getUpgradeResponse().getAcceptedSubProtocol();

    List<ExtensionConfig> source = getNativeSession().getUpgradeResponse().getExtensions();
    this.extensions = new ArrayList<WebSocketExtension>(source.size());
    for (ExtensionConfig ec : source) {
      this.extensions.add(new WebSocketExtension(ec.getName(), ec.getParameters()));
    }

    if (this.user == null) {
      this.user = session.getUpgradeRequest().getUserPrincipal();
    }
  }
Example #11
0
 @Override
 @OnWebSocketConnect
 public void onConnect(Session session) {
   super.onConnect(session);
   this.session.setIdleTimeout(TimeUnit.MINUTES.toMillis(1));
   Connector con = null;
   try {
     ConnectorFactory cf = ConnectorFactory.getDefault();
     con = cf.createConnector();
   } catch (AgentProxyException e) {
     System.out.println(e);
   }
   IdentityRepository irepo = null;
   if (con != null) {
     RemoteIdentityRepository rrepo = new RemoteIdentityRepository(con);
     if (rrepo.getIdentities() != null && rrepo.getIdentities().size() > 0) {
       irepo = rrepo;
       jsch.setIdentityRepository(irepo);
     }
   }
   if (irepo == null) {
     String home = System.getProperty("user.home");
     String sshDir = home + File.separator + ".ssh" + File.separator;
     String[] defaultKeys =
         new String[] {
           sshDir + "id_ecdsa",
           sshDir + "id_id_ed25519",
           sshDir + "id_rsa",
           sshDir + "id_dsa",
           sshDir + "identity"
         };
     for (String nextKey : defaultKeys) {
       try {
         jsch.addIdentity(nextKey);
         log.fine("Key '" + nextKey + "'  added");
       } catch (JSchException e) {
         log.log(Level.FINE, "Key '" + nextKey + "'  not valid", e);
       }
     }
   }
   Map<String, List<String>> parameterMap = session.getUpgradeRequest().getParameterMap();
   String host = getStringParameter(parameterMap, "host", null);
   String connectHost = hostLookupService.getResolvableHostname(host);
   String user = getStringParameter(parameterMap, "user", null);
   if ("@admin".equals(user)) {
     user = hostLookupService.getAdminUserFor(host);
   }
   Resize resize = new Resize();
   resize.cols = getIntParameter(parameterMap, "cols", 80);
   resize.rows = getIntParameter(parameterMap, "rows", 24);
   try {
     java.util.Properties config = new java.util.Properties();
     config.put("StrictHostKeyChecking", "no");
     jschSession = jsch.getSession(user, connectHost, hostLookupService.getSshPort(host));
     jschSession.setConfig(config);
     jschSession.connect(60000);
     shell = (ChannelShell) jschSession.openChannel("shell");
     shell.setAgentForwarding(true);
     shell.setPtyType("vt102");
     shell.connect();
     shell.setPtySize(resize.cols, resize.rows, resize.getPixelWidth(), resize.getPixelHeight());
   } catch (JSchException e) {
     close(1, "Failed to create ssh session", e);
   }
   Runnable run;
   try {
     run =
         new RawSentOutputTask(
             session, new BufferedInputStream(shell.getInputStream(), BUFFER_LEN));
     Thread thread = new Thread(run);
     thread.start();
   } catch (IOException e) {
     close(2, "IOException while getting data from ssh", e);
   }
   try {
     inputToShell = new PrintStream(shell.getOutputStream(), true, "UTF-8");
   } catch (IOException e) {
     close(3, "IOException while creating write stream to ssh", e);
   }
 }
Example #12
0
 /**
  * Disconnects this client's session. @TODO send notification first before suddenly closing
  * connection
  */
 public void disconnectSession() {
   session.close();
 }
Example #13
0
 /**
  * Gets the session id that this client is connected to the server with. (ie. the remote address,
  * to string'd)
  *
  * @return the session object
  */
 public String getSessionId() {
   return session.getRemoteAddress().toString();
 }
Example #14
0
 public synchronized void keepAlive() throws Exception {
   checkConnected();
   connection.getRemote().sendString("\n");
 }
Example #15
0
 public synchronized void sendFrame(StompFrame frame) throws Exception {
   checkConnected();
   connection.getRemote().sendString(frame.format());
 }
Example #16
0
 public synchronized void sendRawFrame(String rawFrame) throws Exception {
   checkConnected();
   connection.getRemote().sendString(rawFrame);
 }
Example #17
0
 public void close() {
   if (connection != null) {
     connection.close();
   }
 }
Example #18
0
 @Override
 public boolean isConnected() {
   return connection != null ? connection.isOpen() : false;
 }
    /**
     * In order to implement a file watcher, we loop forever ensuring requesting to take the next
     * item from the file watchers queue.
     */
    @Override
    public void run() {

      final Path path = Paths.get(spath);
      try {
        // We wait until the file we are told to monitor exists.
        while (!Files.exists(path)) {
          Thread.sleep(200);
        }

        // get the first event before looping
        WatchKey key = null;
        while (session.isOpen() && connected && (key = watcher.take()) != null) {

          try {
            if (!Files.exists(path)) continue;

            for (WatchEvent<?> event : key.pollEvents()) {

              if (!Files.exists(path)) continue;

              Path epath = (Path) event.context();
              if (!Files.isDirectory(path) && !path.endsWith(epath)) continue;

              try {
                // Data has changed, read its shape and publish the event using a web socket.
                final IDataHolder holder =
                    ServiceHolder.getLoaderService().getData(spath, new IMonitor.Stub());
                if (holder == null) continue; // We do not stop if the loader got nothing.

                final ILazyDataset lz =
                    sdataset != null && !"".equals(sdataset)
                        ? holder.getLazyDataset(sdataset)
                        : holder.getLazyDataset(0);
                if (lz == null) continue; // We do not stop if the loader got nothing.

                if (lz instanceof IDynamicDataset) {
                  ((IDynamicDataset) lz).refreshShape();
                }

                if (writing) {
                  ServiceHolder.getLoaderService().clearSoftReferenceCache(spath);
                }
                final DataEvent evt = new DataEvent(lz.getName(), lz.getShape());
                evt.setFilePath(spath);

                // We manually JSON the object because we
                // do not want a dependency and object simple
                String json = evt.encode();
                session.getRemote().sendString(json);
                if (diagInfo != null) diagInfo.record("JSON Send", json);

              } catch (HDF5FunctionArgumentException h5error) {
                // This happens sometimes when the file is not ready to read.
                logger.trace("Path might not be ready to read " + path);
                continue;

              } catch (Exception ne) {
                logger.error("Exception getting data from " + path);
                continue;
              }
              break;
            }

          } finally {
            key.reset();
          }
        }

      } catch (Exception e) {
        logger.error("Exception monitoring " + path, e);
        if (session.isOpen()) session.close(403, e.getMessage());

      } finally {
        if (diagInfo != null) diagInfo.record("Close Thread", Thread.currentThread().getName());
        try {
          watcher.close();
        } catch (IOException e) {
          logger.error("Error closing watcher", e);
        }
      }
    }
Example #20
0
 @Override
 public boolean isOpen() {
   return webSocketConnection.isOpen();
 }
 private String getFirstValue(Session sess, String name) {
   final List<String> vals = sess.getUpgradeRequest().getParameterMap().get(name);
   return vals != null ? vals.get(0) : null;
 }
 @Override
 public void onWebSocketConnect(Session sess) {
   LOG.debug("onWebSocketConnect({})", sess);
   calls.incrementAndGet();
   sess.close(StatusCode.NORMAL, "FastCloseServer");
 }