コード例 #1
0
  @Nullable
  public Script getScriptSync(@NotNull final String isolateId, @NotNull final String scriptId) {
    assertSyncRequestAllowed();

    final Semaphore semaphore = new Semaphore();
    semaphore.down();

    final Ref<Script> resultRef = Ref.create();

    addRequest(
        () ->
            myVmService.getObject(
                isolateId,
                scriptId,
                new GetObjectConsumer() {
                  @Override
                  public void received(Obj script) {
                    resultRef.set((Script) script);
                    semaphore.up();
                  }

                  @Override
                  public void received(Sentinel response) {
                    semaphore.up();
                  }

                  @Override
                  public void onError(RPCError error) {
                    semaphore.up();
                  }
                }));

    semaphore.waitFor(RESPONSE_WAIT_TIMEOUT);
    return resultRef.get();
  }
コード例 #2
0
ファイル: SmoothProgressAdapter.java プロジェクト: jexp/idea2
  public synchronized void stop() {
    if (myOriginal.isRunning()) {
      myOriginal.stop();
    } else {
      myStartupAlarm.cancelAllRequests();
    }

    // needed only for correct assertion of !progress.isRunning() in
    // ApplicationImpl.runProcessWithProgressSynchroniously
    final Semaphore semaphore = new Semaphore();
    semaphore.down();

    SwingUtilities.invokeLater(
        new Runnable() {
          public void run() {
            semaphore.waitFor();
            if (myDialog != null) {
              // System.out.println("myDialog.destroyProcess()");
              myDialog.close(DialogWrapper.OK_EXIT_CODE);
              myDialog = null;
            }
          }
        });

    super.stop(); // should be last to not leaveModal before closing the dialog
    semaphore.up();
  }
コード例 #3
0
  private List<String> runCompiler(final Consumer<ErrorReportingCallback> runnable) {
    final Semaphore semaphore = new Semaphore();
    semaphore.down();
    final ErrorReportingCallback callback = new ErrorReportingCallback(semaphore);
    UIUtil.invokeAndWaitIfNeeded(
        new Runnable() {
          @Override
          public void run() {
            try {
              if (useJps()) {
                getProject().save();
                CompilerTestUtil.saveSdkTable();
                File ioFile = VfsUtil.virtualToIoFile(myModule.getModuleFile());
                if (!ioFile.exists()) {
                  getProject().save();
                  assert ioFile.exists() : "File does not exist: " + ioFile.getPath();
                }
              }
              runnable.consume(callback);
            } catch (Exception e) {
              throw new RuntimeException(e);
            }
          }
        });

    // tests run in awt
    while (!semaphore.waitFor(100)) {
      if (SwingUtilities.isEventDispatchThread()) {
        UIUtil.dispatchAllInvocationEvents();
      }
    }
    callback.throwException();
    return callback.getMessages();
  }
コード例 #4
0
  public static List<GitCommit> history(
      final Project project, @NotNull VirtualFile root, String... parameters) throws VcsException {
    final List<GitCommit> commits = new ArrayList<GitCommit>();
    final Semaphore semaphore = new Semaphore();
    semaphore.down();
    historyWithLinks(
        project,
        new FilePathImpl(root),
        null,
        new AsynchConsumer<GitCommit>() {
          @Override
          public void finished() {
            semaphore.up();
          }

          @Override
          public void consume(GitCommit gitCommit) {
            commits.add(gitCommit);
          }
        },
        null,
        null,
        parameters);
    semaphore.waitFor();
    return commits;
  }
コード例 #5
0
  static void invokeAndWait(
      @NotNull final Runnable runnable, @NotNull ModalityState modalityState) {
    LOG.assertTrue(!isDispatchThread());

    final Semaphore semaphore = new Semaphore();
    semaphore.down();
    final Ref<Throwable> exception = Ref.create();
    Runnable runnable1 =
        new Runnable() {
          @Override
          public void run() {
            try {
              runnable.run();
            } catch (Throwable e) {
              exception.set(e);
            } finally {
              semaphore.up();
            }
          }

          @Override
          @NonNls
          public String toString() {
            return "InvokeAndWait[" + runnable + "]";
          }
        };
    invokeLater(runnable1, modalityState);
    semaphore.waitFor();
    if (!exception.isNull()) {
      throw new RuntimeException(exception.get());
    }
  }
コード例 #6
0
  @Override
  public void commitAndRunReadAction(@NotNull final Runnable runnable) {
    final Application application = ApplicationManager.getApplication();
    if (SwingUtilities.isEventDispatchThread()) {
      commitAllDocuments();
      runnable.run();
    } else {
      LOG.assertTrue(
          !ApplicationManager.getApplication().isReadAccessAllowed(),
          "Don't call commitAndRunReadAction inside ReadAction, it will cause a deadlock otherwise.");

      final Semaphore s1 = new Semaphore();
      final Semaphore s2 = new Semaphore();
      final boolean[] committed = {false};

      application.runReadAction(
          new Runnable() {
            @Override
            public void run() {
              if (myUncommittedDocuments.isEmpty()) {
                runnable.run();
                committed[0] = true;
              } else {
                s1.down();
                s2.down();
                final Runnable commitRunnable =
                    new Runnable() {
                      @Override
                      public void run() {
                        commitAllDocuments();
                        s1.up();
                        s2.waitFor();
                      }
                    };
                final ProgressIndicator progressIndicator =
                    ProgressManager.getInstance().getProgressIndicator();
                if (progressIndicator == null) {
                  ApplicationManager.getApplication().invokeLater(commitRunnable);
                } else {
                  ApplicationManager.getApplication()
                      .invokeLater(commitRunnable, progressIndicator.getModalityState());
                }
              }
            }
          });

      if (!committed[0]) {
        s1.waitFor();
        application.runReadAction(
            new Runnable() {
              @Override
              public void run() {
                s2.up();
                runnable.run();
              }
            });
      }
    }
  }
コード例 #7
0
  @Override
  public boolean executeTask(
      DataContext context,
      RunConfiguration configuration,
      ExecutionEnvironment env,
      final BuildArtifactsBeforeRunTask task) {
    final Ref<Boolean> result = Ref.create(false);
    final Semaphore finished = new Semaphore();

    final List<Artifact> artifacts = new ArrayList<Artifact>();
    new ReadAction() {
      @Override
      protected void run(final Result result) {
        for (ArtifactPointer pointer : task.getArtifactPointers()) {
          ContainerUtil.addIfNotNull(pointer.get(), artifacts);
        }
      }
    }.execute();

    final CompileStatusNotification callback =
        new CompileStatusNotification() {
          @Override
          public void finished(
              boolean aborted, int errors, int warnings, CompileContext compileContext) {
            result.set(!aborted && errors == 0);
            finished.up();
          }
        };
    final Condition<Compiler> compilerFilter =
        new Condition<Compiler>() {
          @Override
          public boolean value(com.intellij.openapi.compiler.Compiler compiler) {
            return compiler instanceof ArtifactsCompiler
                || compiler instanceof ArtifactAwareCompiler
                    && ((ArtifactAwareCompiler) compiler).shouldRun(artifacts);
          }
        };

    ApplicationManager.getApplication()
        .invokeAndWait(
            new Runnable() {
              @Override
              public void run() {
                final CompilerManager manager = CompilerManager.getInstance(myProject);
                finished.down();
                manager.make(
                    ArtifactCompileScope.createArtifactsScope(myProject, artifacts),
                    compilerFilter,
                    callback);
              }
            },
            ModalityState.NON_MODAL);

    finished.waitFor();
    return result.get();
  }
コード例 #8
0
ファイル: PeriodicalTasksCloser.java プロジェクト: jexp/idea2
  public static void invokeAndWaitInterruptedWhenClosing(
      final Project project, final Runnable runnable, final ModalityState modalityState) {
    final Ref<Boolean> start = new Ref<Boolean>(Boolean.TRUE);
    final Application application = ApplicationManager.getApplication();
    LOG.assertTrue(!application.isDispatchThread());

    final Semaphore semaphore = new Semaphore();
    semaphore.down();
    Runnable runnable1 =
        new Runnable() {
          public void run() {
            try {
              runnable.run();
            } finally {
              semaphore.up();
            }
          }

          @NonNls
          public String toString() {
            return "PeriodicalTaskCloser's invoke and wait [" + runnable.toString() + "]";
          }
        };
    LaterInvocator.invokeLater(
        runnable1,
        modalityState,
        new Condition<Object>() {
          public boolean value(Object o) {
            synchronized (start) {
              return !start.get();
            }
          }
        });

    while (true) {
      if (semaphore.waitFor(1000)) {
        return;
      }
      final Ref<Boolean> fire = new Ref<Boolean>();
      synchronized (ourLock) {
        final Boolean state = myStates.get(project);
        if (!Boolean.TRUE.equals(state)) {
          fire.set(Boolean.TRUE);
        }
        if (Boolean.TRUE.equals(fire.get())) {
          synchronized (start) {
            start.set(Boolean.FALSE);
            return;
          }
        }
      }
    }
  }
コード例 #9
0
 // blocks until all elements in the queue are processed
 public void waitFor() {
   final Semaphore semaphore = new Semaphore();
   semaphore.down();
   schedule(
       new Runnable() {
         @Override
         public void run() {
           semaphore.up();
         }
       });
   semaphore.waitFor();
 }
コード例 #10
0
 private void waitForProcess(Application application) {
   myWaitSemaphore = new Semaphore();
   myWaitSemaphore.down();
   myWaitForThreadFuture =
       application.executeOnPooledThread(
           () -> {
             try {
               myProcess.waitFor();
             } catch (InterruptedException ignored) {
             } finally {
               myWaitSemaphore.up();
             }
           });
 }
コード例 #11
0
  private CompilationLog compile(final ParameterizedRunnable<CompileStatusNotification> action) {
    final Ref<CompilationLog> result = Ref.create(null);
    final Semaphore semaphore = new Semaphore();
    UIUtil.invokeAndWaitIfNeeded(
        new Runnable() {
          @Override
          public void run() {
            semaphore.down();

            CompilerManagerImpl.testSetup();
            final CompileStatusNotification callback =
                new CompileStatusNotification() {
                  @Override
                  public void finished(
                      boolean aborted, int errors, int warnings, CompileContext compileContext) {
                    try {
                      if (aborted) {
                        Assert.fail("compilation aborted");
                      }
                      result.set(
                          new CompilationLog(
                              CompilerManagerImpl.getPathsToRecompile(),
                              CompilerManagerImpl.getPathsToDelete(),
                              compileContext.getMessages(CompilerMessageCategory.ERROR),
                              compileContext.getMessages(CompilerMessageCategory.WARNING)));
                    } finally {
                      semaphore.up();
                    }
                  }
                };
            if (useExternalCompiler()) {
              myProject.save();
              CompilerTestUtil.saveSdkTable();
              CompilerTestUtil.scanSourceRootsToRecompile(myProject);
            }
            action.run(callback);
          }
        });

    long start = System.currentTimeMillis();
    while (!semaphore.waitFor(10)) {
      if (System.currentTimeMillis() - start > 60 * 1000) {
        throw new RuntimeException("timeout");
      }
      UIUtil.dispatchAllInvocationEvents();
    }
    UIUtil.dispatchAllInvocationEvents();

    return result.get();
  }
コード例 #12
0
  protected ProcessHandler runProcess(
      String className,
      Module module,
      final Class<? extends Executor> executorClass,
      final ProcessListener listener,
      final ProgramRunner runner)
      throws ExecutionException {
    final ApplicationConfiguration configuration =
        new ApplicationConfiguration(
            "app", getProject(), ApplicationConfigurationType.getInstance());
    configuration.setModule(module);
    configuration.setMainClassName(className);
    final Executor executor = Executor.EXECUTOR_EXTENSION_NAME.findExtension(executorClass);
    final ExecutionEnvironment environment =
        new ExecutionEnvironment(
            configuration,
            getProject(),
            new RunnerSettings<JDOMExternalizable>(null, null),
            null,
            null);
    final Semaphore semaphore = new Semaphore();
    semaphore.down();

    final AtomicReference<ProcessHandler> processHandler = new AtomicReference<ProcessHandler>();
    runner.execute(
        executor,
        environment,
        new ProgramRunner.Callback() {
          @Override
          public void processStarted(final RunContentDescriptor descriptor) {
            disposeOnTearDown(
                new Disposable() {
                  @Override
                  public void dispose() {
                    Disposer.dispose(descriptor);
                  }
                });
            final ProcessHandler handler = descriptor.getProcessHandler();
            assert handler != null;
            handler.addProcessListener(listener);
            processHandler.set(handler);
            semaphore.up();
          }
        });
    semaphore.waitFor();
    return processHandler.get();
  }
コード例 #13
0
ファイル: AppTest.java プロジェクト: Turbo87/intellij-plugins
  private void openAndWait(VirtualFile file, @Nullable String relativePath)
      throws InterruptedException, IOException {
    semaphore.down();

    DesignerApplicationManager.getInstance()
        .renderDocument(myModule, Tests.virtualToPsi(myProject, file));
    await();
  }
コード例 #14
0
  public void stop() {
    super.stop();

    myQueue.cancelAllUpdates();
    myFreezeSemaphore.up();

    ApplicationManager.getApplication()
        .invokeLater(
            new Runnable() {
              public void run() {
                final CompletionPhase phase = CompletionServiceImpl.getCompletionPhase();
                if (!(phase instanceof CompletionPhase.BgCalculation)
                    || phase.indicator != CompletionProgressIndicator.this) return;

                LOG.assertTrue(!getProject().isDisposed(), "project disposed");

                if (myEditor.isDisposed()) {
                  LookupManager.getInstance(getProject()).hideActiveLookup();
                  CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion);
                  return;
                }

                if (myEditor instanceof EditorWindow) {
                  LOG.assertTrue(
                      ((EditorWindow) myEditor).getInjectedFile().isValid(),
                      "injected file !valid");
                  LOG.assertTrue(
                      ((DocumentWindow) myEditor.getDocument()).isValid(), "docWindow !valid");
                }
                PsiFile file = myLookup.getPsiFile();
                LOG.assertTrue(file == null || file.isValid(), "file !valid");

                myLookup.setCalculating(false);

                if (hideAutopopupIfMeaningless()) {
                  return;
                }

                if (myCount == 0) {
                  if (!isAutopopupCompletion()) {
                    LookupManager.getInstance(getProject()).hideActiveLookup();

                    final CompletionProgressIndicator current =
                        CompletionServiceImpl.getCompletionService().getCurrentCompletion();
                    LOG.assertTrue(
                        current == null, current + "!=" + CompletionProgressIndicator.this);

                    handleEmptyLookup(!((CompletionPhase.BgCalculation) phase).modifiersChanged);
                  }
                } else {
                  CompletionServiceImpl.setCompletionPhase(
                      new CompletionPhase.ItemsCalculated(CompletionProgressIndicator.this));
                  updateLookup();
                }
              }
            },
            myQueue.getModalityState());
  }
コード例 #15
0
  protected void performRemoteGitTask(final GitLineHandler handler, String title)
      throws ServerRuntimeException {
    final GitTask task = new GitTask(myProject, handler, title);
    task.setProgressAnalyzer(new GitStandardProgressAnalyzer());

    final Semaphore semaphore = new Semaphore();
    semaphore.down();

    final Ref<ServerRuntimeException> errorRef = new Ref<ServerRuntimeException>();

    ApplicationManager.getApplication()
        .invokeLater(
            new Runnable() {

              @Override
              public void run() {
                task.execute(
                    false,
                    false,
                    new GitTaskResultHandlerAdapter() {

                      @Override
                      protected void run(GitTaskResult result) {
                        super.run(result);
                        semaphore.up();
                      }

                      @Override
                      protected void onFailure() {
                        for (VcsException error : handler.errors()) {
                          myLoggingHandler.println(error.toString());
                          if (errorRef.isNull()) {
                            errorRef.set(new ServerRuntimeException(error));
                          }
                        }
                      }
                    });
              }
            });

    semaphore.waitFor();
    if (!errorRef.isNull()) {
      throw errorRef.get();
    }
  }
コード例 #16
0
 public Waiter(
     @NotNull Project project, @NotNull Runnable runnable, String title, boolean cancellable) {
   super(
       project,
       VcsBundle.message("change.list.manager.wait.lists.synchronization", title),
       cancellable);
   myRunnable = runnable;
   mySemaphore.down();
   setCancelText("Skip");
 }
コード例 #17
0
  public void run(@NotNull ProgressIndicator indicator) {
    indicator.setIndeterminate(true);
    indicator.setText2(VcsBundle.message("commit.wait.util.synched.text"));

    if (!myStarted.compareAndSet(false, true)) {
      LOG.error("Waiter running under progress being started again.");
    } else {
      while (!mySemaphore.waitFor(500)) {
        indicator.checkCanceled();
      }
    }
  }
コード例 #18
0
  @Nullable
  private String evaluateExpression(
      final @NotNull String isolateId,
      final @Nullable Frame vmTopFrame,
      final @Nullable XExpression xExpression) {
    final String evalText = xExpression == null ? null : xExpression.getExpression();
    if (vmTopFrame == null || StringUtil.isEmptyOrSpaces(evalText)) return null;

    final Ref<String> evalResult = new Ref<>();
    final Semaphore semaphore = new Semaphore();
    semaphore.down();

    myDebugProcess
        .getVmServiceWrapper()
        .evaluateInFrame(
            isolateId,
            vmTopFrame,
            evalText,
            new XDebuggerEvaluator.XEvaluationCallback() {
              @Override
              public void evaluated(@NotNull final XValue result) {
                if (result instanceof DartVmServiceValue) {
                  evalResult.set(
                      getSimpleStringPresentation(((DartVmServiceValue) result).getInstanceRef()));
                }
                semaphore.up();
              }

              @Override
              public void errorOccurred(@NotNull final String errorMessage) {
                evalResult.set(
                    "Failed to evaluate log expression [" + evalText + "]: " + errorMessage);
                semaphore.up();
              }
            },
            true);

    semaphore.waitFor(1000);
    return evalResult.get();
  }
コード例 #19
0
  public synchronized void close() throws IOException {
    if (myWaitForThreadFuture != null) {
      myWaitForThreadFuture.cancel(true);
    }
    if (myWaitSemaphore != null) {
      myWaitSemaphore.up();
    }

    try {
      if (myInputStream != null && !myContainsError) {
        myInputStream.close();
        try {
          Thread.sleep(10);
        } catch (InterruptedException e) {
          // ignore
        }
      }
    } finally {
      try {
        if (myOutputStream != null && !myContainsError) {
          myOutputStream.close();
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            // ignore
          }
        }
        try {
          if (myErrThread != null) {
            myErrThread.setProcessTerminated(true);
          }
          if (myStdErrFuture != null) {
            myStdErrFuture.get();
          }
        } catch (InterruptedException e) {
          //
        } catch (ExecutionException e) {
          LOG.error(e);
        }
      } finally {
        try {
          if (myProcess != null) {
            myProcess.destroy();
          }
        } finally {
          myInputStream = null;
          myOutputStream = null;
          myProcess = null;
        }
      }
    }
  }
コード例 #20
0
  @Override
  public synchronized void stop() {
    if (myOriginal.isRunning()) {
      myOriginal.stop();
    } else {
      myStartupAlarm.cancelAllRequests();

      if (!myOriginalStarted && myOriginal instanceof Disposable) {
        // dispose original because start & stop were not called so original progress might not have
        // released its resources
        Disposer.dispose(((Disposable) myOriginal));
      }
    }

    // needed only for correct assertion of !progress.isRunning() in
    // ApplicationImpl.runProcessWithProgressSynchroniously
    final Semaphore semaphore = new Semaphore();
    semaphore.down();

    SwingUtilities.invokeLater(
        new Runnable() {
          @Override
          public void run() {
            semaphore.waitFor();
            if (myDialog != null) {
              // System.out.println("myDialog.destroyProcess()");
              myDialog.close(DialogWrapper.OK_EXIT_CODE);
              myDialog = null;
            }
          }
        });

    try {
      super.stop(); // should be last to not leaveModal before closing the dialog
    } finally {
      semaphore.up();
    }
  }
コード例 #21
0
  @Override
  public void waitForSmartMode() {
    final Application application = ApplicationManager.getApplication();
    if (!application.isUnitTestMode()) {
      assert !application.isDispatchThread();
      assert !application.isReadAccessAllowed();
    }

    if (!isDumb()) {
      return;
    }

    final Semaphore semaphore = new Semaphore();
    semaphore.down();
    runWhenSmart(
        new Runnable() {
          @Override
          public void run() {
            semaphore.up();
          }
        });
    semaphore.waitFor();
  }
コード例 #22
0
 private void execute(final MavenRunnerParameters params) {
   final Semaphore sema = new Semaphore();
   sema.down();
   UIUtil.invokeLaterIfNeeded(
       new Runnable() {
         @Override
         public void run() {
           MavenRunConfigurationType.runConfiguration(
               myProject,
               params,
               getMavenGeneralSettings(),
               new MavenRunnerSettings(),
               new ProgramRunner.Callback() {
                 @Override
                 public void processStarted(final RunContentDescriptor descriptor) {
                   descriptor
                       .getProcessHandler()
                       .addProcessListener(
                           new ProcessAdapter() {
                             @Override
                             public void processTerminated(ProcessEvent event) {
                               sema.up();
                               UIUtil.invokeLaterIfNeeded(
                                   new Runnable() {
                                     @Override
                                     public void run() {
                                       Disposer.dispose(descriptor);
                                     }
                                   });
                             }
                           });
                 }
               });
         }
       });
   sema.waitFor();
 }
コード例 #23
0
ファイル: AppTest.java プロジェクト: Turbo87/intellij-plugins
  private void insertString(VirtualFile file, int offset, @NotNull CharSequence s)
      throws InterruptedException {
    final Document document = FileDocumentManager.getInstance().getDocument(file);
    assertNotNull(document);
    AccessToken token = WriteAction.start();
    try {
      document.insertString(offset, s);
    } finally {
      token.finish();
    }

    semaphore.down();
    PsiDocumentManager.getInstance(myProject).commitAllDocuments();
    FileDocumentManager.getInstance().saveAllDocuments();
    await();
  }
コード例 #24
0
ファイル: AppTest.java プロジェクト: Turbo87/intellij-plugins
  private void renderAndWait(VirtualFile file) throws InterruptedException {
    semaphore.down();
    AsyncResult<DocumentInfo> result =
        DesignerApplicationManager.getInstance()
            .renderDocument(myModule, Tests.virtualToPsi(myProject, file));

    result.doWhenProcessed(
        new Runnable() {
          @Override
          public void run() {
            semaphore.up();
          }
        });

    await();
  }
コード例 #25
0
ファイル: AppTest.java プロジェクト: Turbo87/intellij-plugins
 private void callClientAssert(VirtualFile file) throws IOException, InterruptedException {
   semaphore.down();
   ActionCallback callback =
       client.test(
           null,
           DocumentFactoryManager.getInstance().getId(file),
           getTestName(false),
           APP_TEST_CLASS_ID);
   callback.doWhenProcessed(
       new Runnable() {
         @Override
         public void run() {
           semaphore.up();
         }
       });
   await();
 }
コード例 #26
0
  public void fireEvents(boolean hasWriteAction) {
    try {
      if (!iHaveEventsToFire) return;

      if (hasWriteAction) {
        fireEventsInWriteAction();
      } else {
        ApplicationManager.getApplication()
            .runWriteAction(
                new Runnable() {
                  @Override
                  public void run() {
                    fireEventsInWriteAction();
                  }
                });
      }
    } finally {
      mySemaphore.up();
    }
  }
コード例 #27
0
ファイル: AppTest.java プロジェクト: Turbo87/intellij-plugins
 @Override
 protected void processCommand(int command) throws IOException {
   boolean result = true;
   try {
     super.processCommand(command);
   } catch (Throwable e) {
     //noinspection InstanceofCatchParameter
     if (!(e instanceof SocketException)) {
       result = false;
       fail.set(true);
       try {
         LOG.error(e);
       } catch (AssertionError ignored) {
       }
     }
   } finally {
     if (!result) {
       semaphore.up();
     }
   }
 }
コード例 #28
0
 @Override
 public void finished(
     boolean aborted, int errors, int warnings, final CompileContext compileContext) {
   try {
     for (CompilerMessageCategory category : CompilerMessageCategory.values()) {
       for (CompilerMessage message : compileContext.getMessages(category)) {
         final String msg = message.getMessage();
         if (category != CompilerMessageCategory.INFORMATION
             || !msg.startsWith("Compilation completed successfully")) {
           myMessages.add(category + ": " + msg);
         }
       }
     }
     if (errors > 0) {
       fail("Compiler errors occurred! " + StringUtil.join(myMessages, "\n"));
     }
     assertFalse("Code did not compile!", aborted);
   } catch (Throwable t) {
     myError = t;
   } finally {
     mySemaphore.up();
   }
 }
コード例 #29
0
  @CalledInAwt
  public void execute() {
    FileDocumentManager.getInstance().saveAllDocuments();

    mySemaphore.down();
    runInEdt(
        () -> {
          if (areInSameHierarchy(
              createUrl(myMergeContext.getSourceUrl()), myMergeContext.getWcInfo().getUrl())) {
            end("Cannot merge from self", true);
          } else if (!hasSwitchedRoots() || myInteraction.shouldContinueSwitchedRootFound()) {
            runInBackground(
                "Checking repository capabilities",
                indicator -> {
                  if (supportsMergeInfo()) {
                    runInEdt(this::selectMergeVariant);
                  } else {
                    mergeAll(false);
                  }
                });
          }
        });
  }
コード例 #30
0
  private static boolean checkPort(final InetSocketAddress remoteAddress) {
    final ClientBootstrap bootstrap =
        new ClientBootstrap(new OioClientSocketChannelFactory(new PooledThreadExecutor()));
    bootstrap.setOption("child.tcpNoDelay", true);

    final AtomicBoolean result = new AtomicBoolean(false);
    final Semaphore semaphore = new Semaphore();
    semaphore.down(); // must call to down() here to ensure that down was called _before_ up()
    bootstrap.setPipeline(
        pipeline(
            new HttpResponseDecoder(),
            new HttpRequestEncoder(),
            new SimpleChannelUpstreamHandler() {
              @Override
              public void messageReceived(ChannelHandlerContext context, MessageEvent e)
                  throws Exception {
                try {
                  if (e.getMessage() instanceof HttpResponse) {
                    HttpResponse response = (HttpResponse) e.getMessage();
                    if (response.getStatus().equals(OK)
                        && response
                            .getContent()
                            .toString(CharsetUtil.US_ASCII)
                            .equals(getApplicationStartTime())) {
                      LOG.info("port check: current OS must be marked as normal");
                      result.set(true);
                    }
                  }
                } finally {
                  semaphore.up();
                }
              }

              @Override
              public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
                  throws Exception {
                try {
                  LOG.error(e.getCause());
                } finally {
                  semaphore.up();
                }
              }
            }));

    ChannelFuture connectFuture = null;
    try {
      connectFuture = bootstrap.connect(remoteAddress);
      if (!waitComplete(connectFuture, "connect")) {
        return false;
      }
      ChannelFuture writeFuture =
          connectFuture
              .getChannel()
              .write(new DefaultHttpRequest(HTTP_1_1, HttpMethod.GET, START_TIME_PATH));
      if (!waitComplete(writeFuture, "write")) {
        return false;
      }

      try {
        // yes, 30 seconds. I always get timeout in Linux in Parallels if I set to 2 seconds.
        // In any case all work is done in pooled thread (IDE init time isn't affected)
        if (!semaphore.waitForUnsafe(30000)) {
          LOG.info("port check: semaphore down timeout");
        }
      } catch (InterruptedException e) {
        LOG.info("port check: semaphore interrupted", e);
      }
    } finally {
      if (connectFuture != null) {
        connectFuture.getChannel().close().awaitUninterruptibly();
      }
      bootstrap.releaseExternalResources();
    }
    return result.get();
  }