コード例 #1
0
  private Collection<ClientServerExchangeLockContext> queryLock(LockID lock) {
    final ThreadID current = this.threadManager.getThreadID();

    this.inFlightLockQueries.put(current, lock);
    this.remoteLockManager.query(lock, this.threadManager.getThreadID());

    boolean interrupted = false;
    try {
      while (true) {
        synchronized (lock) {
          final Object data = this.inFlightLockQueries.get(current);
          if (data instanceof Collection) {
            return castToCollection(data);
          } else {
            try {
              lock.wait();
            } catch (final InterruptedException e) {
              interrupted = true;
            }
          }
        }
      }
    } finally {
      Util.selfInterruptIfNeeded(interrupted);
    }
  }
コード例 #2
0
  @Override
  public synchronized T fetchEntity()
      throws EntityNotFoundException, EntityVersionMismatchException {
    EntityClientEndpoint endpoint = null;
    try {
      ClientInstanceID clientInstanceID =
          new ClientInstanceID(this.nextClientInstanceID.getAndIncrement());
      EntityDescriptor entityDescriptor =
          new EntityDescriptor(getEntityID(), clientInstanceID, this.version);
      endpoint =
          this.entityManager.fetchEntity(
              entityDescriptor, entityClientService.getMessageCodec(), null);
    } catch (EntityException e) {
      // In this case, we want to close the endpoint but still throw back the exception.
      // Note that we must externally only present the specific exception types we were expecting.
      // Thus, we need to check
      // that this is one of those supported types, asserting that there was an unexpected wire
      // inconsistency, otherwise.
      if (e instanceof EntityNotFoundException) {
        throw (EntityNotFoundException) e;
      } else if (e instanceof EntityVersionMismatchException) {
        throw (EntityVersionMismatchException) e;
      } else {
        throw Assert.failure("Unsupported exception type returned to fetch", e);
      }
    } catch (final Throwable t) {
      Util.printLogAndRethrowError(t, logger);
    }

    // Note that a failure to resolve the endpoint would have thrown so this can't be null.
    if (endpoint == null) {
      Assert.assertNotNull(endpoint);
    }
    return (T) entityClientService.create(endpoint);
  }
コード例 #3
0
  /** ******************************* */
  private void waitUntilRunning() {
    this.stateGuard.readLock().lock();
    try {
      if (this.state == State.RUNNING) {
        return;
      }
    } finally {
      this.stateGuard.readLock().unlock();
    }

    boolean interrupted = false;
    this.stateGuard.writeLock().lock();
    try {
      while (this.state != State.RUNNING) {
        try {
          if (isShutdown()) {
            throw new TCNotRunningException();
          }
          this.runningCondition.await();
        } catch (final InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      this.stateGuard.writeLock().unlock();
      Util.selfInterruptIfNeeded(interrupted);
    }
  }
コード例 #4
0
 @Override
 public synchronized void waitForHandshake() {
   boolean isInterrupted = false;
   try {
     while (this.disconnected && !this.isShutdown()) {
       try {
         wait();
       } catch (InterruptedException e) {
         this.logger.error("Interrupted while waiting for handshake");
         isInterrupted = true;
       }
     }
   } finally {
     Util.selfInterruptIfNeeded(isInterrupted);
   }
 }
 private void blockIfNecessary() {
   boolean isInterrupted = false;
   try {
     while (bytes >= maxSegmentBytes) {
       try {
         sizeFullCondition.await();
       } catch (InterruptedException e) {
         isInterrupted = true;
       }
     }
   } finally {
     if (isInterrupted) {
       Util.selfInterruptIfNeeded(isInterrupted);
     }
   }
 }
    void addSelectorTask(final Runnable task) {
      boolean isInterrupted = false;

      try {
        while (true) {
          try {
            this.selectorTasks.put(task);
            break;
          } catch (InterruptedException e) {
            logger.warn(e);
            isInterrupted = true;
          }
        }
      } finally {
        this.selector.wakeup();
        Util.selfInterruptIfNeeded(isInterrupted);
      }
    }
    private Selector createSelector() {
      Selector selector1 = null;

      final int tries = 3;

      boolean interrupted = false;
      try {
        for (int i = 0; i < tries; i++) {
          try {
            selector1 = Selector.open();
            return selector1;
          } catch (IOException ioe) {
            throw new RuntimeException(ioe);
          } catch (NullPointerException npe) {
            if (i < tries && NIOWorkarounds.selectorOpenRace(npe)) {
              System.err.println(
                  "Attempting to work around sun bug 6427854 (attempt "
                      + (i + 1)
                      + " of "
                      + tries
                      + ")");
              try {
                Thread.sleep(new Random().nextInt(20) + 5);
              } catch (InterruptedException ie) {
                interrupted = true;
              }
              continue;
            }
            throw npe;
          }
        }
      } finally {
        Util.selfInterruptIfNeeded(interrupted);
      }

      return selector1;
    }
    private void selectLoop() throws IOException {
      Assert.eval(Thread.currentThread() == this);

      Selector localSelector = this.selector;
      LinkedBlockingQueue localSelectorTasks = this.selectorTasks;

      while (true) {
        final int numKeys;
        try {
          numKeys = localSelector.select();
        } catch (IOException ioe) {
          if (NIOWorkarounds.linuxSelectWorkaround(ioe)) {
            logger.warn("working around Sun bug 4504001");
            continue;
          }

          if (NIOWorkaroundsTemp.solarisSelectWorkaround(ioe)) {
            logger.warn("working around Solaris select IOException");
            continue;
          }

          throw ioe;
        } catch (CancelledKeyException cke) {
          logger.warn("Cencelled Key " + cke);
          continue;
        }

        if (isStopRequested()) {
          if (logger.isDebugEnabled()) {
            logger.debug("Select loop terminating");
          }
          return;
        }

        boolean isInterrupted = false;
        // run any pending selector tasks
        while (true) {
          Runnable task;
          while (true) {
            try {
              task = (Runnable) localSelectorTasks.poll(0, TimeUnit.MILLISECONDS);
              break;
            } catch (InterruptedException ie) {
              logger.error("Error getting task from task queue", ie);
              isInterrupted = true;
            }
          }

          if (null == task) {
            break;
          }

          try {
            task.run();
          } catch (Exception e) {
            logger.error("error running selector task", e);
          }
        }
        Util.selfInterruptIfNeeded(isInterrupted);

        final Set selectedKeys = localSelector.selectedKeys();
        if ((0 == numKeys) && (0 == selectedKeys.size())) {
          continue;
        }

        for (Iterator iter = selectedKeys.iterator(); iter.hasNext(); ) {
          SelectionKey key = (SelectionKey) iter.next();
          iter.remove();

          if (null == key) {
            logger.error("Selection key is null");
            continue;
          }

          try {

            if (key.isAcceptable()) {
              doAccept(key);
              continue;
            }

            if (key.isConnectable()) {
              doConnect(key);
              continue;
            }

            if (isReader() && key.isValid() && key.isReadable()) {
              int read;
              TCChannelReader reader = (TCChannelReader) key.attachment();
              do {
                read = reader.doRead();
                this.bytesRead.addAndGet(read);
              } while ((read != 0) && key.isReadable());
            }

            if (key.isValid() && !isReader() && key.isWritable()) {
              int written = ((TCChannelWriter) key.attachment()).doWrite();
              this.bytesWritten.addAndGet(written);
            }

            TCConnection conn = (TCConnection) key.attachment();
            if (conn != null && conn.isClosePending()) {
              conn.asynchClose();
            }

          } catch (CancelledKeyException cke) {
            logger.info("selection key cancelled key@" + key.hashCode());
          } catch (Exception e) { // DEV-9369. Do not reconnect on fatal errors.
            logger.info("Unhandled exception occured on connection layer", e);
            TCConnectionImpl conn = (TCConnectionImpl) key.attachment();
            // TCConnectionManager will take care of closing and cleaning up resources
            conn.fireErrorEvent(new RuntimeException(e), null);
          }
        } // for
      } // while (true)
    }