Examples with ISVNRemoteFolder org.tigris.subversion.subclipse.core.ISVNRemoteFolder used on opensource projects

Example 1 with ISVNRemoteFolder

use of org.tigris.subversion.subclipse.core.ISVNRemoteFolder in project subclipse by subclipse.

the class UpdateCacheAction method execute.

protected void execute(IAction action) throws InvocationTargetException, InterruptedException {
    final ISVNRemoteFolder[] selectedFolders = getSelectedRemoteFolders();
    GraphBackgroundTask task = new GraphBackgroundTask(SVNUIPlugin.getActivePage().getActivePart(), null, null, selectedFolders[0]);
    try {
        task.run();
    } catch (Exception e) {
        MessageDialog.openError(Display.getDefault().getActiveShell(), Policy.bind("UpdateCacheAction.title"), // $NON-NLS-1$
        e.getMessage());
    }
}

Example 2 with ISVNRemoteFolder

use of org.tigris.subversion.subclipse.core.ISVNRemoteFolder in project subclipse by subclipse.

the class SharingWizard method performFinish.

/*
   * @see IWizard#performFinish
   */
public boolean performFinish() {
    shareCanceled = false;
    if (!WorkspacePathValidator.validateWorkspacePath())
        return true;
    final boolean[] result = new boolean[] { true };
    try {
        final boolean[] doSync = new boolean[] { false };
        getContainer().run(true, /* fork */
        true, /* cancel */
        new IRunnableWithProgress() {

            public void run(IProgressMonitor monitor) throws InvocationTargetException {
                try {
                    // $NON-NLS-1$
                    monitor.beginTask("", 100);
                    if (autoconnectPage != null && (projectStatus != null)) {
                        // Autoconnect to the repository using svn/ directories
                        // Get the repository location (the get will add the locatin to the provider)
                        boolean isPreviouslyKnown = SVNProviderPlugin.getPlugin().getRepositories().isKnownRepository(projectStatus.getUrlString(), false);
                        // Validate the connection if the user wants to
                        boolean validate = autoconnectPage.getValidate();
                        if (validate && !isPreviouslyKnown) {
                            ISVNRepositoryLocation location = SVNProviderPlugin.getPlugin().getRepository(projectStatus.getUrlString());
                            // Do the validation
                            try {
                                location.validateConnection(new SubProgressMonitor(monitor, 50));
                            } catch (final TeamException e) {
                                // Exception validating. We can continue if the user wishes.
                                final boolean[] keep = new boolean[] { false };
                                getShell().getDisplay().syncExec(new Runnable() {

                                    public void run() {
                                        keep[0] = MessageDialog.openQuestion(getContainer().getShell(), Policy.bind(// $NON-NLS-1$
                                        "SharingWizard.validationFailedTitle"), Policy.bind("SharingWizard.validationFailedText", new Object[] { e.getStatus().getMessage() }));
                                    // $NON-NLS-1$
                                    }
                                });
                                if (!keep[0]) {
                                    // Remove the root
                                    try {
                                        if (!isPreviouslyKnown) {
                                            SVNProviderPlugin.getPlugin().getRepositories().disposeRepository(location);
                                        }
                                    } catch (TeamException e1) {
                                        SVNUIPlugin.openError(getContainer().getShell(), Policy.bind("exception"), null, e1, // $NON-NLS-1$
                                        SVNUIPlugin.PERFORM_SYNC_EXEC);
                                    }
                                    result[0] = false;
                                    return;
                                }
                            // They want to keep the connection anyway. Fall through.
                            }
                        }
                        // Set the sharing
                        SVNWorkspaceRoot.setSharing(project, new SubProgressMonitor(monitor, 50));
                    } else {
                        // No svn directory : Share the project
                        doSync[0] = true;
                        // Check if the directory exists on the server
                        ISVNRepositoryLocation location = null;
                        boolean isKnown = false;
                        boolean createDirectory = true;
                        try {
                            location = getLocation();
                            isKnown = SVNProviderPlugin.getPlugin().getRepositories().isKnownRepository(location.getLocation(), false);
                            // Purge any svn folders that may exists in subfolders
                            SVNWorkspaceRoot.getSVNFolderFor(project).unmanage(null);
                            // check if the remote directory already exist
                            String remoteDirectoryName = getRemoteDirectoryName();
                            ISVNRemoteFolder folder = location.getRemoteFolder(remoteDirectoryName);
                            if (folder.exists(new SubProgressMonitor(monitor, 50))) {
                                if (autoconnectPage == null) {
                                    getShell().getDisplay().syncExec(new Runnable() {

                                        public void run() {
                                            if (!MessageDialog.openQuestion(getShell(), Policy.bind("SharingWizard.couldNotImport"), Policy.bind("SharingWizard.couldNotImportLong"))) {
                                                // $NON-NLS-1$ //$NON-NLS-2$
                                                shareCanceled = true;
                                                return;
                                            }
                                        }
                                    });
                                    if (shareCanceled)
                                        return;
                                }
                                createDirectory = false;
                            }
                        } catch (TeamException e) {
                            SVNUIPlugin.openError(getShell(), null, null, e, SVNUIPlugin.PERFORM_SYNC_EXEC);
                            result[0] = false;
                            doSync[0] = false;
                            return;
                        }
                        // Add the location to the provider if it is new
                        if (!isKnown) {
                            SVNProviderPlugin.getPlugin().getRepositories().addOrUpdateRepository(location);
                        }
                        // Create the remote module for the project
                        SVNWorkspaceRoot.shareProject(location, project, getRemoteDirectoryName(), finishPage.getComment(), createDirectory, new SubProgressMonitor(monitor, 50));
                        try {
                            project.refreshLocal(IProject.DEPTH_INFINITE, new SubProgressMonitor(monitor, 50));
                        } catch (CoreException ce) {
                            throw new TeamException(ce.getStatus());
                        }
                        // Map any nested projects to repository provider.
                        Collection<File> files = new ArrayList<File>();
                        collectProjectFilesFromDirectory(files, project.getLocation().toFile(), null, monitor);
                        for (File file : files) {
                            IResource resource = File2Resource.getResource(file.getParentFile());
                            IProject childProject = resource.getProject();
                            if (!childProject.equals(project)) {
                                RepositoryProvider.map(childProject, SVNProviderPlugin.getTypeId());
                            }
                        }
                    }
                } catch (TeamException e) {
                    throw new InvocationTargetException(e);
                } finally {
                    monitor.done();
                }
            }
        });
        if (shareCanceled)
            return false;
        if (doSync[0]) {
            final List syncList = new ArrayList();
            syncList.add(project);
            try {
                ISynchronizeParticipantReference[] references = TeamUI.getSynchronizeManager().getSynchronizeParticipants();
                if (references != null) {
                    for (int i = 0; i < references.length; i++) {
                        ISynchronizeParticipantReference reference = references[i];
                        ISynchronizeParticipant participant = reference.getParticipant();
                        if (participant instanceof SVNSynchronizeParticipant) {
                            SVNSynchronizeParticipant svnParticipant = (SVNSynchronizeParticipant) participant;
                            IResource[] resources = svnParticipant.getResources();
                            if (resources != null) {
                                for (int j = 0; j < resources.length; j++) {
                                    IResource resource = resources[j];
                                    if (!resource.equals(project)) {
                                        syncList.add(resource);
                                    }
                                }
                            }
                            break;
                        }
                    }
                }
            } catch (Exception e) {
            }
            SynchronizeAction synchronizeAction = new SynchronizeAction() {

                protected IResource[] getSelectedResources() {
                    IResource[] selection = new IResource[syncList.size()];
                    syncList.toArray(selection);
                    return selection;
                }
            };
            synchronizeAction.run(null);
        }
    } catch (InterruptedException e) {
        return true;
    } catch (InvocationTargetException e) {
        SVNUIPlugin.openError(getContainer().getShell(), null, null, e);
        return false;
    }
    return result[0];
}

Example 3 with ISVNRemoteFolder

use of org.tigris.subversion.subclipse.core.ISVNRemoteFolder in project subclipse by subclipse.

the class GetLogsCommand method run.

/**
 * execute the command
 *
 * @param aMonitor
 * @throws SVNException
 */
public void run(IProgressMonitor aMonitor) throws SVNException {
    ISVNRepositoryLocation repository = null;
    ISVNClientAdapter svnClient = null;
    logEntries = null;
    IProgressMonitor monitor = Policy.monitorFor(aMonitor);
    // $NON-NLS-1$
    monitor.beginTask(Policy.bind("RemoteFile.getLogEntries"), 100);
    ISVNLogMessage[] logMessages;
    try {
        if (callback == null) {
            logMessages = remoteResource.getLogMessages(pegRevision, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions);
        } else {
            repository = remoteResource.getRepository();
            svnClient = repository.getSVNClient();
            if (remoteResource instanceof BaseResource) {
                boolean logMessagesRetrieved = false;
                ISVNLocalResource svnResource = SVNWorkspaceRoot.getSVNResourceFor(remoteResource.getResource());
                if (svnResource != null) {
                    LocalResourceStatus status = svnResource.getStatus();
                    if (status != null && status.isCopied()) {
                        ISVNInfo info = svnClient.getInfoFromWorkingCopy(svnResource.getFile());
                        SVNUrl copiedFromUrl = info.getCopyUrl();
                        if (copiedFromUrl != null) {
                            svnClient.getLogMessages(copiedFromUrl, SVNRevision.HEAD, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions, ISVNClientAdapter.DEFAULT_LOG_PROPERTIES, callback);
                            logMessagesRetrieved = true;
                            GetRemoteResourceCommand getRemoteResourceCommand = new GetRemoteResourceCommand(remoteResource.getRepository(), copiedFromUrl, SVNRevision.HEAD);
                            getRemoteResourceCommand.run(null);
                            remoteResource = getRemoteResourceCommand.getRemoteResource();
                        }
                    }
                }
                if (!logMessagesRetrieved)
                    svnClient.getLogMessages(((BaseResource) remoteResource).getFile(), pegRevision, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions, ISVNClientAdapter.DEFAULT_LOG_PROPERTIES, callback);
            } else {
                svnClient.getLogMessages(remoteResource.getUrl(), pegRevision, revisionStart, revisionEnd, stopOnCopy, !SVNProviderPlugin.getPlugin().getSVNClientManager().isFetchChangePathOnDemand(), limit, includeMergedRevisions, ISVNClientAdapter.DEFAULT_LOG_PROPERTIES, callback);
            }
            logMessages = callback.getLogMessages();
        }
        if (remoteResource.isFolder()) {
            logEntries = LogEntry.createLogEntriesFrom((ISVNRemoteFolder) remoteResource, logMessages, getTags(logMessages));
        } else {
            logEntries = LogEntry.createLogEntriesFrom((ISVNRemoteFile) remoteResource, logMessages, getTags(logMessages), getUrls(logMessages));
        }
    } catch (Exception e) {
        throw SVNException.wrapException(e);
    } finally {
        if (repository != null) {
            repository.returnSVNClient(svnClient);
        }
        monitor.done();
    }
}

Example 4 with ISVNRemoteFolder

use of org.tigris.subversion.subclipse.core.ISVNRemoteFolder in project subclipse by subclipse.

the class RepositoriesView method refreshViewerNode.

protected void refreshViewerNode() {
    IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
    Iterator iter = selection.iterator();
    while (iter.hasNext()) {
        Object object = iter.next();
        if (object instanceof ISVNRepositoryLocation) {
            refreshAction.run();
            break;
        }
        if (object instanceof ISVNRemoteFolder)
            ((ISVNRemoteFolder) object).refresh();
        treeViewer.refresh(object);
    }
}

Example 5 with ISVNRemoteFolder

use of org.tigris.subversion.subclipse.core.ISVNRemoteFolder in project subclipse by subclipse.

the class RepositoryManager method startup.

/**
 * called when plugin is started
 */
public void startup() {
    commentsManager.loadCommentHistory();
    commentsManager.loadCommentTemplates();
    keyFilesManager.loadKeyFileHistory();
    // we listen to changes to repository so that we can advise concerned views
    SVNProviderPlugin.getPlugin().getRepositoryResourcesManager().addRepositoryListener(new ISVNListener() {

        public void repositoryAdded(ISVNRepositoryLocation root) {
            rootAdded(root);
        }

        public void repositoryRemoved(ISVNRepositoryLocation root) {
            rootRemoved(root);
        }

        public void remoteResourceDeleted(ISVNRemoteResource resource) {
            resourceDeleted(resource);
        }

        public void remoteResourceCreated(ISVNRemoteFolder parent, String resourceName) {
            resourceCreated(parent, resourceName);
        }

        public void remoteResourceCopied(ISVNRemoteResource source, ISVNRemoteFolder destination) {
            resourceCopied(source, destination);
        }

        public void remoteResourceMoved(ISVNRemoteResource resource, ISVNRemoteFolder destinationFolder, String destinationResourceName) {
            resourceMoved(resource, destinationFolder, destinationResourceName);
        }

        public void repositoryModified(ISVNRepositoryLocation root) {
            rootModified(root);
        }
    });
}