use of org.rstudio.studio.client.server.ServerRequestCallback in project rstudio by rstudio.
the class LintManager method performCppLintServerRequest.
private void performCppLintServerRequest(final LintContext context) {
cppCompletionContext_.cppCompletionOperation(new CppCompletionOperation() {
@Override
public void execute(String docPath, int line, int column) {
server_.getCppDiagnostics(target_.getPath(), new ServerRequestCallback<JsArray<CppDiagnostic>>() {
@Override
public void onResponseReceived(JsArray<CppDiagnostic> diag) {
if (context.token.isInvalid())
return;
final JsArray<LintItem> cppLint = CppCompletionRequest.asLintArray(diag);
server_.lintRSourceDocument(target_.getId(), target_.getPath(), context.showMarkers, context.explicit, new ServerRequestCallback<JsArray<LintItem>>() {
@Override
public void onResponseReceived(JsArray<LintItem> rLint) {
if (context.token.isInvalid())
return;
JsArray<LintItem> allLint = JsArray.createArray().cast();
for (int i = 0; i < cppLint.length(); i++) allLint.push(cppLint.get(i));
for (int i = 0; i < rLint.length(); i++) allLint.push(rLint.get(i));
showLint(context, allLint);
}
@Override
public void onError(ServerError error) {
Debug.logError(error);
}
});
}
@Override
public void onError(ServerError error) {
Debug.logError(error);
}
});
}
});
}
use of org.rstudio.studio.client.server.ServerRequestCallback in project rstudio by rstudio.
the class Packages method doUpdatePackages.
private void doUpdatePackages(final PackageInstallContext installContext) {
new CheckForUpdatesDialog(globalDisplay_, new ServerDataSource<JsArray<PackageUpdate>>() {
public void requestData(ServerRequestCallback<JsArray<PackageUpdate>> requestCallback) {
server_.checkForPackageUpdates(requestCallback);
}
}, new OperationWithInput<ArrayList<PackageUpdate>>() {
@Override
public void execute(ArrayList<PackageUpdate> updates) {
InstallCommand cmd = buildUpdatePackagesCommand(updates, installContext);
executeWithLoadedPackageCheck(cmd);
}
}, new Operation() {
@Override
public void execute() {
// cancel emits an empty console input line to clear
// the busy indicator
events_.fireEvent(new SendToConsoleEvent("", true));
}
}).showModal();
}
use of org.rstudio.studio.client.server.ServerRequestCallback in project rstudio by rstudio.
the class ApplicationClientInit method execute.
public void execute(final ServerRequestCallback<SessionInfo> requestCallback, final boolean retryOnTransmissionError) {
// reset internal state
timedOut_ = false;
timeoutTimer_ = null;
// send the request
final ServerRequestCallback<SessionInfo> rpcRequestCallback = new ServerRequestCallback<SessionInfo>() {
@Override
public void onResponseReceived(SessionInfo sessionInfo) {
if (!timedOut_) {
cancelTimeoutTimer();
requestCallback.onResponseReceived(sessionInfo);
}
}
@Override
public void onError(ServerError error) {
if (!timedOut_) {
cancelTimeoutTimer();
if ((error.getCode() == ServerError.TRANSMISSION) && retryOnTransmissionError) {
// transmission error can occur due to a race
// condition when switching projects or versions, for
// this case wait 1000ms then retry
new Timer() {
@Override
public void run() {
// retry (specify flag to ensure we only retry once)
execute(requestCallback, false);
}
}.schedule(1000);
} else {
requestCallback.onError(error);
}
}
}
};
server_.clientInit(rpcRequestCallback);
// wait for 60 seconds then ask the user if they want to issue an
// interrupt to the server
int timeoutMs = 60000;
timeoutTimer_ = new Timer() {
public void run() {
// set timed out flag
timedOut_ = true;
// cancel our request
rpcRequestCallback.cancel();
// ask the user if they want to attempt to interrupt the server
globalDisplay_.showYesNoMessage(GlobalDisplay.MSG_QUESTION, // caption
"Initializing RStudio", // message
"The RStudio server is taking a long time to respond. It is " + "possible that your R session has become unresponsive. " + "Do you want to terminate the currently running R session?", // don't include cancel
false, // Yes operation
new Operation() {
public void execute() {
// call interrupt then call this method back on success
server_.abort(null, new ServerRequestCallback<Void>() {
@Override
public void onResponseReceived(Void response) {
// reload the application
reloadWithDelay(1000);
}
@Override
public void onError(ServerError error) {
// if we get an error during interrupt then just
// forward the error on to the original handler
requestCallback.onError(error);
}
});
}
}, // No operation
new Operation() {
public void execute() {
// keep trying (reload to clear out any crufty app
// or networking state)
reloadWithDelay(1);
}
}, // Cancel operation (none)
null, "Terminate R", "Keep Waiting", // default to No
false);
}
};
// activate the timer
timeoutTimer_.schedule(timeoutMs);
}
use of org.rstudio.studio.client.server.ServerRequestCallback in project rstudio by rstudio.
the class ChunkSatelliteWindow method onInitialize.
@Override
protected void onInitialize(LayoutPanel mainPanel, JavaScriptObject params) {
chunkWindowParams_ = params.cast();
String title = "RStudio: Notebook Output";
Window.setTitle(title);
ChunkOutputHost chunkOutputHost = new ChunkOutputHost() {
@Override
public void onOutputRemoved(final ChunkOutputWidget widget) {
}
@Override
public void onOutputHeightChanged(ChunkOutputWidget widget, int height, boolean ensureVisible) {
}
};
chunkOutputWidget_ = new ChunkOutputWidget(chunkWindowParams_.getDocId(), chunkWindowParams_.getChunkId(), RmdChunkOptions.create(), ChunkOutputWidget.EXPANDED, // can close
false, chunkOutputHost, ChunkOutputSize.Full);
Element ele = chunkOutputWidget_.getElement();
ele.addClassName(ThemeStyles.INSTANCE.selectableText());
// Append the chunkOutputWidget as an HTML element, not as a widget.
// Why? Chunks are widgets that are attached to the ACE editor as HTML
// elements, not as widgets. The reason being that GWT does not support
// triggering events for widgets that are not attached to their hierarchy.
// Therefore, if we attach this element as a widget, GWT will remove
// events in some cases which will cause functionality to be lost.
mainPanel.getElement().appendChild(chunkOutputWidget_.getElement());
chunkOutputWidget_.getElement().getStyle().setHeight(100, Unit.PCT);
mainPanel.addStyleName("ace_editor");
pEventBus_.get().addHandler(ChunkSatelliteCodeExecutingEvent.TYPE, this);
pEventBus_.get().addHandler(ChunkSatelliteCacheEditorStyleEvent.TYPE, this);
pEventBus_.get().addHandler(ChunkPlotRefreshedEvent.TYPE, this);
pEventBus_.get().addHandler(ChunkPlotRefreshFinishedEvent.TYPE, this);
pEventBus_.get().addHandler(ChunkChangeEvent.TYPE, this);
pEventBus_.get().addHandler(RmdChunkOutputFinishedEvent.TYPE, this);
pEventBus_.get().addHandler(RmdChunkOutputEvent.TYPE, this);
Window.addWindowClosingHandler(new ClosingHandler() {
@Override
public void onWindowClosing(ClosingEvent arg0) {
server_.cleanReplayNotebookChunkPlots(chunkWindowParams_.getDocId(), chunkWindowParams_.getChunkId(), new ServerRequestCallback<Void>() {
@Override
public void onError(ServerError error) {
}
});
}
});
pEventBus_.get().fireEventToMainWindow(new ChunkSatelliteWindowOpenedEvent(chunkWindowParams_.getDocId(), chunkWindowParams_.getChunkId()));
}
use of org.rstudio.studio.client.server.ServerRequestCallback 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();
}
Aggregations