private void loadClientConfigRoot(@NotNull Project project, @NotNull ClientConfigRoot root) { RootNode fileRoot = createRootNode(root); try { List<ActionChoice> pendingActions = CacheComponent.getInstance(project).getCachePending().copyActions(root.getClientConfig()) .collect(Collectors.toList()); fileRoot.pending.setPendingCount(pendingActions.size()); pendingActions.forEach((ac) -> { DefaultMutableTreeNode actionNode = new DefaultMutableTreeNode(ac); fileRoot.pendingNode.add(actionNode); // File information on an action is static. for (FilePath affectedFile : ac.getAffectedFiles()) { actionNode.add(new DefaultMutableTreeNode(affectedFile)); } for (P4CommandRunner.ResultError previousExecutionProblem : ac.getPreviousExecutionProblems()) { actionNode.add(new DefaultMutableTreeNode(previousExecutionProblem)); } }); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException(e))); } }
@NotNull public static Map<ClientServerRef, P4ChangelistId> getActiveChangelistIds(@NotNull Project project) { LocalChangeList defaultIdeChangeList = ChangeListManager.getInstance(project).getDefaultChangeList(); Map<ClientServerRef, P4ChangelistId> ret = new HashMap<>(); try { CacheComponent.getInstance(project).getServerOpenedCache().first .getP4ChangesFor(defaultIdeChangeList) .forEach((id) -> ret.put(id.getClientServerRef(), id)); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException(e))); } return ret; }
InternalErrorMessage.send(project).cacheLockTimeoutError( new ErrorEvent<>(new VcsInterruptedException(e))); } catch (P4CommandRunner.ServerResultException e) {
InternalErrorMessage.send(project).cacheLockTimeoutError( new ErrorEvent<>(new VcsInterruptedException(e))); return null;
@Override @Nullable public VcsFileRevision getLastRevision(FilePath filePath) throws VcsException { ClientConfigRoot root = getRootFor(filePath); if (root == null) { LOG.info("File not under vcs: " + filePath); return null; } try { List<VcsFileRevision> revisions = getHistory(root, filePath, 1) .blockingGet(UserProjectPreferences.getLockWaitTimeoutMillis(project), TimeUnit.MILLISECONDS) .getRevisions(formatter, loader); if (revisions.isEmpty()) { if (LOG.isDebugEnabled()) { LOG.debug("no revisions found for " + filePath); } return null; } return revisions.get(0); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException(e))); return null; } }
@Override public void run(@NotNull ProgressIndicator progressIndicator) { progressIndicator.setIndeterminate(true); progressIndicator.startNonCancelableSection(); try { LOG.info("Fetching files into " + rootPath); FetchFilesResult r = P4ServerComponent .perform(project, clientConfig, new FetchFilesAction(Collections.singletonList(rootPath), null, false)) .blockingGet(UserProjectPreferences.getLockWaitTimeoutMillis(project), TimeUnit.MILLISECONDS); progressIndicator.finishNonCancelableSection(); synchronized (sync) { res = r; } } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>( new VcsInterruptedException(e))); progressIndicator.finishNonCancelableSection(); onCancel(); } catch (P4CommandRunner.ServerResultException e) { progressIndicator.finishNonCancelableSection(); VcsNotifier.getInstance(project).notifyError(P4Bundle.getString("checkout.config.error.title"), e.getMessage()); synchronized (sync) { res = null; } } progressIndicator.stop(); }
P4ChangeProvider(@NotNull P4Vcs vcs, @NotNull Disposable parentDisposable) { this.project = vcs.getProject(); this.vcs = vcs; this.loader = new HistoryContentLoaderImpl(project); final MessageBusClient.ApplicationClient mbClient = MessageBusClient.forApplication(parentDisposable); final String cacheId = AbstractCacheMessage.createCacheId(project, P4ChangeProvider.class); ClientActionMessage.addListener(mbClient, cacheId, event -> { P4CommandRunner.ClientActionCmd cmd = (P4CommandRunner.ClientActionCmd) event.getAction().getCmd(); try { switch (cmd) { case CREATE_CHANGELIST: onChangelistCreated( (CreateChangelistAction) event.getAction(), (CreateChangelistResult) event.getResult(), event.getState()); break; case DELETE_CHANGELIST: if (event.getState() == ClientActionMessage.ActionState.PENDING) { onChangelistDelete((DeleteChangelistAction) event.getAction()); } break; } } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>( new VcsInterruptedException(e))); } }); }
@Override public void changeListRenamed(final ChangeList list, final String oldName) { LOG.info("changeListRenamed: from " + oldName + " to " + list); if (! (list instanceof LocalChangeList)) { // ignore return; } // Don't check name equality, due to the reuse from // changeListCommentChanged LocalChangeList local = (LocalChangeList) list; for (ClientConfigRoot clientConfigRoot : getClientConfigRoots()) { try { P4ChangelistId change = CacheComponent.getInstance(myProject).getServerOpenedCache().first.getP4ChangeFor( clientConfigRoot.getClientConfig().getClientServerRef(), local); if (change != null) { P4ServerComponent .perform(myProject, clientConfigRoot.getClientConfig(), new EditChangelistAction(change, toDescription(local))); } } catch (InterruptedException e) { InternalErrorMessage.send(myProject).cacheLockTimeoutError(new ErrorEvent<>( new VcsInterruptedException(e))); } } }
private void createSwarmReviews(@NotNull Project project, @NotNull ProjectConfigRegistry registry, @NotNull List<ChangeList> changeLists) { Answer<Integer> next = Answer.resolve(0); for (ChangeList ideChangeList : changeLists) { if (ideChangeList instanceof LocalChangeList) { try { Collection<P4ChangelistId> p4Changelists = CacheComponent.getInstance(project).getServerOpenedCache().first. getP4ChangesFor((LocalChangeList) ideChangeList); if (!p4Changelists.isEmpty()) { for (P4ChangelistId p4Changelist : p4Changelists) { next = next.mapAsync(x -> SwarmReview.createOrEditSwarmReview(project, registry, ideChangeList, p4Changelist)); // Failure reporting is handled by the SwarmReview class. } // Skip the notOnServer message. continue; } } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>( new VcsInterruptedException("Timeout or interruption while reading list of changes", e))); } } SwarmErrorMessage.send(project).notOnServer(new SwarmErrorMessage.SwarmEvent(null), ideChangeList); } }
@Override public void actionPerformed(AnActionEvent anActionEvent) { final ClientConfigRoot selRoot = getSelected(ClientConfigRoot.class); final ActionChoice sel = getSelected(ActionChoice.class); final CacheComponent cache = CacheComponent.getInstance(project); if (selRoot != null && sel != null) { try { cache.getCachePending() .writeActions(selRoot.getClientConfig().getClientServerRef(), (c) -> c.removeActionById(sel.getActionId())); // Updating the cache to remove actions doesn't send out events, so we must // manually refresh the view. // TODO This could be done more elegantly. refresh(); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError( new ErrorEvent<>(new VcsInterruptedException(e))); } } }
@Override public void serverActionUpdate(@NotNull ServerActionCacheMessage.Event event) { try { if (event.getState() == ServerActionCacheMessage.ActionState.PENDING) { // Add the event pendingCache.writeActions(event.getServerName(), (store) -> store.addAction(event.getServerAction())); } else { // Remove the event pendingCache.writeActions(event.getServerName(), (store) -> store.removeActionById(event.getServerAction().getActionId())); } } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } }
@Nullable @Override public ProjectCacheStore.State getState() { try { return projectCache.getState(); } catch (InterruptedException e) { if (project != null) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>( new VcsInterruptedException(SERIALIZE_CACHE_TIMEOUT_MESSAGE, e))); } else { LOG.warn(SERIALIZE_CACHE_TIMEOUT_MESSAGE, e); } return null; } }
@Override public void fileActionUpdate(@NotNull FileActionMessage.Event event) { try { if (event.getState() == FileActionMessage.ActionState.PENDING) { pendingCache.writeActions(event.getClientRef(), (store) -> store.addAction(event.getClientAction())); } else { pendingCache.writeActions(event.getClientRef(), (store) -> store.removeActionById(event.getClientAction().getActionId())); } } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } // Do not fire a cache update message. }
@Override public void loadState(ProjectCacheStore.State state) { try { this.projectCache.setState(state); } catch (InterruptedException e) { if (project != null) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>( new VcsInterruptedException(DESERIALIZE_CACHE_TIMEOUT_MESSAGE, e))); } else { LOG.warn(DESERIALIZE_CACHE_TIMEOUT_MESSAGE, e); } } }
@Override public void listClientsForUserUpdate(@NotNull ListClientsForUserCacheMessage.Event event) { try { cache.write(event.getServerName(), (store) -> store.setUserClients(event.getUser(), event.getClients())); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } }
@Override public void jobSpecUpdate(@NotNull JobSpecCacheMessage.Event event) { try { cache.write(event.getServerName(), (store) -> store.setJobSpec(event.getJobSpec())); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } }
@Override public void clientActionUpdate(@NotNull ClientActionMessage.Event event) { if (LOG.isDebugEnabled()) { LOG.debug("Caching action " + event.getAction()); } try { handleClientAction(event); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } }
@Override public void jobUpdate(@NotNull JobCacheMessage.Event event) { try { cache.write(event.getServerName(), (store) -> store.addJob(event.getJob())); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } }
private void reportCacheWaitError(InterruptedException e) { if (project == null) { LOG.warn(CACHE_WAIT_ERROR_MESSAGE, e); } else { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( CACHE_WAIT_ERROR_MESSAGE, e))); } }
@Override public void clientConfigurationRemoved(@NotNull ClientConfigRemovedMessage.Event event) { Collection<ClientConfig> activeConfigs = getActiveClientConfigs(); try { cache.cleanClientCache(activeConfigs); } catch (InterruptedException e) { InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException( SERVER_CACHE_TIMEOUT_MESSAGE, e))); } } }