Examples with ServerError org.rstudio.studio.client.server.ServerError used on opensource projects

Example 21 with ServerError

use of org.rstudio.studio.client.server.ServerError in project rstudio by rstudio.

the class HistoryAsyncDataProvider method onRangeChanged.

@Override
public void onRangeChanged(final HasData<CommitInfo> display) {
    final Range rng = display.getVisibleRange();
    final int start = rng.getStart();
    final int length = rng.getLength();
    if (length == 0)
        return;
    getHistory(rev_, fileFilter_.getValue(), start, length, searchText_.getValue(), new SimpleRequestCallback<RpcObjectList<CommitInfo>>("Error Fetching History") {

        @Override
        public void onResponseReceived(RpcObjectList<CommitInfo> response) {
            super.onResponseReceived(response);
            if (response.length() < length)
                updateRowCount(start + response.length(), true);
            updateRowData(start, response.toArrayList());
        }

        @Override
        public void onError(ServerError error) {
            if (display instanceof AbstractHasData) {
                display.setVisibleRangeAndClearData(new Range(start, 0), true);
            }
            if (strategy_.getShowHistoryErrors())
                super.onError(error);
            else
                Debug.logError(error);
        }
    });
}

Example 22 with ServerError

use of org.rstudio.studio.client.server.ServerError in project rstudio by rstudio.

the class HistoryPresenter method showCommitDetail.

private void showCommitDetail(boolean noSizeWarning) {
    final CommitInfo commitInfo = view_.getCommitList().getSelectedCommit();
    if (!noSizeWarning && commitInfo != null && commitInfo.getId().equals(commitShowing_)) {
        return;
    }
    commitShowing_ = null;
    view_.hideSizeWarning();
    view_.getCommitDetail().setSelectedCommit(commitInfo);
    view_.getCommitDetail().showDetailProgress();
    invalidation_.invalidate();
    if (commitInfo == null)
        return;
    final Token token = invalidation_.getInvalidationToken();
    strategy_.showCommit(commitInfo.getId(), noSizeWarning, new SimpleRequestCallback<String>() {

        @Override
        public void onResponseReceived(String response) {
            super.onResponseReceived(response);
            if (token.isInvalid())
                return;
            DiffParser parser = strategy_.createParserForCommit(response);
            view_.getCommitDetail().setDetails(parser, !strategy_.isShowFileSupported());
            commitShowing_ = commitInfo.getId();
        }

        @Override
        public void onError(ServerError error) {
            commitShowing_ = null;
            JSONNumber size = error.getClientInfo().isNumber();
            if (size != null)
                view_.showSizeWarning((long) size.doubleValue());
            else if (strategy_.getShowHistoryErrors())
                super.onError(error);
            else
                Debug.logError(error);
        }
    });
}

Example 23 with ServerError

use of org.rstudio.studio.client.server.ServerError in project rstudio by rstudio.

the class SshKeyWidget method viewPublicKey.

private void viewPublicKey() {
    progressIndicator_.onProgress("Reading public key...");
    // compute path to public key
    FileSystemItem privKey = FileSystemItem.createFile(txtSshKeyPath_.getText());
    FileSystemItem keyDir = privKey.getParentPath();
    final String keyPath = keyDir.completePath(privKey.getStem() + ".pub");
    server_.gitSshPublicKey(keyPath, new ServerRequestCallback<String>() {

        @Override
        public void onResponseReceived(String publicKeyContents) {
            progressIndicator_.onCompleted();
            new ShowPublicKeyDialog("Public Key", publicKeyContents).showModal();
        }

        @Override
        public void onError(ServerError error) {
            String msg = "Error attempting to read key '" + keyPath + "' (" + error.getUserMessage() + ")";
            progressIndicator_.onError(msg);
        }
    });
}

Example 24 with ServerError

use of org.rstudio.studio.client.server.ServerError in project rstudio by rstudio.

the class Projects method createNewProject.

private void createNewProject(final NewProjectResult newProject, final boolean saveChanges) {
    // This gets a little crazy. We have several pieces of asynchronous logic
    // that each may or may not need to be executed, depending on the type
    // of project being created and on whether the previous pieces of logic
    // succeed. Plus we have this ProgressIndicator that needs to be fed
    // properly.
    final ProgressIndicator indicator = globalDisplay_.getProgressIndicator("Error Creating Project");
    // Here's the command queue that will hold the various operations.
    final SerializedCommandQueue createProjectCmds = new SerializedCommandQueue();
    // WARNING: When calling addCommand, BE SURE TO PASS FALSE as the second
    // argument, to delay running of the commands until they are all
    // scheduled.
    // First, attempt to update the default project location pref
    createProjectCmds.addCommand(new SerializedCommand() {

        @Override
        public void onExecute(final Command continuation) {
            UIPrefs uiPrefs = pUIPrefs_.get();
            // update default project location pref if necessary
            if ((newProject.getNewDefaultProjectLocation() != null) || (newProject.getCreateGitRepo() != uiPrefs.newProjGitInit().getValue())) {
                indicator.onProgress("Saving defaults...");
                if (newProject.getNewDefaultProjectLocation() != null) {
                    uiPrefs.defaultProjectLocation().setGlobalValue(newProject.getNewDefaultProjectLocation());
                }
                if (newProject.getCreateGitRepo() != uiPrefs.newProjGitInit().getValue()) {
                    uiPrefs.newProjGitInit().setGlobalValue(newProject.getCreateGitRepo());
                }
                if (newProject.getUsePackrat() != uiPrefs.newProjUsePackrat().getValue()) {
                    uiPrefs.newProjUsePackrat().setGlobalValue(newProject.getUsePackrat());
                }
                // call the server -- in all cases continue on with
                // creating the project (swallow errors updating the pref)
                projServer_.setUiPrefs(session_.getSessionInfo().getUiPrefs(), new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onResponseReceived(Void response) {
                        continuation.execute();
                    }

                    @Override
                    public void onError(ServerError error) {
                        super.onError(error);
                        continuation.execute();
                    }
                });
            } else {
                continuation.execute();
            }
        }
    }, false);
    // Next, if necessary, clone a repo
    if (newProject.getVcsCloneOptions() != null) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                VcsCloneOptions cloneOptions = newProject.getVcsCloneOptions();
                if (cloneOptions.getVcsName().equals((VCSConstants.GIT_ID)))
                    indicator.onProgress("Cloning Git repository...");
                else
                    indicator.onProgress("Checking out SVN repository...");
                gitServer_.vcsClone(cloneOptions, new ServerRequestCallback<ConsoleProcess>() {

                    @Override
                    public void onResponseReceived(ConsoleProcess proc) {
                        final ConsoleProgressDialog consoleProgressDialog = new ConsoleProgressDialog(proc, gitServer_);
                        consoleProgressDialog.showModal();
                        proc.addProcessExitHandler(new ProcessExitEvent.Handler() {

                            @Override
                            public void onProcessExit(ProcessExitEvent event) {
                                if (event.getExitCode() == 0) {
                                    consoleProgressDialog.hide();
                                    continuation.execute();
                                } else {
                                    indicator.onCompleted();
                                }
                            }
                        });
                    }

                    @Override
                    public void onError(ServerError error) {
                        Debug.logError(error);
                        indicator.onError(error.getUserMessage());
                    }
                });
            }
        }, false);
    }
    // Next, create the project itself -- depending on the type, this
    // could involve creating an R package, or Shiny application, and so on.
    createProjectCmds.addCommand(new SerializedCommand() {

        @Override
        public void onExecute(final Command continuation) {
            // Validate the package name if we're creating a package
            if (newProject.getNewPackageOptions() != null) {
                final String packageName = newProject.getNewPackageOptions().getPackageName();
                if (!PACKAGE_NAME_PATTERN.test(packageName)) {
                    indicator.onError("Invalid package name '" + packageName + "': " + "package names must start with a letter, and contain " + "only letters and numbers.");
                    return;
                }
            }
            indicator.onProgress("Creating project...");
            if (newProject.getNewPackageOptions() == null) {
                projServer_.createProject(newProject.getProjectFile(), newProject.getNewPackageOptions(), newProject.getNewShinyAppOptions(), newProject.getProjectTemplateOptions(), new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onSuccess() {
                        continuation.execute();
                    }
                });
            } else {
                String projectFile = newProject.getProjectFile();
                String packageDirectory = projectFile.substring(0, projectFile.lastIndexOf('/'));
                projServer_.packageSkeleton(newProject.getNewPackageOptions().getPackageName(), packageDirectory, newProject.getNewPackageOptions().getCodeFiles(), newProject.getNewPackageOptions().getUsingRcpp(), new ServerRequestCallback<RResult<Void>>() {

                    @Override
                    public void onResponseReceived(RResult<Void> response) {
                        if (response.failed())
                            indicator.onError(response.errorMessage());
                        else
                            continuation.execute();
                    }

                    @Override
                    public void onError(ServerError error) {
                        Debug.logError(error);
                        indicator.onError(error.getUserMessage());
                    }
                });
            }
        }
    }, false);
    // Next, initialize a git repo if requested
    if (newProject.getCreateGitRepo()) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                indicator.onProgress("Initializing git repository...");
                String projDir = FileSystemItem.createFile(newProject.getProjectFile()).getParentPathString();
                gitServer_.gitInitRepo(projDir, new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onSuccess() {
                        continuation.execute();
                    }

                    @Override
                    public void onFailure() {
                        continuation.execute();
                    }
                });
            }
        }, false);
    }
    // Generate a new packrat project
    if (newProject.getUsePackrat()) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                indicator.onProgress("Initializing packrat project...");
                String projDir = FileSystemItem.createFile(newProject.getProjectFile()).getParentPathString();
                packratServer_.packratBootstrap(projDir, false, new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onSuccess() {
                        continuation.execute();
                    }
                });
            }
        }, false);
    }
    if (newProject.getOpenInNewWindow()) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                FileSystemItem project = FileSystemItem.createFile(newProject.getProjectFile());
                if (Desktop.isDesktop()) {
                    Desktop.getFrame().openProjectInNewWindow(project.getPath());
                    continuation.execute();
                } else {
                    indicator.onProgress("Preparing to open project...");
                    serverOpenProjectInNewWindow(project, newProject.getRVersion(), continuation);
                }
            }
        }, false);
    }
    // If we get here, dismiss the progress indicator
    createProjectCmds.addCommand(new SerializedCommand() {

        @Override
        public void onExecute(Command continuation) {
            indicator.onCompleted();
            if (!newProject.getOpenInNewWindow()) {
                applicationQuit_.performQuit(saveChanges, newProject.getProjectFile(), newProject.getRVersion());
            }
            continuation.execute();
        }
    }, false);
    // Now set it all in motion!
    createProjectCmds.run();
}

Example 25 with ServerError

use of org.rstudio.studio.client.server.ServerError in project rstudio by rstudio.

the class Projects method onShowDiagnosticsProject.

@Handler
public void onShowDiagnosticsProject() {
    final ProgressIndicator indicator = globalDisplay_.getProgressIndicator("Lint");
    indicator.onProgress("Analyzing project sources...");
    projServer_.analyzeProject(new ServerRequestCallback<Void>() {

        @Override
        public void onResponseReceived(Void response) {
            indicator.onCompleted();
        }

        @Override
        public void onError(ServerError error) {
            Debug.logError(error);
            indicator.onCompleted();
        }
    });
}