Exemple #1
0
  public void run() {
    logger.info("Started GSN Controller on port " + gsnControllerPort);
    while (true) {
      try {
        Socket socket = mySocket.accept();
        logger.debug("Opened connection on control socket.");
        socket.setSoTimeout(GSN_CONTROL_READ_TIMEOUT);

        // Only connections from localhost are allowed
        if (ValidityTools.isLocalhost(socket.getInetAddress().getHostAddress()) == false) {
          try {
            logger.warn(
                "Connection request from IP address >"
                    + socket.getInetAddress().getHostAddress()
                    + "< was denied.");
            socket.close();
          } catch (IOException ioe) {
            // do nothing
          }
          continue;
        }
        new StopManager().start();
      } catch (SocketTimeoutException e) {
        logger.debug("Connection timed out. Message was: " + e.getMessage());
      } catch (IOException e) {
        logger.warn("Error while accepting control connection: " + e.getMessage());
      }
    }
  }
  public String waitForPassword(int timeout, String username) throws TimeoutException {
    while (!initiated) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException ex) {
      }
    }

    String password = "";
    try {
      // send a message to the robot
      String response = robotSocketServer.sendMessageAndWaitForResponse("waitForPassword");
      if (!response.startsWith("password is ")) {
        System.err.println(
            "waitForPassword RECEIVED MESSAGE DIFFERENT THAN \"password is ...\": " + response);
        System.exit(1);
      }
      password = response.substring(12, response.length());
      System.out.println("Received: " + response + "   Password is " + password);
    } catch (SocketTimeoutException ex) {
      System.err.println("waitForPassword EXCEPTION!");
      ex.printStackTrace();
      System.exit(1);
    }
    return password;
  }
    public void run() {
      // Counter to wait for timeout 5 times
      int counter = 5;

      while (running) {
        try {
          byte[] buf = new byte[32];
          packet = new DatagramPacket(buf, buf.length);
          socket.setSoTimeout(1000);

          // Wait for a message
          socket.receive(packet);

          // Clean the string (remove all the null characters)
          String message = new String(packet.getData());
          int endoftext = message.indexOf("\0");
          if (endoftext != -1) message = message.substring(0, endoftext);

          // If the message is different from the one sent
          if (!message.equals("requestIP")) {
            // Broadcast an intent with the message
            Intent answer = new Intent(Constants.UDP_ANSWER);
            answer.putExtra("message", message);
            sendBroadcast(answer);
          }
        } catch (SocketTimeoutException e) {
          // If the socket timed out, decrement the counter
          counter--;
          if (counter == 0) cancel();
          e.printStackTrace();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  /*
   * Evento que se ejecuta cuando se invocó el servicio por medio de un
   * Intent.
   */
  @Override
  protected void onHandleIntent(final Intent intent) {
    final ResultReceiver receiver = intent.getParcelableExtra("receiver");
    final String command = intent.getStringExtra("command");
    final String query = intent.getStringExtra("query");

    final Bundle b = new Bundle();
    try {
      if (command.equals(GET_PRODUCTS_CMD)) {
        getProducts(receiver, b, query);
      }
    } catch (SocketTimeoutException e) {
      Log.e(TAG, e.getMessage());
      receiver.send(STATUS_CONNECTION_ERROR, b);
    } catch (JSONException e) {
      Log.e(TAG, e.getMessage());
      receiver.send(STATUS_ERROR, b);
    } catch (ClientProtocolException e) {
      Log.e(TAG, e.getMessage());
      receiver.send(STATUS_ERROR, b);
    } catch (IllegalArgumentException e) {
      Log.e(TAG, e.getMessage());
      receiver.send(STATUS_ILLEGAL_ARGUMENT, b);
    } catch (IOException e) {
      Log.e(TAG, e.getMessage());
      receiver.send(STATUS_ERROR, b);
    } catch (Exception e) {
      Log.e(TAG, e.getMessage());
    }

    // Es importante terminar el servicio lo antes posible.
    this.stopSelf();
  }
Exemple #5
0
 /**
  * 下载文件
  *
  * @param params 请求参数
  * @param filepath 保存路径
  */
 public static File downloadFile(RequestParams params, String filepath) throws TaskException {
   // 设置断点续传
   params.setAutoResume(true);
   params.setSaveFilePath(filepath);
   try {
     return x.http().getSync(params, File.class);
   } catch (SocketTimeoutException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (ConnectTimeoutException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (UnknownHostException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (IOException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (Throwable throwable) {
     TaskException taskException = null;
     if (throwable.getCause() instanceof TaskException) {
       taskException = (TaskException) throwable.getCause();
     } else if (throwable instanceof TaskException) {
       taskException = (TaskException) throwable;
     }
     if (taskException != null) {
       throw taskException;
     }
     throw new TaskException(
         "", TextUtils.isEmpty(throwable.getMessage()) ? "服务器错误" : throwable.getMessage());
   }
 }
    @Override
    protected DanmuFileData doInBackground(Void... voids) {
      Boolean isSuccessed = false;

      try {
        isSuccessed = NetWorkUtils.downLoadDanmuFile(chatId);
      } catch (SocketTimeoutException e) {
        e.printStackTrace();
        return null;
      }
      L.e("网络请求成功" + isSuccessed);
      if (!isSuccessed) {
        return null;
      }

      File danmuFile = new File(Constant.DANMU_FILE_SAVE_PATH + chatId);
      if (!danmuFile.exists()) {
        return null;
      }
      L.e("文件解析成功");
      FileInputStream fileInputStream = null;
      try {
        fileInputStream = new FileInputStream(danmuFile);
      } catch (FileNotFoundException e) {
        e.printStackTrace();
        L.e("文件流读取失败");
        return null;
      }
      L.e("文件流读取成功");
      BiliDanmakuXMLParser biliDanmakuXMLParser =
          (BiliDanmakuXMLParser)
              DataUtils.parseXMLToDanmakuFile(fileInputStream, new BiliDanmakuXMLParser());
      return biliDanmakuXMLParser.getDanmakuFileData();
    }
Exemple #7
0
 public void receivePacket() {
   int buffLength = 256;
   byte[] buff = new byte[buffLength];
   DatagramPacket packet = new DatagramPacket(buff, buffLength);
   try {
     socket.receive(packet);
     String message = new String(packet.getData(), 0, packet.getLength() - 2);
     System.out.println("receive message : " + message);
     if (message.indexOf(":") == -1) {
       return;
     }
     String[] fields = message.split(":");
     long commandField = Long.parseLong(fields[4]);
     if ((commandField & IPMSG_ANSENTRY) != 0) {
       this.receiveAnswerEntry(fields, packet);
     } else if ((commandField & IPMSG_SENDMSG) != 0) {
       this.receiveMessage(fields, packet);
     }
   } catch (SocketTimeoutException ste) {
     ste.printStackTrace();
   } catch (PortUnreachableException pue) {
     pue.printStackTrace();
   } catch (IllegalBlockingModeException ibme) {
     ibme.printStackTrace();
   } catch (IOException ioe) {
     ioe.printStackTrace();
   }
 }
Exemple #8
0
  public static byte[] post(String url, RequestEntity requestEntity) throws Exception {

    PostMethod method = new PostMethod(url);
    method.addRequestHeader("Connection", "Keep-Alive");
    method.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
    method
        .getParams()
        .setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(0, false));
    method.setRequestEntity(requestEntity);
    method.addRequestHeader("Content-Type", "application/x-www-form-urlencoded");

    try {
      int statusCode = client.executeMethod(method);
      if (statusCode != HttpStatus.SC_OK) {
        System.err.println("httpCode=" + statusCode);
        return method.getResponseBody();
      }
      return method.getResponseBody();

    } catch (SocketTimeoutException e) {
      e.printStackTrace();
      return null;
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    } finally {
      method.releaseConnection();
    }
  }
Exemple #9
0
 public static <T> T doPostSync(RequestParams params, Class<T> responseCls) throws TaskException {
   try {
     return x.http().postSync(params, responseCls);
   } catch (SocketTimeoutException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (ConnectTimeoutException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (UnknownHostException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (IOException e) {
     e.printStackTrace();
     throw new TaskException(TaskException.TaskError.timeout.toString());
   } catch (Throwable throwable) {
     TaskException taskException = null;
     if (throwable.getCause() instanceof TaskException) {
       taskException = (TaskException) throwable.getCause();
     } else if (throwable instanceof TaskException) {
       taskException = (TaskException) throwable;
     }
     if (taskException != null) {
       throw taskException;
     }
     throw new TaskException(
         "", TextUtils.isEmpty(throwable.getMessage()) ? "服务器错误" : throwable.getMessage());
   }
 }
  @GET
  @Path("/{imageStream}/tag/{imageStreamTag}")
  @Produces(MediaType.APPLICATION_JSON)
  public ImageStreamTag getImageStreamTag(
      @PathParam("namespace") String namespace,
      @PathParam("imageStream") String imageStream,
      @PathParam("imageStreamTag") String imageStreamTag)
      throws UnauthorizedException, ServerException {
    URL url;
    try {
      url =
          UriBuilder.fromPath(getTagUrlTemplate)
              .buildFromMap(
                  ImmutableMap.of(
                      "namespace", namespace,
                      "imageStream", imageStream,
                      "tag", imageStreamTag))
              .toURL();
    } catch (MalformedURLException e) {
      throw new ServerException("Unable to get image stream tag. " + e.getMessage(), e);
    }

    try {
      final String response =
          clientFactory.getHttpClient().get(url, IHttpClient.DEFAULT_READ_TIMEOUT);
      return DtoFactory.getInstance().createDtoFromJson(response, ImageStreamTag.class);
    } catch (SocketTimeoutException e) {
      throw new ServerException("Unable to get image stream tag. " + e.getMessage(), e);
    }
  }
 private boolean checkConnectTimeout(HftpFileSystem fs, boolean ignoreReadTimeout)
     throws IOException {
   boolean timedout = false;
   List<HttpURLConnection> conns = new LinkedList<HttpURLConnection>();
   try {
     // with a listen backlog of 1, should only have to make one connection
     // to trigger a connection timeout.  however... linux doesn't honor the
     // socket's listen backlog so we have to try a bunch of times
     for (int n = 32; !timedout && n > 0; n--) {
       try {
         conns.add(fs.openConnection("/", ""));
       } catch (SocketTimeoutException ste) {
         String message = ste.getMessage();
         // https will get a read timeout due to SSL negotiation, but
         // a normal http will not, so need to ignore SSL read timeouts
         // until a connect timeout occurs
         if (!(ignoreReadTimeout && message.equals("Read timed out"))) {
           timedout = true;
           assertEquals("connect timed out", message);
         }
       }
     }
   } finally {
     for (HttpURLConnection conn : conns) {
       conn.disconnect();
     }
   }
   return timedout;
 }
Exemple #12
0
 /* (non-Javadoc)
  * @see botFramework.IBot#sendCommands()
  */
 public void sendCommands() {
   String command;
   boolean success;
   while (!queuedCommands.isEmpty()) {
     command = queuedCommands.removeFirst();
     success = send(command);
     if (success == false) {
       queuedCommands.addFirst(command);
       log.error("error sending command. will reconnect and retry");
       sendErrorEvent("Bot.sendCommands", "problem", "Could not send - reconnecting");
       reconnect("Write error!");
       return;
     }
   }
   try {
     sender.flush();
   } catch (SocketTimeoutException e) {
     log.error("socket timeout while flushing", e);
     sendErrorEvent("Bot.sendCommands", "SocketTimeoutException", e.getMessage());
   } catch (IOException e) {
     log.error("ioexception while flushing", e);
     sendErrorEvent("Bot.sendCommands", "IOException", e.getMessage());
     reconnect("Write error!");
   }
 }
Exemple #13
0
  private boolean connectSPPMon() {
    if (state == ConnectionEvent.CONNECTION_PENDING) {
      ExpCoordinator.print(
          new String("NCCPConnection(" + host + ", " + port + ").connect connection pending"), 0);
      while (state == ConnectionEvent.CONNECTION_PENDING) {
        try {
          Thread.sleep(500);
        } catch (java.lang.InterruptedException e) {
        }
      }
      return (isConnected());
    }

    state = ConnectionEvent.CONNECTION_PENDING;
    if (nonProxy != null) {
      try {
        nonProxy.connect();
      } catch (UnknownHostException e) {
        boolean rtn = informUserError("Don't know about host: " + host + ":" + e.getMessage());
        return rtn;
      } catch (SocketTimeoutException e) {
        boolean rtn = informUserError("Socket time out for " + host + ":" + e.getMessage());
        return rtn;
      } catch (IOException e) {
        boolean rtn = informUserError("Couldnt get I/O for " + host + ":" + e.getMessage());
        return rtn;
      }
    }
    return (isConnected());
  }
  /**
   * @param theUrl
   * @param conAttempts
   * @return
   * @throws IOException
   */
  public int getResposeCode(String theUrl, int conAttempts)
      throws IOException { // throws IOException
    URL newUrl = new URL(theUrl);
    // These codes are returned to indicate either fault or not.
    int ERROR_CODE = 1000, OK_CODE = 0;

    HttpURLConnection huc = (HttpURLConnection) newUrl.openConnection();
    huc.setRequestMethod("HEAD");
    huc.setRequestProperty("User-Agent", userAgent);
    huc.setReadTimeout(2000);
    huc.connect();
    try {
      return huc.getResponseCode();

    } catch (java.net.SocketException e) {
      if (e.getMessage().equalsIgnoreCase("Unexpected end of file from server"))
        return OK_CODE; // link still valid so return a small positive int that isn't a http status
                        // code
      else
        return ERROR_CODE; // error, return a large int that isn't included in any http status code

    } catch (java.net.SocketTimeoutException e) {
      if (e.getMessage().equalsIgnoreCase("Read timed out")) {
        if (conAttempts != MAX_CONNECTION_ATTEMPTS) return getResposeCode(theUrl, conAttempts + 1);
        else
          return ERROR_CODE; // ERROR return a large int that isn't included in any http status code
      } else return ERROR_CODE;

    } catch (IOException e) {
      e.printStackTrace();
      return ERROR_CODE; // error, return a large int that isn't included in any http status code
    }
  }
  public TicketsResponse checkTickets(TicketsRequest request) {
    String jsonResp = null;
    TicketsResponse response = null;
    TicketsResponseError responseError = null;
    try {
      jsonResp = sendRequest(request);
      try {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        response = mapper.readValue(jsonResp, TicketsResponse.class);
      } catch (JsonMappingException e) {
        //				logger.error("Could not parse JSON, trying to parse an error. Original exception: ",
        // e);
        responseError = new ObjectMapper().readValue(jsonResp, TicketsResponseError.class);
        TicketsResponse invaildResponse = new TicketsResponse();
        invaildResponse.setError(true);
        invaildResponse.setErrorDescription(responseError.getErrorDescription());
        logger.error("UzGovUa error description: " + responseError.getErrorDescription());
        return invaildResponse;
      }
    } catch (HttpException e) {
      e.printStackTrace();
      logger.error(e.getMessage(), e);
    } catch (SocketTimeoutException e) {
      logger.error(e.getMessage(), e);
    } catch (IOException e) {
      logger.error(e.getMessage(), e);
    }

    return response;
  }
 public void testBlockingConnectTimesOut() throws Exception {
   AbstractNBSocket socket = udpSelectorProvider.openSocketChannel().socket();
   try {
     socket.connect(new InetSocketAddress("127.0.0.1", 9999), 1000);
     fail("shouldn't have connected");
   } catch (SocketTimeoutException iox) {
     assertEquals("operation timed out (1000)", iox.getMessage());
   }
 }
Exemple #17
0
 /* (non-Javadoc)
  * @see botFramework.IBot#send(java.lang.String)
  */
 public synchronized boolean send(String string) {
   try {
     sender.write(string);
   } catch (SocketTimeoutException e) {
     log.error("socket timeout while writing", e);
     sendErrorEvent("Bot.send", "SocketTimeoutException", e.getMessage());
     return false;
   } catch (IOException e) {
     log.error("ioexception while writing", e);
     sendErrorEvent("Bot.send", "IOException", e.getMessage());
     return false;
   }
   return true;
 }
    protected String doInBackground(String... params) {
      Log.i(TAG, "doInBackground");
      String respuesta = null;

      try {
        TelephonyManager telephonyManager =
            (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        String IMEI = telephonyManager.getDeviceId();
        String IMSI = telephonyManager.getSimSerialNumber();
        String consulta;
        if (phone.getText().toString().equals("2")) {
          consulta = URLs.RESOURCE;
        } else consulta = SoapRequestMovistar.getResource(IMEI, IMSI, phone.getText().toString());

        ArrayList<String> retorno = XMLParser.getReturnCode(consulta);

        code = Integer.valueOf(retorno.get(0));

        if (code == 0) {
          respuesta = consulta;
          Log.i(TAG, retorno.get(1));
        } else respuesta = retorno.get(1);
        return respuesta;

      } catch (HttpHostConnectException e2) {
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (HttpResponseException e3) {
        e3.printStackTrace();
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (ParseException p) {
        p.printStackTrace();
        errorMessage = "Error en la recepción de los datos. Por favor reintente";
        return null;
      } catch (SocketTimeoutException s1) {
        s1.printStackTrace();
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (ConnectTimeoutException et) {
        et.printStackTrace();
        errorMessage = "Se agotó el tiempo de espera. Por favor reintente";
        return null;
      } catch (Exception e1) {
        e1.printStackTrace();
        errorMessage = "Ha ocurrido un error con la respuesta del servidor.";
        return null;
      }
    }
Exemple #19
0
 @Override
 public void onSocketTimeoutException(SocketTimeoutException e, Object arg1) {
   Message msg = new Message();
   Bundle params = new Bundle();
   params.putString("response", e.getMessage());
   params.putString("title", "onSocketTimeoutException");
   mHandler.sendMessage(msg);
 }
 public JSONObject put(String path, ArrayList<NameValuePair> params) {
   JSONObject res = new JSONObject();
   HttpPut httpPut = new HttpPut(host + ":" + port + path);
   try {
     httpPut.setEntity(new UrlEncodedFormEntity(params));
     HttpResponse response;
     response = httpClient.execute(httpPut);
     res = new JSONObject(EntityUtils.toString(response.getEntity()));
   } catch (ConnectTimeoutException c) {
     c.printStackTrace();
   } catch (SocketTimeoutException s) {
     s.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   } catch (JSONException e) {
     e.printStackTrace();
   }
   return res;
 }
 public JSONArray getArray(String path, ArrayList<NameValuePair> params) {
   JSONArray res = new JSONArray();
   String paramString = URLEncodedUtils.format(params, "utf-8");
   HttpGet httpGet = new HttpGet(host + ":" + port + path + "?" + paramString);
   HttpResponse response;
   try {
     response = httpClient.execute(httpGet);
     res = new JSONArray(EntityUtils.toString(response.getEntity()));
   } catch (ConnectTimeoutException c) {
     c.printStackTrace();
   } catch (SocketTimeoutException s) {
     s.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   } catch (JSONException e) {
     e.printStackTrace();
   }
   return res;
 }
  /**
   * 执行http get请求
   *
   * @param url
   * @return HttpResult
   */
  public HttpResult invoke(String url) {
    GetMethod get = null;
    HttpResult result = null;
    try {
      get = new GetMethod(url);
      getClient().executeMethod(get);
      int statusCode = get.getStatusCode();
      String statusText = get.getStatusText();
      result = new HttpResult(statusCode, statusText);

      if (statusCode == 200) {
        StringBuffer buf = new StringBuffer();
        BufferedReader br =
            new BufferedReader(new InputStreamReader(get.getResponseBodyAsStream()));
        String line;
        while ((line = br.readLine()) != null) {
          buf.append(line).append('\n');
        }
        result.setBody(buf.toString());
      }

    } catch (SocketTimeoutException e) {
      result = new HttpResult(408, "REQUEST TIMEOUT. " + e.getMessage());
    } catch (java.net.ConnectException e) {
      result = new HttpResult(321, "Connection refused. " + e.getMessage());
    } catch (Exception e) {
      LOG.error(e);
      result = new HttpResult(123, e.getMessage());
    } finally {
      if (get != null) {
        try {
          // byte[] bytes = get.getResponseBody();
          get.releaseConnection();
        } catch (Exception e) {
          LOG.error(e);
        }
      }
    }

    return result;
  }
Exemple #23
0
  public synchronized boolean connect() {
    try {
      connection = new Socket((String) servers.get(currentServer), port);
      connection.setSoTimeout(10000);
      receiver = new BufferedReader(new InputStreamReader(connection.getInputStream(), encoding));
      sender = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream(), encoding));

      sender.write(irc.nick(myNick));
      sender.write(irc.user(myNick, mode, realname));
      sender.flush();
    } catch (SocketTimeoutException e) {
      log.error("socket timeout while connecting", e);
      sendErrorEvent("Bot.connect", "SocketTimeoutException", e.getMessage());
      return false;
    } catch (IOException e) {
      log.error("error while connecting", e);
      sendErrorEvent("Bot.connect", "IOException", e.getMessage());
      return false;
    }
    return true;
  }
  public void openTray(int trayNum) {
    while (!initiated) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException ex) {
      }
    }

    try {
      // send a message to the robot
      String response = robotSocketServer.sendMessageAndWaitForResponse("openTray " + trayNum);
      if (!response.startsWith("closedTray")) {
        System.err.println("openTray RECEIVED MESSAGE DIFFERENT THAN \"closedTray\": " + response);
        System.exit(1);
      }
    } catch (SocketTimeoutException ex) {
      System.err.println("openTray EXCEPTION!");
      ex.printStackTrace();
      System.exit(1);
    }
  }
Exemple #25
0
  public void read(URL url) throws Exception {

    URLConnection connection = url.openConnection();
    if (connection instanceof HttpURLConnection) {
      HttpURLConnection hc = ((HttpURLConnection) connection);
      // hc.setConnectTimeout(1000);
      // hc.setReadTimeout(6000);
      try {
        BufferedReader in = new BufferedReader(new InputStreamReader(hc.getInputStream()));
        String input;
        StringBuffer response = new StringBuffer(256);

        while ((input = in.readLine()) != null) {
          response.append(input + "\r");
          System.out.println(input);
        }
      } catch (SocketTimeoutException x) {
        x.printStackTrace();
        System.out.println(x.getClass().getName());
      }
    }
  }
Exemple #26
0
  public void run() {
    OutputStream out = null;
    InputStream in = null;
    try {
      client.setSoTimeout(4000);
      while (true) {
        out = client.getOutputStream();
        in = client.getInputStream();

        byte[] temp = SocketUtil.readBytesFromStream(in);

        if (null != temp && temp.length > 0) {
          String proTypeStr = new String(temp);
          System.out.println("接收到客户端消息" + proTypeStr + "当前服务器端口是" + port);

          out.write(("success" + port).getBytes());
        }
      }
    } catch (SocketTimeoutException e1) {
      e1.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        if (out != null) {
          out.close();
        }
        if (in != null) {
          in.close();
        }

        if (client != null) {
          client.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
  public void ringBuzzer() {
    while (!initiated) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException ex) {
      }
    }

    try {
      // send a message to the robot
      String response = robotSocketServer.sendMessageAndWaitForResponse("ringBuzzer");
      if (!response.equals("ringBuzzer done")) {
        System.err.println(
            "ringBuzzer RECEIVED MESSAGE DIFFERENT THAN \"ringBuzzer done\": " + response);
        System.exit(1);
      }
    } catch (SocketTimeoutException ex) {
      System.err.println("ringBuzzer EXCEPTION!");
      ex.printStackTrace();
      System.exit(1);
    }
  }
  @Override
  protected void doConnect(SocketAddress remoteAddress, SocketAddress localAddress)
      throws Exception {
    if (localAddress != null) {
      socket.bind(localAddress);
    }

    boolean success = false;
    try {
      socket.connect(remoteAddress, config().getConnectTimeoutMillis());
      activate(socket.getInputStream(), socket.getOutputStream());
      success = true;
    } catch (SocketTimeoutException e) {
      ConnectTimeoutException cause =
          new ConnectTimeoutException("connection timed out: " + remoteAddress);
      cause.setStackTrace(e.getStackTrace());
      throw cause;
    } finally {
      if (!success) {
        doClose();
      }
    }
  }
  @Test
  public void testHsftpSocketTimeout() throws Exception {
    Configuration conf = new Configuration();
    ServerSocket socket = new ServerSocket(0, 1);
    URI uri =
        new URI(
            "hsftp",
            null,
            InetAddress.getByName(null).getHostAddress(),
            socket.getLocalPort(),
            null,
            null,
            null);
    boolean timedout = false;

    HsftpFileSystem fs = (HsftpFileSystem) FileSystem.get(uri, conf);
    try {
      HttpURLConnection conn = null;
      timedout = false;
      try {
        // this will consume the only slot in the backlog
        conn = fs.openConnection("/", "");
      } catch (SocketTimeoutException ste) {
        // SSL expects a negotiation, so it will timeout on read, unlike hftp
        timedout = true;
        assertEquals("Read timed out", ste.getMessage());
      } finally {
        if (conn != null) {
          conn.disconnect();
        }
      }
      assertTrue("ssl read connect timedout", timedout);
      assertTrue("connect timedout", checkConnectTimeout(fs, true));
    } finally {
      fs.close();
    }
  }
  public void moveRobotToNextPoint() {
    while (!initiated) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException ex) {
      }
    }

    try {
      // send a message to the robot
      String response = robotSocketServer.sendMessageAndWaitForResponse("move robot to next point");
      if (!response.equals("next point found")) {
        System.err.println(
            "moveRobotToNextPoint RECEIVED MESSAGE DIFFERENT THAN \"next point found\": "
                + response);
        System.exit(1);
      }
      System.out.println("Robot arrived to the next point");
    } catch (SocketTimeoutException ex) {
      System.err.println("moveRobotToNextPoint EXCEPTION!");
      ex.printStackTrace();
      System.exit(1);
    }
  }