private void loadHistory() {
    StringBuilder jsonArrayString = new StringBuilder();
    try (BufferedReader reader = new BufferedReader(new FileReader(DEFAULT_PERSISTENCE_FILE))) {
      while (reader.ready()) {
        jsonArrayString.append(reader.readLine());
      }
    } catch (IOException e) {
      logger.error("Could not parse message.", e);
    }

    JSONArray jsonArray = new JSONArray();

    if (jsonArrayString.length() == 0) {
      return;
    }

    try {
      jsonArray = (JSONArray) MessageHelper.getJsonParser().parse(jsonArrayString.toString());
    } catch (ParseException e) {
      logger.error("Could not parse message.", e);
    }

    for (int i = 0; i < jsonArray.size(); i++) {
      JSONObject jsonObject = (JSONObject) jsonArray.get(i);
      Message message = MessageHelper.jsonObjectToMessage(jsonObject);
      messages.add(message);
    }
  }
Exemple #2
0
 private Response doGet(HttpExchange httpExchange) {
   String query = httpExchange.getRequestURI().getQuery();
   if (query == null) {
     return Response.badRequest("Absent query in request");
   }
   Map<String, String> map = queryToMap(query);
   String token = map.get(Constants.REQUEST_PARAM_TOKEN);
   if (StringUtils.isEmpty(token)) {
     return Response.badRequest("Token query parameter is required");
   }
   try {
     int index = MessageHelper.parseToken(token);
     if (index > messageStorage.size()) {
       return Response.badRequest(
           String.format(
               "Incorrect token in request: %s. Server does not have so many messages", token));
     }
     Portion portion = new Portion(index);
     List<Message> messages = messageStorage.getPortion(portion);
     String responseBody = MessageHelper.buildServerResponseBody(messages, messageStorage.size());
     return Response.ok(responseBody);
   } catch (InvalidTokenException e) {
     return Response.badRequest(e.getMessage());
   }
 }
Exemple #3
0
  public List<String> getMessages() {
    CLIENT_LOGGER.info("start receiving messages");
    checkConnected();
    List<String> list = new ArrayList<>();
    HttpURLConnection incomeConnection = null;
    try {
      CLIENT_LOGGER.info("send request for receive messages");
      String query =
          String.format(
              "%s?%s=%s",
              Constants.CONTEXT_PATH,
              Constants.REQUEST_PARAM_TOKEN,
              MessageHelper.buildToken(localHistory.size()));
      URL url = new URL(Constants.PROTOCOL, host, port, query);
      incomeConnection = prepareInputConnection(url);
      CLIENT_LOGGER.info("response is received");
      String response = MessageHelper.inputStreamToString(incomeConnection.getInputStream());
      JSONObject jsonObject = MessageHelper.stringToJsonObject(response);
      JSONArray jsonArray = (JSONArray) jsonObject.get("messages");
      CLIENT_LOGGER.info("received " + jsonArray.size() + " messages");
      for (Object o : jsonArray) {
        logger.info(String.format("Message from server: %s", o));
        CLIENT_LOGGER.info("message from server: " + o);
        list.add(o.toString());
      }

      /** Here is an example how for cycle can be replaced with Java 8 Stream API */
      // jsonArray.forEach(System.out::println);
      // list = (List<String>)
      // jsonArray.stream().map(Object::toString).collect(Collectors.toList());

    } catch (ParseException e) {
      logger.error("Could not parse message", e);
      CLIENT_LOGGER.error("could not parse message", e);
    } catch (ConnectException e) {
      logger.error("Connection error. Disconnecting...", e);
      CLIENT_LOGGER.error("connection error", e);
      disconnect();
    } catch (IOException e) {
      logger.error("IOException occured while reading input message", e);
      CLIENT_LOGGER.error("IOException occured while reading input message", e);
    } finally {
      if (incomeConnection != null) {
        incomeConnection.disconnect();
      }
    }
    CLIENT_LOGGER.info("stop receiving messages");
    return list;
  }
Exemple #4
0
 public void sendMessage(String message) {
   checkConnected();
   HttpURLConnection outcomeConnection = null;
   try {
     CLIENT_LOGGER.info("start sending message \"" + message + "\"");
     outcomeConnection = prepareOutputConnection();
     byte[] buffer = MessageHelper.buildSendMessageRequestBody(message).getBytes();
     OutputStream outputStream = outcomeConnection.getOutputStream();
     outputStream.write(buffer, 0, buffer.length);
     outputStream.close();
     outcomeConnection.getInputStream(); // to send data to server
     CLIENT_LOGGER.info("message sent");
   } catch (ConnectException e) {
     logger.error("Connection error. Disconnecting...", e);
     CLIENT_LOGGER.error("connection error", e);
     disconnect();
   } catch (IOException e) {
     CLIENT_LOGGER.error("IOException", e);
     logger.error("IOException occurred while sending message", e);
   } finally {
     if (outcomeConnection != null) {
       outcomeConnection.disconnect();
     }
     CLIENT_LOGGER.info("stop sending message \"" + message + "\"");
   }
 }
 private boolean rewriteHistory() {
   try (Writer writer =
       new OutputStreamWriter(new FileOutputStream(DEFAULT_PERSISTENCE_FILE), "UTF-8")) {
     JSONArray array = MessageHelper.getJsonArrayOfMessages(messages);
     writer.write(array.toString());
     return true;
   } catch (IOException e) {
     logger.error("Could not parse message.", e);
     return false;
   }
 }
Exemple #6
0
 // +++++++
 private Response doPost(HttpExchange httpExchange) {
   try {
     Message message = MessageHelper.getClientMessage(httpExchange.getRequestBody());
     logger.info(String.format("Received new message from user: %s", message));
     messageStorage.addMessage(message);
     return Response.ok();
   } catch (ParseException e) {
     logger.error("Could not parse message.", e);
     return new Response(Constants.RESPONSE_CODE_BAD_REQUEST, "Incorrect request body");
   } catch (MessageExistException e) {
     logger.error("Message with same id exist.", e);
     return new Response(Constants.RESPONSE_CODE_BAD_REQUEST, "Message with same id exist");
   }
 }