Java RemoteInterpreterResult类代码示例

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
private RemoteInterpreterResult convert(InterpreterResult result,
    Map<String, Object> config, GUI gui, GUI noteGui) {

  List<RemoteInterpreterResultMessage> msg = new LinkedList<>();
  for (InterpreterResultMessage m : result.message()) {
    msg.add(new RemoteInterpreterResultMessage(
        m.getType().name(),
        m.getData()));
  }

  return new RemoteInterpreterResult(
      result.code().name(),
      msg,
      gson.toJson(config),
      gui.toJson(),
      noteGui.toJson());
}
 

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
private RemoteInterpreterResult convert(InterpreterResult result,
    Map<String, Object> config, GUI gui) {
  return new RemoteInterpreterResult(
      result.code().name(),
      result.type().name(),
      result.message(),
      gson.toJson(config),
      gson.toJson(gui));
}
 

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
private InterpreterResult convert(RemoteInterpreterResult result) {
  InterpreterResult r = new InterpreterResult(
      InterpreterResult.Code.valueOf(result.getCode()));

  for (RemoteInterpreterResultMessage m : result.getMsg()) {
    r.add(InterpreterResult.Type.valueOf(m.getType()), m.getData());
  }

  return r;
}
 

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
@Override
public InterpreterResult interpret(String st, InterpreterContext context) {
  logger.debug("st: {}", st);
  FormType form = getFormType();
  RemoteInterpreterProcess interpreterProcess = getInterpreterProcess();
  Client client = null;
  try {
    client = interpreterProcess.getClient();
  } catch (Exception e1) {
    throw new InterpreterException(e1);
  }

  InterpreterContextRunnerPool interpreterContextRunnerPool = interpreterProcess
      .getInterpreterContextRunnerPool();

  List<InterpreterContextRunner> runners = context.getRunners();
  if (runners != null && runners.size() != 0) {
    // assume all runners in this InterpreterContext have the same note id
    String noteId = runners.get(0).getNoteId();

    interpreterContextRunnerPool.clear(noteId);
    interpreterContextRunnerPool.addAll(noteId, runners);
  }

  boolean broken = false;
  try {
    GUI settings = context.getGui();
    RemoteInterpreterResult remoteResult = client.interpret(className, st, convert(context));

    Map<String, Object> remoteConfig = (Map<String, Object>) gson.fromJson(
        remoteResult.getConfig(), new TypeToken<Map<String, Object>>() {
        }.getType());
    context.getConfig().clear();
    context.getConfig().putAll(remoteConfig);

    if (form == FormType.NATIVE) {
      GUI remoteGui = gson.fromJson(remoteResult.getGui(), GUI.class);
      context.getGui().clear();
      context.getGui().setParams(remoteGui.getParams());
      context.getGui().setForms(remoteGui.getForms());
    }

    InterpreterResult result = convert(remoteResult);
    return result;
  } catch (TException e) {
    broken = true;
    throw new InterpreterException(e);
  } finally {
    interpreterProcess.releaseClient(client, broken);
  }
}
 

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
private InterpreterResult convert(RemoteInterpreterResult result) {
  return new InterpreterResult(
      InterpreterResult.Code.valueOf(result.getCode()),
      Type.valueOf(result.getType()),
      result.getMsg());
}
 

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
@Override
public InterpreterResult interpret(final String st, final InterpreterContext context)
    throws InterpreterException {
  if (LOGGER.isDebugEnabled()) {
    LOGGER.debug("st:\n{}", st);
  }

  final FormType form = getFormType();
  RemoteInterpreterProcess interpreterProcess = null;
  try {
    interpreterProcess = getOrCreateInterpreterProcess();
  } catch (IOException e) {
    throw new InterpreterException(e);
  }
  InterpreterContextRunnerPool interpreterContextRunnerPool = interpreterProcess
      .getInterpreterContextRunnerPool();
  List<InterpreterContextRunner> runners = context.getRunners();
  if (runners != null && runners.size() != 0) {
    // assume all runners in this InterpreterContext have the same note id
    String noteId = runners.get(0).getNoteId();

    interpreterContextRunnerPool.clear(noteId);
    interpreterContextRunnerPool.addAll(noteId, runners);
  }
  this.lifecycleManager.onInterpreterUse(this.getInterpreterGroup(), sessionId);
  return interpreterProcess.callRemoteFunction(
      new RemoteInterpreterProcess.RemoteFunction<InterpreterResult>() {
        @Override
        public InterpreterResult call(Client client) throws Exception {

          RemoteInterpreterResult remoteResult = client.interpret(
              sessionId, className, st, convert(context));
          Map<String, Object> remoteConfig = (Map<String, Object>) gson.fromJson(
              remoteResult.getConfig(), new TypeToken<Map<String, Object>>() {
              }.getType());
          context.getConfig().clear();
          context.getConfig().putAll(remoteConfig);
          GUI currentGUI = context.getGui();
          GUI currentNoteGUI = context.getNoteGui();
          if (form == FormType.NATIVE) {
            GUI remoteGui = GUI.fromJson(remoteResult.getGui());
            GUI remoteNoteGui = GUI.fromJson(remoteResult.getNoteGui());
            currentGUI.clear();
            currentGUI.setParams(remoteGui.getParams());
            currentGUI.setForms(remoteGui.getForms());
            currentNoteGUI.setParams(remoteNoteGui.getParams());
            currentNoteGUI.setForms(remoteNoteGui.getForms());
          } else if (form == FormType.SIMPLE) {
            final Map<String, Input> currentForms = currentGUI.getForms();
            final Map<String, Object> currentParams = currentGUI.getParams();
            final GUI remoteGUI = GUI.fromJson(remoteResult.getGui());
            final Map<String, Input> remoteForms = remoteGUI.getForms();
            final Map<String, Object> remoteParams = remoteGUI.getParams();
            currentForms.putAll(remoteForms);
            currentParams.putAll(remoteParams);
          }

          InterpreterResult result = convert(remoteResult);
          return result;
        }
      }
  );

}
 

import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; //导入依赖的package包/类
@Override
public RemoteInterpreterResult interpret(String noteId, String className, String st,
    RemoteInterpreterContext interpreterContext) throws TException {
  if (logger.isDebugEnabled()) {
    logger.debug("st:\n{}", st);
  }
  Interpreter intp = getInterpreter(noteId, className);
  InterpreterContext context = convert(interpreterContext);
  context.setClassName(intp.getClassName());

  Scheduler scheduler = intp.getScheduler();
  InterpretJobListener jobListener = new InterpretJobListener();
  InterpretJob job = new InterpretJob(
      interpreterContext.getParagraphId(),
      "remoteInterpretJob_" + System.currentTimeMillis(),
      jobListener,
      JobProgressPoller.DEFAULT_INTERVAL_MSEC,
      intp,
      st,
      context);
  scheduler.submit(job);

  while (!job.isTerminated()) {
    synchronized (jobListener) {
      try {
        jobListener.wait(1000);
      } catch (InterruptedException e) {
        logger.info("Exception in RemoteInterpreterServer while interpret, jobListener.wait", e);
      }
    }
  }

  progressMap.remove(interpreterContext.getParagraphId());

  InterpreterResult result;
  if (job.getStatus() == Status.ERROR) {
    result = new InterpreterResult(Code.ERROR, Job.getStack(job.getException()));
  } else {
    result = (InterpreterResult) job.getReturn();

    // in case of job abort in PENDING status, result can be null
    if (result == null) {
      result = new InterpreterResult(Code.KEEP_PREVIOUS_RESULT);
    }
  }
  return convert(result,
      context.getConfig(),
      context.getGui(),
      context.getNoteGui());
}