private void acquireLock(Handler resultHandler, Handler<Lock> next) {
   vertx
       .sharedData()
       .getLock(
           "service.registry.lock",
           maybeLock -> {
             if (maybeLock.failed()) {
               resultHandler.handle(Future.failedFuture("Cannot acquire registry lock"));
             } else {
               next.handle(maybeLock.result());
             }
           });
 }
Пример #2
0
 private void failTest(Handler<TestContext> thrower) {
   AtomicReference<Throwable> failure = new AtomicReference<>();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 try {
                   thrower.handle(context);
                 } catch (Error | RuntimeException e) {
                   failure.set(e);
                   throw e;
                 }
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertFalse(result.succeeded());
   assertTrue(result.failed());
   assertNotNull(result.failure());
   assertSame(failure.get().getMessage(), result.failure().message());
   assertSame(failure.get(), result.failure().cause());
 }
Пример #3
0
 void handleChunk(Buffer data) {
   synchronized (conn) {
     if (paused) {
       if (pausedChunk == null) {
         pausedChunk = data.copy();
       } else {
         pausedChunk.appendBuffer(data);
       }
     } else {
       request.dataReceived();
       if (pausedChunk != null) {
         data = pausedChunk.appendBuffer(data);
         pausedChunk = null;
       }
       bytesRead += data.length();
       if (dataHandler != null) {
         try {
           dataHandler.handle(data);
         } catch (Throwable t) {
           handleException(t);
         }
       }
     }
   }
 }
Пример #4
0
 void handleException(Throwable e) {
   synchronized (conn) {
     if (exceptionHandler != null) {
       exceptionHandler.handle(e);
     }
   }
 }
Пример #5
0
 private synchronized void callDrainHandler() {
   if (drainHandler != null) {
     if (!writeQueueFull()) {
       drainHandler.handle(null);
     }
   }
 }
Пример #6
0
 void start() {
   connection.setErrorHandler(
       th -> {
         log.debug("QUIT failed, ignoring exception", th);
         resultHandler.handle(null);
       });
   connection.write(
       "QUIT",
       message -> {
         log.debug("QUIT result: " + message);
         if (!StatusCode.isStatusOk(message)) {
           log.warn("quit failed: " + message);
         }
         resultHandler.handle(null);
       });
 }
Пример #7
0
 @Override
 protected synchronized void handleClosed() {
   checkContext();
   if (endHandler != null) {
     endHandler.handle(null);
   }
   super.handleClosed();
   if (vertx.eventBus() != null) {
     registration.unregister();
   }
 }
Пример #8
0
 void handleDrained() {
   synchronized (getLock()) {
     if (drainHandler != null) {
       try {
         drainHandler.handle(null);
       } catch (Throwable t) {
         handleException(t);
       }
     }
   }
 }
Пример #9
0
 void handleResponse(HttpClientResponseImpl resp) {
   synchronized (getLock()) {
     // If an exception occurred (e.g. a timeout fired) we won't receive the response.
     if (!exceptionOccurred) {
       cancelOutstandingTimeoutTimer();
       try {
         if (resp.statusCode() == 100) {
           if (continueHandler != null) {
             continueHandler.handle(null);
           }
         } else {
           if (respHandler != null) {
             respHandler.handle(resp);
           }
           if (endHandler != null) {
             endHandler.handle(null);
           }
         }
       } catch (Throwable t) {
         handleException(t);
       }
     }
   }
 }
Пример #10
0
 @Override
 public void findUser(Handler<User> handler, String userName) {
   findUsers(
       result -> {
         User user;
         if (result.size() == 0) {
           user = null;
         } else {
           // Should only be one with this name
           user = result.get(0);
         }
         handler.handle(user);
       },
       new JsonObject().put("userName", userName));
 }
Пример #11
0
 @Override
 public HttpClientRequest exceptionHandler(Handler<Throwable> handler) {
   synchronized (getLock()) {
     if (handler != null) {
       checkComplete();
       this.exceptionHandler =
           t -> {
             cancelOutstandingTimeoutTimer();
             handler.handle(t);
           };
     } else {
       this.exceptionHandler = null;
     }
     return this;
   }
 }
 private void getRegistry(
     Lock lock, Handler resultHandler, Handler<Map<String, JsonObject>> next) {
   vertx.<Map<String, JsonObject>>executeBlocking(
       future -> {
         Map<String, JsonObject> map =
             ((VertxInternal) vertx).getClusterManager().getSyncMap("service.registry");
         future.complete(map);
       },
       map -> {
         if (map.succeeded()) {
           next.handle(map.result());
         } else {
           resultHandler.handle(Future.failedFuture(map.cause()));
           lock.release();
         }
       });
 }
Пример #13
0
 synchronized void handleDataReceived(Buffer data) {
   checkContext();
   if (paused) {
     if (pendingData == null) {
       pendingData = data.copy();
     } else {
       pendingData.appendBuffer(data);
     }
     return;
   }
   if (pendingData != null) {
     data = pendingData.appendBuffer(data);
   }
   reportBytesRead(data.length());
   if (dataHandler != null) {
     dataHandler.handle(data);
   }
 }
Пример #14
0
  @Override
  public void addUser(Handler<String> handler, User user) {
    String json = new Gson().toJson(user);
    JsonObject document = new JsonObject(json);

    mongo.insert(
        USER,
        document,
        res -> {
          // TODO
          // Check if the username already exists

          if (res.succeeded()) {
            handler.handle(res.result());
          } else {
            res.cause().printStackTrace();
          }
        });
  }
Пример #15
0
 void handleEnd(LastHttpContent trailer) {
   synchronized (conn) {
     conn.reportBytesRead(bytesRead);
     bytesRead = 0;
     request.reportResponseEnd(this);
     if (paused) {
       hasPausedEnd = true;
       pausedTrailer = trailer;
     } else {
       this.trailer = trailer;
       trailers = new HeadersAdaptor(trailer.trailingHeaders());
       if (endHandler != null) {
         try {
           endHandler.handle(null);
         } catch (Throwable t) {
           handleException(t);
         }
       }
     }
   }
 }
Пример #16
0
 @Override
 public synchronized NetSocket upgradeToSsl(final Handler<Void> handler) {
   SslHandler sslHandler = channel.pipeline().get(SslHandler.class);
   if (sslHandler == null) {
     sslHandler = helper.createSslHandler(vertx);
     channel.pipeline().addFirst("ssl", sslHandler);
   }
   sslHandler
       .handshakeFuture()
       .addListener(
           future ->
               context.executeFromIO(
                   () -> {
                     if (future.isSuccess()) {
                       handler.handle(null);
                     } else {
                       log.error(future.cause());
                     }
                   }));
   return this;
 }
Пример #17
0
 synchronized void handleFailure(RoutingContext context) {
   if (failureHandler != null) {
     failureHandler.handle(context);
   }
 }
Пример #18
0
 synchronized void handleContext(RoutingContext context) {
   if (contextHandler != null) {
     contextHandler.handle(context);
   }
 }
Пример #19
0
 void notifyHandler(Handler<Buffer> bodyHandler) {
   bodyHandler.handle(body());
   // reset body so it can get GC'ed
   body = null;
 }
Пример #20
0
  private Handler<HttpClientResponse> connectHandler(Handler<HttpClientResponse> responseHandler) {
    Objects.requireNonNull(responseHandler, "no null responseHandler accepted");
    return resp -> {
      HttpClientResponse response;
      if (resp.statusCode() == 200) {
        // connect successful force the modification of the ChannelPipeline
        // beside this also pause the socket for now so the user has a chance to register its
        // dataHandler
        // after received the NetSocket
        NetSocket socket = resp.netSocket();
        socket.pause();

        response =
            new HttpClientResponse() {
              private boolean resumed;

              @Override
              public int statusCode() {
                return resp.statusCode();
              }

              @Override
              public String statusMessage() {
                return resp.statusMessage();
              }

              @Override
              public MultiMap headers() {
                return resp.headers();
              }

              @Override
              public String getHeader(String headerName) {
                return resp.getHeader(headerName);
              }

              @Override
              public String getHeader(CharSequence headerName) {
                return resp.getHeader(headerName);
              }

              @Override
              public String getTrailer(String trailerName) {
                return resp.getTrailer(trailerName);
              }

              @Override
              public MultiMap trailers() {
                return resp.trailers();
              }

              @Override
              public List<String> cookies() {
                return resp.cookies();
              }

              @Override
              public HttpClientResponse bodyHandler(Handler<Buffer> bodyHandler) {
                resp.bodyHandler(bodyHandler);
                return this;
              }

              @Override
              public synchronized NetSocket netSocket() {
                if (!resumed) {
                  resumed = true;
                  vertx
                      .getContext()
                      .runOnContext(
                          (v) ->
                              socket
                                  .resume()); // resume the socket now as the user had the chance to
                                              // register a dataHandler
                }
                return socket;
              }

              @Override
              public HttpClientResponse endHandler(Handler<Void> endHandler) {
                resp.endHandler(endHandler);
                return this;
              }

              @Override
              public HttpClientResponse handler(Handler<Buffer> handler) {
                resp.handler(handler);
                return this;
              }

              @Override
              public HttpClientResponse pause() {
                resp.pause();
                return this;
              }

              @Override
              public HttpClientResponse resume() {
                resp.resume();
                return this;
              }

              @Override
              public HttpClientResponse exceptionHandler(Handler<Throwable> handler) {
                resp.exceptionHandler(handler);
                return this;
              }
            };
      } else {
        response = resp;
      }
      responseHandler.handle(response);
    };
  }
Пример #21
0
 @Override
 public void handle(AsyncResult<DatagramSocket> event) {
   if (event.failed() && exceptionHandler != null) {
     exceptionHandler.handle(event.cause());
   }
 }