/** @see java.lang.Thread#run() */
    public void run() {
      // Wait for registration. Put it into a thread so this
      // can occur while other stuff goes on. It locks the fConnectionPool
      // until done so that the first request for a connection by anyone
      // else will wait until this thread is finished.

      synchronized (fConnectionPool) {
        synchronized (REMProxyFactoryRegistry.this) {
          // Notify the main thread that we have the
          // connection pool locked.
          REMProxyFactoryRegistry.this.notifyAll();
        }
        synchronized (this) {
          // sync on self so that it can be notified when finally receive the registration
          long stopTime = System.currentTimeMillis() + 60000;
          while (waitRegistrationThread != null
              && (fNoTimeouts || System.currentTimeMillis() < stopTime)) {
            try {
              Thread.currentThread().wait(60000);
            } catch (InterruptedException e) {
            }
          }
        }
      }

      waitRegistrationThread = null; // No longer exists.			
    }
 public void runViewUpdate(final Runnable runnable, final boolean preserveExpansion) {
   if (Utils.canUpdateViewer(getViewer()) || isPerformingBackgroundUpdate()) {
     internalRunViewUpdate(runnable, preserveExpansion);
   } else {
     if (Thread.currentThread() != getEventHandlerJob().getThread()) {
       // Run view update should only be called from the UI thread or
       // the update handler thread.
       // We will log the problem for now and make it an assert later
       TeamUIPlugin.log(
           IStatus.WARNING,
           "View update invoked from invalid thread",
           new TeamException(
               "View update invoked from invalid thread")); //$NON-NLS-1$ //$NON-NLS-2$
     }
     final Control ctrl = getViewer().getControl();
     if (ctrl != null && !ctrl.isDisposed()) {
       ctrl.getDisplay()
           .syncExec(
               new Runnable() {
                 public void run() {
                   if (!ctrl.isDisposed()) {
                     BusyIndicator.showWhile(
                         ctrl.getDisplay(),
                         new Runnable() {
                           public void run() {
                             internalRunViewUpdate(runnable, preserveExpansion);
                           }
                         });
                   }
                 }
               });
     }
   }
 }
 /**
  * Get a free connection
  *
  * @return
  * @throws IllegalStateException - Thrown if a connection cannot be created.
  * @since 1.0.0
  */
 public IREMConnection getFreeConnection() throws IllegalStateException {
   Thread thread = Thread.currentThread();
   if (thread instanceof REMCallbackThread) {
     // The current thread is a call back thread, so just reuse the connection.
     // But this thread could actually be trying to access another registry.
     // So if this thread is for this registry, use it, if not for this registry, create a new
     // connection.
     // But if for this registry AND is already in a transaction, we need a fresh connection.
     REMCallbackThread callbackThread = (REMCallbackThread) thread;
     if (callbackThread.registry == this && !callbackThread.inTransaction()) {
       // This way any calls out to the remote vm will be on same thread as callback caller
       // on remote vm because that thread is waiting on this connection for commands.
       IREMConnection c = (callbackThread).getConnection();
       if (c.isConnected()) return c;
       else
         throw new IllegalStateException(
             ProxyRemoteMessages.REMProxyFactoryRegistry_CallbackConnectionNotWorking_EXC_);
     }
   }
   synchronized (fConnectionPool) {
     if (!fConnectionPool.isEmpty()) return (IREMConnection) fConnectionPool.pop();
     // else we need to allocate one.
     return createConnection();
   }
 }
 /** Free the connection */
 public void returnConnection(IREMConnection connection) {
   if (connection.isConnected()) {
     Thread thread = Thread.currentThread();
     if (!(thread instanceof REMCallbackThread)
         || ((REMCallbackThread) thread).getConnection() != connection) {
       // We are not a callback thread, or we are but the connection is not for the thread, then
       // the connection
       // can be returned.
       synchronized (fConnectionPool) {
         if (fConnectionPool.size() < NUMBER_FREE_CONNECTIONS) fConnectionPool.push(connection);
         else connection.close(); // We don't need to maintain more than five free connections.
       }
     }
   }
 }
 /* (non-Javadoc)
  * @see java.lang.Thread#run()
  */
 public IStatus run(IProgressMonitor mon) {
   try {
     // There is no join on a process available, so we will have to
     // busy wait. Give it 10 seconds in 1/10 second intervals.
     for (int i = 0; !process.isTerminated() && i < 100; i++) {
       try {
         Thread.sleep(100);
       } catch (InterruptedException e) {
       }
     }
     if (!process.isTerminated()) {
       process.terminate();
     }
   } catch (DebugException e) {
   }
   return Status.OK_STATUS;
 }
 /*
  * Return whether the event handler is performing a background view update.
  * In other words, a client has invoked <code>performUpdate</code>.
  */
 public boolean isPerformingBackgroundUpdate() {
   return Thread.currentThread() == getEventHandlerJob().getThread() && performingBackgroundUpdate;
 }
  /**
   * Make a new connection.
   *
   * @return
   * @throws IllegalStateException - Thrown if connection cannot be created.
   * @since 1.0.0
   */
  protected IREMConnection createConnection() throws IllegalStateException {
    // If we have a server port, then the server is probably open. If we don't then there is no
    // server.
    if (fServerPort != 0) {
      // We are putting it off into a thread because there are no timeout capabilities on getting a
      // socket.
      // So we need to allow for that.
      final Socket[] scArray = new Socket[1];
      final boolean[] waiting = new boolean[] {true};
      Thread doIt =
          new Thread(
              new Runnable() {
                public void run() {
                  try {
                    Socket sc = new Socket("localhost", fServerPort); // $NON-NLS-1$
                    synchronized (this) {
                      if (waiting[0]) scArray[0] = sc;
                      else
                        sc
                            .close(); // We are no longer waiting on this thread so close the socket
                                      // since no one will use it.
                    }
                  } catch (IOException e) {
                    ProxyPlugin.getPlugin()
                        .getLogger()
                        .log(
                            new Status(
                                IStatus.WARNING,
                                ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
                                0,
                                "",
                                e)); //$NON-NLS-1$
                  }
                }
              });

      doIt.start();
      while (true) {
        try {
          doIt.join(!fNoTimeouts ? 60000 : 0);
          synchronized (doIt) {
            waiting[0] = false; // To let it know we are no longer waiting
          }
          break;
        } catch (InterruptedException e) {
        }
      }

      if (scArray[0] == null) {
        // Log where we are at so we can know where it was we down.
        ProxyPlugin.getPlugin()
            .getLogger()
            .log(
                new Status(
                    IStatus.WARNING,
                    ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
                    0,
                    "",
                    new IllegalStateException(
                        ProxyRemoteMessages
                            .REMProxyFactoryRegistry_ConnectionCreationFailed_INFO_))); //$NON-NLS-1$
        throw new IllegalStateException(
            ProxyRemoteMessages
                .REMProxyFactoryRegistry_CouldNotCreateSocketConnectionToRemoteVM_EXC_); // Couldn't
                                                                                         // get one,
                                                                                         // probably
                                                                                         // server
                                                                                         // is down.
                                                                                         // //$NON-NLS-1$
      }

      REMConnection connection = new REMConnection(scArray[0], fNoTimeouts);
      if (connection.isConnected()) return connection;

      // Failed, close the socket.
      try {
        scArray[0].close();
      } catch (IOException e) {
      }
    } else
      ProxyPlugin.getPlugin()
          .getLogger()
          .log(
              new Status(
                  IStatus.WARNING,
                  ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
                  0,
                  "No Server to retrieve a connection.",
                  null)); ///$NON-NLS-1$

    throw new IllegalStateException(
        ProxyRemoteMessages.REMProxyFactoryRegistry_CouldNotCreateSocketConnectionToRemoteVM_EXC_);
  }
 public void join() throws InterruptedException {
   if (job != null && job.getThread() != Thread.currentThread()) {
     job.join();
   }
 }