예제 #1
0
  public void testCacheStopExpired() throws Exception {
    ProducerCache cache = new ProducerCache(this, context, 5);
    cache.start();

    assertEquals("Size should be 0", 0, cache.size());

    for (int i = 0; i < 8; i++) {
      Endpoint e = new MyEndpoint(true, i);
      Producer p = cache.acquireProducer(e);
      cache.releaseProducer(e, p);
    }

    // the eviction is async so force cleanup
    cache.cleanUp();

    assertEquals("Size should be 5", 5, cache.size());

    // the eviction listener is async so sleep a bit
    Thread.sleep(1000);

    // should have stopped the 3 evicted
    assertEquals(3, stopCounter.get());

    cache.stop();

    // should have stopped all 8
    assertEquals(8, stopCounter.get());
  }
  @Test
  public void bufferDiscardsStreamWhenFull() throws IOException, InterruptedException {
    CountDownLatch latch = new CountDownLatch(1);
    Pair<InputStream, List<byte[]>> stream = TestUtils.generateStream(100);

    MJpegStreamBufferer buffer = new MJpegStreamBufferer(5);

    AtomicInteger discardedCount = new AtomicInteger(0);

    buffer.start(
        new MJpegStreamBufferListener() {
          @Override
          public void stopped() {
            latch.countDown();
          }

          @Override
          public void streamBuffered(byte[] stream) {}

          @Override
          public void streamDiscarded(byte[] stream) {
            discardedCount.incrementAndGet();
          }
        },
        new MJpegStreamIterator(stream.getLeft()));

    latch.await();

    for (int x = 0; x < 5; ++x) {
      assertThat(buffer.get(), is(stream.getRight().get(x + 95)));
    }

    assertNull(buffer.get());
    assertThat(discardedCount.get(), is(95));
  }
예제 #3
0
  @Override
  public void handlePerspective(
      final Message<Event, Object> action, final PerspectiveLayout perspectiveLayout) {
    if (action.messageBodyEquals(MessageUtil.INIT)) {

      perspectiveLayout.registerRootComponent(createRoot());
      GridPane.setVgrow(perspectiveLayout.getRootComponent(), Priority.ALWAYS);
      GridPane.setHgrow(perspectiveLayout.getRootComponent(), Priority.ALWAYS);

      // register left panel
      perspectiveLayout.registerTargetLayoutComponent("content0", this.content1);
      perspectiveLayout.registerTargetLayoutComponent("content1", this.content2);
      perspectiveLayout.registerTargetLayoutComponent("content2", this.content3);
      ApplicationLauncherPerspectiveMessaginTest.latch.countDown();
    } else {
      if (counter.get() > 1) {
        counter.decrementAndGet();
        context.send("id10", "message");
      } else {
        System.out.println("Perspective id12: FINISH");
        if (wait.getCount() > 0) wait.countDown();
        if (PerspectiveMessagingTestP1.wait.getCount() > 0) context.send("id10", "message");
      }
    }
  }
  public E poll() {
    final AtomicInteger count = this.count;
    if (count.get() == 0) return null;

    Node<E> x = null;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();

    try {
      if (count.get() > 0) {
        x = extract();
        if (count.getAndDecrement() > 1) notEmpty.signal();
      }
    } finally {
      takeLock.unlock();
    }

    if (x != null) {
      E result = x.item;

      // temporary clearence
      x.item = null;
      x.next = null;

      return result;
    }

    return null;
  }
예제 #5
0
 private String api_getTokenType(Account account, String token, boolean liveToken)
     throws Exception {
   synchronized (account) {
     try {
       String tokenType = account.getStringProperty("tokenType", null);
       if (tokenType != null && liveToken == false) return tokenType;
       br.getPage("http://cloudzer.net/api/user/jdownloader?access_token=" + token);
       tokenType = br.getRegex("account_type\":\\s*?\"(premium|free)").getMatch(0);
       if (tokenType == null) handleErrorCode(br, account, token, true);
       account.setProperty("tokenType", tokenType);
       if ("premium".equals(tokenType)) {
         try {
           maxPrem.set(-1);
           account.setMaxSimultanDownloads(-1);
           account.setConcurrentUsePossible(true);
         } catch (final Throwable e) {
         }
       } else {
         try {
           maxPrem.set(1);
           account.setMaxSimultanDownloads(1);
           account.setConcurrentUsePossible(false);
         } catch (final Throwable e) {
         }
       }
       return tokenType;
     } catch (final PluginException e) {
       maxPrem.set(-1);
       account.setProperty("token", null);
       account.setProperty("tokenType", null);
       throw e;
     }
   }
 }
예제 #6
0
 protected void allocateBuffers(WebSocket c) throws InterruptedException {
   if (queuesize.get() >= 2 * decoders.size() + 1) {
     return;
   }
   queuesize.incrementAndGet();
   buffers.put(createBuffer());
 }
예제 #7
0
  private ProBInstance startProlog() {
    ProcessHandle processTuple = processProvider.get();
    Process process = processTuple.getProcess();
    String key = processTuple.getKey();
    final BufferedReader stream =
        new BufferedReader(
            new InputStreamReader(process.getInputStream(), Charset.defaultCharset()));

    Map<Class<? extends AbstractCliPattern<?>>, AbstractCliPattern<?>> cliInformation =
        extractCliInformation(stream);

    Integer port = ((PortPattern) cliInformation.get(PortPattern.class)).getValue();
    Long userInterruptReference =
        ((InterruptRefPattern) cliInformation.get(InterruptRefPattern.class)).getValue();

    ProBConnection connection = new ProBConnection(key, port);

    try {
      processCounter.incrementAndGet();
      connection.connect();
      ProBInstance cli =
          new ProBInstance(
              process, stream, userInterruptReference, connection, home, osInfo, processCounter);
      processes.add(new WeakReference<ProBInstance>(cli));
      return cli;
    } catch (IOException e) {
      processCounter.decrementAndGet();
      logger.error("Error connecting to Prolog binary.", e);
      return null;
    }
  }
  /**
   * Removes the specified element from this set if it is present. More formally, removes an element
   * {@code e} such that <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>, if this set
   * contains such an element. Returns {@code true} if this set contained the element (or
   * equivalently, if this set changed as a result of the call). (This set will not contain the
   * element once the call returns.)
   *
   * <p>The {@code writeLock} will be locked throughout the entire operation.
   *
   * @param elem element to be removed from this set, if present
   * @return {@code true} if this set contained the specified element
   */
  public synchronized boolean remove(E elem) {
    final boolean retValue;
    int localLeftRight = leftRight.get();
    // Do the add() in the first Tree, opposite to the one currently
    // being used by the Read operations. No need to wait.
    if (localLeftRight == READS_ON_LEFT) {
      retValue = rightTree.remove(elem);
    } else {
      retValue = leftTree.remove(elem);
    }
    // Optimization that only works for Sets
    if (!retValue) return false;

    // Toggle leftRight and wait for currently running Readers
    leftRight.set(-localLeftRight);
    toggleVersionAndScan();

    if (-localLeftRight == READS_ON_LEFT) {
      rightTree.remove(elem);
    } else {
      leftTree.remove(elem);
    }

    return retValue;
  }
  public void whenNormalOperation(boolean partitionSpecific, boolean remoteCall) {
    BasicBackPressureService service = newEnabledBackPressureService();

    Operation op;
    if (partitionSpecific) {
      PartitionSpecificOperation partitionOp = new PartitionSpecificOperation();
      partitionOp.setPartitionId(0);
      op = partitionOp;
    } else {
      op = new GenericOperation();
      op.setPartitionId(-1);
    }

    Connection connection = null;
    if (remoteCall) {
      connection = mock(Connection.class);
      OperationAccessor.setConnection(op, connection);
    }

    int expected = SYNC_WINDOW - 1;
    for (int k = 0; k < SYNC_WINDOW; k++) {
      boolean result = service.isBackPressureNeeded(op);
      assertFalse("no back pressure expected", result);

      AtomicInteger syncDelay = service.getSyncDelay(connection, op.getPartitionId());
      assertEquals(expected, syncDelay.get());
      expected--;
    }

    boolean result = service.isBackPressureNeeded(op);
    assertTrue("back pressure expected", result);

    AtomicInteger syncDelay = service.getSyncDelay(connection, op.getPartitionId());
    assertValidSyncDelay(syncDelay);
  }
예제 #10
0
  @Test
  public void uint16() {
    Wire wire = createWire();
    wire.write().uint16(1);
    wire.write(BWKey.field1).uint16(2);
    wire.write(() -> "Test").uint16(3);
    checkWire(
        wire,
        "[pos: 0, rlim: 16, wlim: 8EiB, cap: 8EiB ] À⒈Æfield1⒉ÄTest⒊",
        "[pos: 0, rlim: 22, wlim: 8EiB, cap: 8EiB ] À¢⒈٠Æfield1¢⒉٠ÄTest¢⒊٠",
        "[pos: 0, rlim: 11, wlim: 8EiB, cap: 8EiB ] À⒈º⒈⒉º²ñ\\u009E⒈⒊",
        "[pos: 0, rlim: 17, wlim: 8EiB, cap: 8EiB ] À¢⒈٠º⒈¢⒉٠º²ñ\\u009E⒈¢⒊٠",
        "[pos: 0, rlim: 3, wlim: 8EiB, cap: 8EiB ] ⒈⒉⒊",
        "[pos: 0, rlim: 9, wlim: 8EiB, cap: 8EiB ] ¢⒈٠¢⒉٠¢⒊٠");
    checkAsText123(wire);

    // ok as blank matches anything
    AtomicInteger i = new AtomicInteger();
    IntStream.rangeClosed(1, 3)
        .forEach(
            e -> {
              wire.read().uint16(i::set);
              assertEquals(e, i.get());
            });

    assertEquals(0, bytes.readRemaining());
    // check it's safe to read too much.
    wire.read();
  }
예제 #11
0
  @Test
  public void int32() {
    Wire wire = createWire();
    wire.write().int32(1);
    wire.write(BWKey.field1).int32(2);
    wire.write(() -> "Test").int32(3);
    checkWire(
        wire,
        "[pos: 0, rlim: 16, wlim: 8EiB, cap: 8EiB ] À⒈Æfield1⒉ÄTest⒊",
        "[pos: 0, rlim: 28, wlim: 8EiB, cap: 8EiB ] À¦⒈٠٠٠Æfield1¦⒉٠٠٠ÄTest¦⒊٠٠٠",
        "[pos: 0, rlim: 11, wlim: 8EiB, cap: 8EiB ] À⒈º⒈⒉º²ñ\\u009E⒈⒊",
        "[pos: 0, rlim: 23, wlim: 8EiB, cap: 8EiB ] À¦⒈٠٠٠º⒈¦⒉٠٠٠º²ñ\\u009E⒈¦⒊٠٠٠",
        "[pos: 0, rlim: 3, wlim: 8EiB, cap: 8EiB ] ⒈⒉⒊",
        "[pos: 0, rlim: 15, wlim: 8EiB, cap: 8EiB ] ¦⒈٠٠٠¦⒉٠٠٠¦⒊٠٠٠");
    checkAsText123(wire);

    // ok as blank matches anything
    AtomicInteger i = new AtomicInteger();
    IntStream.rangeClosed(1, 3)
        .forEach(
            e -> {
              wire.read().int32(i::set);
              assertEquals(e, i.get());
            });

    assertEquals(0, bytes.readRemaining());
    // check it's safe to read too much.
    wire.read();
  }
예제 #12
0
  @Test
  public void int8() {
    Wire wire = createWire();
    wire.write().int8((byte) 1);
    wire.write(BWKey.field1).int8((byte) 2);
    wire.write(() -> "Test").int8((byte) 3);
    checkWire(
        wire,
        "[pos: 0, rlim: 16, wlim: 8EiB, cap: 8EiB ] À⒈Æfield1⒉ÄTest⒊",
        "[pos: 0, rlim: 19, wlim: 8EiB, cap: 8EiB ] À¤⒈Æfield1¤⒉ÄTest¤⒊",
        "[pos: 0, rlim: 11, wlim: 8EiB, cap: 8EiB ] À⒈º⒈⒉º²ñ\\u009E⒈⒊",
        "[pos: 0, rlim: 14, wlim: 8EiB, cap: 8EiB ] À¤⒈º⒈¤⒉º²ñ\\u009E⒈¤⒊",
        "[pos: 0, rlim: 3, wlim: 8EiB, cap: 8EiB ] ⒈⒉⒊",
        "[pos: 0, rlim: 6, wlim: 8EiB, cap: 8EiB ] ¤⒈¤⒉¤⒊");
    checkAsText123(wire);

    // ok as blank matches anything
    AtomicInteger i = new AtomicInteger();
    IntStream.rangeClosed(1, 3)
        .forEach(
            e -> {
              wire.read().int8(i::set);
              assertEquals(e, i.get());
            });

    assertEquals(0, bytes.readRemaining());
    // check it's safe to read too much.
    wire.read();
  }
 /**
  * Computes the index of the next balancer to retrieve. Adaptation of the {@link AtomicInteger}
  * incrementAndGet() code.
  *
  * @return
  */
 private int getNextIndex() {
   for (; ; ) {
     int current = index.get();
     int next = (current == balancers.size() ? 1 : current + 1);
     if (index.compareAndSet(current, next)) return next - 1;
   }
 }
예제 #14
0
  public void testReleaseProducerInvokesStopAndShutdownByNonSingletonProducers() throws Exception {
    ProducerCache cache = new ProducerCache(this, context, 1);
    cache.start();

    assertEquals("Size should be 0", 0, cache.size());

    for (int i = 0; i < 3; i++) {
      Endpoint e = new MyEndpoint(false, i);
      Producer p = cache.acquireProducer(e);
      cache.releaseProducer(e, p);
    }

    assertEquals("Size should be 0", 0, cache.size());

    // should have stopped all 3
    assertEquals(3, stopCounter.get());

    // should have shutdown all 3
    assertEquals(3, shutdownCounter.get());

    cache.stop();

    // no more stop after stopping the cache
    assertEquals(3, stopCounter.get());

    // no more shutdown after stopping the cache
    assertEquals(3, shutdownCounter.get());
  }
예제 #15
0
  public synchronized PageBufferClientStatus getStatus() {
    String state;
    if (closed) {
      state = "closed";
    } else if (future != null) {
      state = "running";
    } else if (scheduled) {
      state = "scheduled";
    } else if (completed) {
      state = "completed";
    } else {
      state = "queued";
    }
    String httpRequestState = "not scheduled";
    if (future != null) {
      httpRequestState = future.getState();
    }

    long rejectedRows = rowsRejected.get();
    int rejectedPages = pagesRejected.get();

    return new PageBufferClientStatus(
        location,
        state,
        lastUpdate,
        rowsReceived.get(),
        pagesReceived.get(),
        rejectedRows == 0 ? OptionalLong.empty() : OptionalLong.of(rejectedRows),
        rejectedPages == 0 ? OptionalInt.empty() : OptionalInt.of(rejectedPages),
        requestsScheduled.get(),
        requestsCompleted.get(),
        requestsFailed.get(),
        httpRequestState);
  }
  @Test
  public void testIllegalToCreateChildEvenWithEdgeToEnd() {
    final AtomicInteger integer = new AtomicInteger();
    try {
      Intervals.inline(
          new AbstractTask("a") {
            @Override
            public void run(Interval subinterval) {
              final Interval a = subinterval.newAsyncChild(new TestInterval.IncTask("a", integer));

              subinterval.newAsyncChild(
                  new AbstractTask("b") {
                    @Override
                    public void run(Interval current) {
                      a.newAsyncChild(new TestInterval.IncTask("a1", integer, 10));
                    }
                  });
            }
          });
      Assert.fail();
    } catch (RethrownException e) {
      Assert.assertTrue(e.getCause() instanceof IntervalException.MustHappenBefore);
    }
    Assert.assertEquals(1, integer.get()); // a should execute
  }
 private void triggerSnapshotIfRequired(
     String type, Object aggregateIdentifier, final AtomicInteger eventCount) {
   if (eventCount.get() > trigger) {
     snapshotter.scheduleSnapshot(type, aggregateIdentifier);
     eventCount.set(1);
   }
 }
예제 #18
0
  @Override
  public void onInbound(InboundInterceptorContext context) throws Exception {
    if (context.request().requestType() == RequestType.CREATE) {
      ResourceResponse response =
          new DefaultResourceResponse(
              context.request(),
              ResourceResponse.ResponseType.CREATED,
              new Resource() {

                @Override
                public Resource parent() {
                  return null;
                }

                @Override
                public String id() {
                  return "mock";
                }
              });

      ResourceState state = new DefaultResourceState();
      state.putProperty("requestCounter", requestCounter.get());
      state.putProperty("responseCounter", responseCounter.get());
      response.setState(state);

      context.replyWith(response);
    } else {
      requestCounter.incrementAndGet();
      super.onInbound(context);
    }
  }
예제 #19
0
  @SuppressWarnings("deprecation")
  protected void afterEnd(Map flags, Task<?> task) {
    activeTaskCount.decrementAndGet();
    incompleteTaskCount.decrementAndGet();

    if (log.isTraceEnabled()) log.trace(this + " afterEnd, task: " + task);
    ExecutionUtils.invoke(flags.get("newTaskEndCallback"), task);
    List l = (List) flags.get("tagLinkedPreprocessors");
    Collections.reverse(l);
    for (Object li : l) {
      TaskPreprocessor t = (TaskPreprocessor) li;
      t.onEnd(flags, task);
    }

    PerThreadCurrentTaskHolder.perThreadCurrentTask.remove();
    ((BasicTask) task).endTimeUtc = System.currentTimeMillis();
    // clear thread _after_ endTime set, so we won't get a null thread when there is no end-time
    if (RENAME_THREADS) {
      String newThreadName = "brooklyn-" + LanguageUtils.newUid();
      ((BasicTask) task).thread.setName(newThreadName);
    }
    ((BasicTask) task).thread = null;
    synchronized (task) {
      task.notifyAll();
    }

    ExpirationPolicy expirationPolicy = (ExpirationPolicy) flags.get("expirationPolicy");
    if (expirationPolicy == null) expirationPolicy = ExpirationPolicy.IMMEDIATE;
    if (expirationPolicy == ExpirationPolicy.IMMEDIATE) {
      for (Object t : ((BasicTask) task).tags) {
        getMutableTasksWithTag(t).remove(task);
      }
    }
  }
  @Test
  public void shouldEvalScriptWithMapBindingsAndLanguageThenConsume() throws Exception {
    final GremlinExecutor gremlinExecutor =
        GremlinExecutor.build()
            .addEngineSettings(
                "nashorn",
                Collections.emptyList(),
                Collections.emptyList(),
                Collections.emptyList(),
                Collections.emptyMap())
            .create();
    final Map<String, Object> b = new HashMap<>();
    b.put("x", 1);

    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicInteger result = new AtomicInteger(0);
    assertEquals(
        2.0,
        gremlinExecutor
            .eval(
                "1+x",
                "nashorn",
                b,
                r -> {
                  result.set(((Double) r).intValue() * 2);
                  latch.countDown();
                })
            .get());

    latch.await();
    assertEquals(4, result.get());
    gremlinExecutor.close();
  }
  public E take() throws InterruptedException {
    Node<E> x;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
      try {
        while (count.get() == 0) notEmpty.await();
      } catch (InterruptedException ie) {
        notEmpty.signal(); // propagate to a non-interrupted thread
        throw ie;
      }

      x = extract();
      if (count.getAndDecrement() > 1) notEmpty.signal();
    } finally {
      takeLock.unlock();
    }

    E result = x.item;

    // temporary clearence
    x.item = null;
    x.next = null;

    return result;
  }
  @Test
  public void shouldNotExhaustThreads() throws Exception {
    final ScheduledExecutorService executorService =
        Executors.newScheduledThreadPool(2, testingThreadFactory);
    final GremlinExecutor gremlinExecutor =
        GremlinExecutor.build()
            .executorService(executorService)
            .scheduledExecutorService(executorService)
            .create();

    final AtomicInteger count = new AtomicInteger(0);
    assertTrue(
        IntStream.range(0, 1000)
            .mapToObj(i -> gremlinExecutor.eval("1+1"))
            .allMatch(
                f -> {
                  try {
                    return (Integer) f.get() == 2;
                  } catch (Exception ex) {
                    throw new RuntimeException(ex);
                  } finally {
                    count.incrementAndGet();
                  }
                }));

    assertEquals(1000, count.intValue());

    executorService.shutdown();
    executorService.awaitTermination(30000, TimeUnit.MILLISECONDS);
  }
예제 #23
0
 /** Returns the current number of objects, using its own transactions. */
 private int getObjectCount() throws Exception {
   final AtomicInteger countRef = new AtomicInteger(0);
   final AtomicReference<BigInteger> lastRef = new AtomicReference<BigInteger>();
   final AtomicBoolean done = new AtomicBoolean(false);
   while (!done.get()) {
     txnScheduler.runTask(
         new TestTask(
             new AbstractKernelRunnable() {
               public void run() {
                 BigInteger last = lastRef.get();
                 int count;
                 for (count = 0; count < 50; count++) {
                   BigInteger next = dataService.nextObjectId(last);
                   if (next == null) {
                     done.set(true);
                   }
                   last = next;
                 }
                 countRef.addAndGet(count);
                 lastRef.set(last);
               }
             }),
         taskOwner);
   }
   return countRef.get();
 }
예제 #24
0
  @Test
  public void testBaseMetaChange() throws Exception {
    startEngine();

    m_curator
        .setData()
        .forPath(ZKPathUtils.getBaseMetaVersionZkPath(), ZKSerializeUtils.serialize(100L));

    int retries = 50;
    int i = 0;
    while (m_baseMetaChangeCount.get() != 1 && i++ < retries) {
      TimeUnit.MILLISECONDS.sleep(100);
    }
    assertEquals(1, m_baseMetaChangeCount.get());

    m_curator
        .setData()
        .forPath(ZKPathUtils.getBaseMetaVersionZkPath(), ZKSerializeUtils.serialize(200L));

    i = 0;
    while (m_baseMetaChangeCount.get() != 2 && i++ < retries) {
      TimeUnit.MILLISECONDS.sleep(100);
    }
    assertEquals(2, m_baseMetaChangeCount.get());
  }
예제 #25
0
  @Override
  public void releaseClient(HClient client) throws HectorException {
    if (cassandraHost.getMaxActive() == 0) {
      client.close();
    }
    boolean open = client.isOpen();
    if (open) {
      if (active.get()) {
        addClientToPoolGently(client);
      } else {
        log.info(
            "Open client {} released to in-active pool for host {}. Closing.",
            client,
            cassandraHost);
        client.close();
      }
    } else {
      try {
        addClientToPoolGently(createClient());
      } catch (HectorTransportException e) {
        // if unable to open client then don't add one back to the pool
        log.error("Transport exception in re-opening client in release on {}", getName());
      }
    }

    realActiveClientsCount.decrementAndGet();
    activeClientsCount.decrementAndGet();

    if (log.isTraceEnabled()) {
      log.trace("Status of releaseClient {} to queue: {}", client.toString(), open);
    }
  }
예제 #26
0
  private Ref readRef(String name, RefList<Ref> packed) throws IOException {
    final RefList<LooseRef> curList = looseRefs.get();
    final int idx = curList.find(name);
    if (0 <= idx) {
      final LooseRef o = curList.get(idx);
      final LooseRef n = scanRef(o, name);
      if (n == null) {
        if (looseRefs.compareAndSet(curList, curList.remove(idx))) modCnt.incrementAndGet();
        return packed.get(name);
      }

      if (o == n) return n;
      if (looseRefs.compareAndSet(curList, curList.set(idx, n))) modCnt.incrementAndGet();
      return n;
    }

    final LooseRef n = scanRef(null, name);
    if (n == null) return packed.get(name);

    // check whether the found new ref is the an additional ref. These refs
    // should not go into looseRefs
    for (int i = 0; i < additionalRefsNames.length; i++)
      if (name.equals(additionalRefsNames[i])) return n;

    if (looseRefs.compareAndSet(curList, curList.add(idx, n))) modCnt.incrementAndGet();
    return n;
  }
예제 #27
0
  public int sendAlarm(final AlarmInfo alarmInfo) {
    AlarmType type = alarmInfo.type;
    String id = alarmInfo.getId();
    String extraInfo = alarmInfo.getExtraInfo();

    if (terminationToken.isToShutdown()) {
      // 记录告警信息
      System.err.println("rejected alarm:" + id + "," + extraInfo);
      return -1;
    }

    int duplicateSubmissionCount = 0;
    try {

      AtomicInteger prevSubmittedCounter;

      prevSubmittedCounter =
          submittedAlarmRegistry.putIfAbsent(
              type.toString() + ':' + id + '@' + extraInfo, new AtomicInteger(0));
      if (null == prevSubmittedCounter) {
        terminationToken.reservations.incrementAndGet();
        alarmQueue.put(alarmInfo);
      } else {

        // 故障未恢复,不用重复发送告警信息给服务器,故仅增加计数
        duplicateSubmissionCount = prevSubmittedCounter.incrementAndGet();
      }
    } catch (Throwable t) {
      t.printStackTrace();
    }

    return duplicateSubmissionCount;
  }
예제 #28
0
  @Test(timeout = 2000)
  public void testMultiTake() {
    final AtomicInteger count = new AtomicInteger();
    Observable.create(
            new OnSubscribe<Integer>() {

              @Override
              public void call(Subscriber<? super Integer> s) {
                for (int i = 0; !s.isUnsubscribed(); i++) {
                  System.out.println("Emit: " + i);
                  count.incrementAndGet();
                  s.onNext(i);
                }
              }
            })
        .take(100)
        .take(1)
        .toBlocking()
        .forEach(
            new Action1<Integer>() {

              @Override
              public void call(Integer t1) {
                System.out.println("Receive: " + t1);
              }
            });

    assertEquals(1, count.get());
  }
예제 #29
0
  private SliderRow forgeSliderRow(Slider slider) {
    String startLabel = slider.getStartLabel();
    TextElement startLabelEl =
        uifactory.addTextElement(
            "start.label." + count.incrementAndGet(), "start.label", 256, startLabel, flc);
    startLabelEl.setDomReplacementWrapperRequired(false);
    String endLabel = slider.getEndLabel();
    TextElement endLabelEl =
        uifactory.addTextElement(
            "end.label." + count.incrementAndGet(), "end.label", 256, endLabel, flc);
    endLabelEl.setDomReplacementWrapperRequired(false);

    SliderRow row = new SliderRow(slider, startLabelEl, endLabelEl);
    if (!restrictedEdit) {
      FormLink deleteButton =
          uifactory.addFormLink(
              "del." + count.incrementAndGet(),
              "delete_slider",
              "",
              null,
              flc,
              Link.BUTTON | Link.NONTRANSLATED);
      deleteButton.setDomReplacementWrapperRequired(false);
      deleteButton.setIconLeftCSS("o_icon o_icon-lg o_icon_delete_item");
      deleteButton.setUserObject(row);
      row.setDeleteButton(deleteButton);
      flc.contextPut("deleteButtons", Boolean.TRUE);
    }
    return row;
  }
  @Override
  public void doFilter(ServletRequest req, ServletResponse rsp, FilterChain chain)
      throws IOException, ServletException {

    try {
      HttpServletResponse hrsp = (HttpServletResponse) rsp;
      if (maxConnections > 0) {

        if (active.getAndIncrement() > maxConnections) {
          String msg = maxConnectionMessage;
          if (msg == null)
            msg =
                "Too many simultaneous requests (this is a small server, after all, this is not a commercial service)";
          hrsp.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, msg);
          return;
        }
      }

      Coordination c = coordinator.begin("osgi.enroute.webrequest." + active.incrementAndGet(), 0);
      try {
        chain.doFilter(req, rsp);
        c.end();
      } catch (Throwable t) {
        c.fail(t);
        throw t;
      }
    } finally {
      active.decrementAndGet();
    }
  }