http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/ClientFactory.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/ClientFactory.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/ClientFactory.java new file mode 100644 index 0000000..6126f75 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/ClientFactory.java @@ -0,0 +1,79 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.zeppelin.interpreter.remote; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.commons.pool2.BasePooledObjectFactory; +import org.apache.commons.pool2.PooledObject; +import org.apache.commons.pool2.impl.DefaultPooledObject; +import org.apache.thrift.protocol.TBinaryProtocol; +import org.apache.thrift.protocol.TProtocol; +import org.apache.thrift.transport.TSocket; +import org.apache.thrift.transport.TTransportException; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; + +/** + * + */ +public class ClientFactory extends BasePooledObjectFactory<Client>{ + private String host; + private int port; + Map<Client, TSocket> clientSocketMap = new HashMap<Client, TSocket>(); + + public ClientFactory(String host, int port) { + this.host = host; + this.port = port; + } + + @Override + public Client create() throws Exception { + TSocket transport = new TSocket(host, port); + try { + transport.open(); + } catch (TTransportException e) { + throw new InterpreterException(e); + } + + TProtocol protocol = new TBinaryProtocol(transport); + Client client = new RemoteInterpreterService.Client(protocol); + + synchronized (clientSocketMap) { + clientSocketMap.put(client, transport); + } + return client; + } + + @Override + public PooledObject<Client> wrap(Client client) { + return new DefaultPooledObject<Client>(client); + } + + @Override + public void destroyObject(PooledObject<Client> p) { + synchronized (clientSocketMap) { + if (clientSocketMap.containsKey(p)) { + clientSocketMap.get(p).close(); + clientSocketMap.remove(p); + } + } + } +}
http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreter.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreter.java new file mode 100644 index 0000000..e905d5f --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreter.java @@ -0,0 +1,347 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.zeppelin.interpreter.remote; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.apache.thrift.TException; +import org.apache.zeppelin.display.GUI; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterGroup; +import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.InterpreterResult.Type; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterContext; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; +import org.apache.zeppelin.scheduler.Scheduler; +import org.apache.zeppelin.scheduler.SchedulerFactory; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; + +/** + * + */ +public class RemoteInterpreter extends Interpreter { + Logger logger = LoggerFactory.getLogger(RemoteInterpreter.class); + Gson gson = new Gson(); + private String interpreterRunner; + private String interpreterPath; + private String className; + FormType formType; + boolean initialized; + private Map<String, String> env; + static Map<String, RemoteInterpreterProcess> interpreterGroupReference + = new HashMap<String, RemoteInterpreterProcess>(); + + public RemoteInterpreter(Properties property, + String className, + String interpreterRunner, + String interpreterPath) { + super(property); + + this.className = className; + initialized = false; + this.interpreterRunner = interpreterRunner; + this.interpreterPath = interpreterPath; + env = new HashMap<String, String>(); + } + + public RemoteInterpreter(Properties property, + String className, + String interpreterRunner, + String interpreterPath, + Map<String, String> env) { + super(property); + + this.className = className; + this.interpreterRunner = interpreterRunner; + this.interpreterPath = interpreterPath; + this.env = env; + } + + @Override + public String getClassName() { + return className; + } + + public RemoteInterpreterProcess getInterpreterProcess() { + synchronized (interpreterGroupReference) { + if (interpreterGroupReference.containsKey(getInterpreterGroupKey(getInterpreterGroup()))) { + RemoteInterpreterProcess interpreterProcess = interpreterGroupReference + .get(getInterpreterGroupKey(getInterpreterGroup())); + try { + return interpreterProcess; + } catch (Exception e) { + throw new InterpreterException(e); + } + } else { + throw new InterpreterException("Unexpected error"); + } + } + } + + private synchronized void init() { + if (initialized == true) { + return; + } + + RemoteInterpreterProcess interpreterProcess = null; + + synchronized (interpreterGroupReference) { + if (interpreterGroupReference.containsKey(getInterpreterGroupKey(getInterpreterGroup()))) { + interpreterProcess = interpreterGroupReference + .get(getInterpreterGroupKey(getInterpreterGroup())); + } else { + throw new InterpreterException("Unexpected error"); + } + } + + int rc = interpreterProcess.reference(); + + synchronized (interpreterProcess) { + // when first process created + if (rc == 1) { + // create all interpreter class in this interpreter group + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + try { + for (Interpreter intp : this.getInterpreterGroup()) { + logger.info("Create remote interpreter {}", intp.getClassName()); + client.createInterpreter(intp.getClassName(), (Map) property); + + } + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + } + } + initialized = true; + } + + + + @Override + public void open() { + init(); + } + + @Override + public void close() { + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + try { + client.close(className); + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + + interpreterProcess.dereference(); + } + + @Override + public InterpreterResult interpret(String st, InterpreterContext context) { + FormType form = getFormType(); + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + 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()); + } + + return convert(remoteResult); + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + } + + @Override + public void cancel(InterpreterContext context) { + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + try { + client.cancel(className, convert(context)); + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + } + + + @Override + public FormType getFormType() { + init(); + + if (formType != null) { + return formType; + } + + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + try { + formType = FormType.valueOf(client.getFormType(className)); + return formType; + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + } + + @Override + public int getProgress(InterpreterContext context) { + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + try { + return client.getProgress(className, convert(context)); + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + } + + + @Override + public List<String> completion(String buf, int cursor) { + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + Client client = null; + try { + client = interpreterProcess.getClient(); + } catch (Exception e1) { + throw new InterpreterException(e1); + } + + try { + return client.completion(className, buf, cursor); + } catch (TException e) { + throw new InterpreterException(e); + } finally { + interpreterProcess.releaseClient(client); + } + } + + @Override + public Scheduler getScheduler() { + int maxConcurrency = 10; + RemoteInterpreterProcess interpreterProcess = getInterpreterProcess(); + return SchedulerFactory.singleton().createOrGetRemoteScheduler( + "remoteinterpreter_" + interpreterProcess.hashCode(), + getInterpreterProcess(), + maxConcurrency); + } + + @Override + public void setInterpreterGroup(InterpreterGroup interpreterGroup) { + super.setInterpreterGroup(interpreterGroup); + + synchronized (interpreterGroupReference) { + if (!interpreterGroupReference + .containsKey(getInterpreterGroupKey(interpreterGroup))) { + interpreterGroupReference.put(getInterpreterGroupKey(interpreterGroup), + new RemoteInterpreterProcess(interpreterRunner, + interpreterPath, env)); + + logger.info("setInterpreterGroup = " + + getInterpreterGroupKey(interpreterGroup) + " class=" + className + + ", path=" + interpreterPath); + } + } + } + + private String getInterpreterGroupKey(InterpreterGroup interpreterGroup) { + return interpreterGroup.getId(); + } + + private RemoteInterpreterContext convert(InterpreterContext ic) { + return new RemoteInterpreterContext( + ic.getParagraphId(), + ic.getParagraphTitle(), + ic.getParagraphText(), + gson.toJson(ic.getConfig()), + gson.toJson(ic.getGui())); + } + + private InterpreterResult convert(RemoteInterpreterResult result) { + return new InterpreterResult( + InterpreterResult.Code.valueOf(result.getCode()), + Type.valueOf(result.getType()), + result.getMsg()); + } +} http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcess.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcess.java new file mode 100644 index 0000000..a128cd7 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcess.java @@ -0,0 +1,208 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.zeppelin.interpreter.remote; + +import java.io.IOException; +import java.util.Map; +import java.util.concurrent.atomic.AtomicInteger; + +import org.apache.commons.exec.CommandLine; +import org.apache.commons.exec.DefaultExecutor; +import org.apache.commons.exec.ExecuteException; +import org.apache.commons.exec.ExecuteResultHandler; +import org.apache.commons.exec.ExecuteWatchdog; +import org.apache.commons.exec.environment.EnvironmentUtils; +import org.apache.commons.pool2.impl.GenericObjectPool; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * + */ +public class RemoteInterpreterProcess implements ExecuteResultHandler { + Logger logger = LoggerFactory.getLogger(RemoteInterpreterProcess.class); + AtomicInteger referenceCount; + private DefaultExecutor executor; + private ExecuteWatchdog watchdog; + boolean running = false; + int port = -1; + private String interpreterRunner; + private String interpreterDir; + + private GenericObjectPool<Client> clientPool; + private Map<String, String> env; + + public RemoteInterpreterProcess(String intpRunner, String intpDir, Map<String, String> env) { + this.interpreterRunner = intpRunner; + this.interpreterDir = intpDir; + this.env = env; + referenceCount = new AtomicInteger(0); + } + + public int getPort() { + return port; + } + + public int reference() { + synchronized (referenceCount) { + if (executor == null) { + // start server process + try { + port = RemoteInterpreterUtils.findRandomAvailablePortOnAllLocalInterfaces(); + } catch (IOException e1) { + throw new InterpreterException(e1); + } + + + CommandLine cmdLine = CommandLine.parse(interpreterRunner); + cmdLine.addArgument("-d", false); + cmdLine.addArgument(interpreterDir, false); + cmdLine.addArgument("-p", false); + cmdLine.addArgument(Integer.toString(port), false); + + executor = new DefaultExecutor(); + + watchdog = new ExecuteWatchdog(ExecuteWatchdog.INFINITE_TIMEOUT); + executor.setWatchdog(watchdog); + + running = true; + try { + Map procEnv = EnvironmentUtils.getProcEnvironment(); + procEnv.putAll(env); + + logger.info("Run interpreter process {}", cmdLine); + executor.execute(cmdLine, procEnv, this); + } catch (IOException e) { + running = false; + throw new InterpreterException(e); + } + + + long startTime = System.currentTimeMillis(); + while (System.currentTimeMillis() - startTime < 5 * 1000) { + if (RemoteInterpreterUtils.checkIfRemoteEndpointAccessible("localhost", port)) { + break; + } else { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + } + } + } + + clientPool = new GenericObjectPool<Client>(new ClientFactory("localhost", port)); + } + return referenceCount.incrementAndGet(); + } + } + + public Client getClient() throws Exception { + return clientPool.borrowObject(); + } + + public void releaseClient(Client client) { + clientPool.returnObject(client); + } + + public int dereference() { + synchronized (referenceCount) { + int r = referenceCount.decrementAndGet(); + if (r == 0) { + logger.info("shutdown interpreter process"); + // first try shutdown + try { + Client client = getClient(); + client.shutdown(); + releaseClient(client); + } catch (Exception e) { + logger.error("Error", e); + watchdog.destroyProcess(); + } + + clientPool.clear(); + clientPool.close(); + + // wait for 3 sec and force kill + // remote process server.serve() loop is not always finishing gracefully + long startTime = System.currentTimeMillis(); + while (System.currentTimeMillis() - startTime < 3 * 1000) { + if (this.isRunning()) { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + } + } else { + break; + } + } + + if (isRunning()) { + logger.info("kill interpreter process"); + watchdog.destroyProcess(); + } + + executor = null; + watchdog = null; + running = false; + logger.info("Remote process terminated"); + } + return r; + } + } + + public int referenceCount() { + synchronized (referenceCount) { + return referenceCount.get(); + } + } + + @Override + public void onProcessComplete(int exitValue) { + logger.info("Interpreter process exited {}", exitValue); + running = false; + + } + + @Override + public void onProcessFailed(ExecuteException e) { + logger.info("Interpreter process failed {}", e); + running = false; + } + + public boolean isRunning() { + return running; + } + + public int getNumActiveClient() { + if (clientPool == null) { + return 0; + } else { + return clientPool.getNumActive(); + } + } + + public int getNumIdleClient() { + if (clientPool == null) { + return 0; + } else { + return clientPool.getNumIdle(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterServer.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterServer.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterServer.java new file mode 100644 index 0000000..ee4aa2d --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterServer.java @@ -0,0 +1,342 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.zeppelin.interpreter.remote; + + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.net.URL; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.apache.thrift.TException; +import org.apache.thrift.server.TThreadPoolServer; +import org.apache.thrift.transport.TServerSocket; +import org.apache.thrift.transport.TTransportException; +import org.apache.zeppelin.display.GUI; +import org.apache.zeppelin.interpreter.ClassloaderInterpreter; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterGroup; +import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.LazyOpenInterpreter; +import org.apache.zeppelin.interpreter.Interpreter.FormType; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterContext; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterResult; +import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService; +import org.apache.zeppelin.scheduler.Job; +import org.apache.zeppelin.scheduler.JobListener; +import org.apache.zeppelin.scheduler.JobProgressPoller; +import org.apache.zeppelin.scheduler.Scheduler; +import org.apache.zeppelin.scheduler.Job.Status; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; + + +/** + * + */ +public class RemoteInterpreterServer + extends Thread + implements RemoteInterpreterService.Iface { + Logger logger = LoggerFactory.getLogger(RemoteInterpreterServer.class); + + InterpreterGroup interpreterGroup = new InterpreterGroup(); + Gson gson = new Gson(); + + RemoteInterpreterService.Processor<RemoteInterpreterServer> processor; + RemoteInterpreterServer handler; + private int port; + private TThreadPoolServer server; + + public RemoteInterpreterServer(int port) throws TTransportException { + this.port = port; + processor = new RemoteInterpreterService.Processor<RemoteInterpreterServer>(this); + TServerSocket serverTransport = new TServerSocket(port); + server = new TThreadPoolServer( + new TThreadPoolServer.Args(serverTransport).processor(processor)); + } + + @Override + public void run() { + logger.info("Starting remote interpreter server on port {}", port); + server.serve(); + } + + @Override + public void shutdown() throws TException { + // server.stop() does not always finish server.serve() loop + // sometimes server.serve() is hanging even after server.stop() call. + // this case, need to force kill the process + server.stop(); + } + + public int getPort() { + return port; + } + + public boolean isRunning() { + if (server == null) { + return false; + } else { + return server.isServing(); + } + } + + + public static void main(String[] args) + throws TTransportException, InterruptedException { + int port = Integer.parseInt(args[0]); + RemoteInterpreterServer remoteInterpreterServer = new RemoteInterpreterServer(port); + remoteInterpreterServer.start(); + remoteInterpreterServer.join(); + System.exit(0); + } + + + @Override + public void createInterpreter(String className, Map<String, String> properties) + throws TException { + try { + Class<Interpreter> replClass = (Class<Interpreter>) Object.class.forName(className); + Properties p = new Properties(); + p.putAll(properties); + + Constructor<Interpreter> constructor = + replClass.getConstructor(new Class[] {Properties.class}); + Interpreter repl = constructor.newInstance(p); + + ClassLoader cl = ClassLoader.getSystemClassLoader(); + repl.setClassloaderUrls(new URL[]{}); + + synchronized (interpreterGroup) { + interpreterGroup.add(new LazyOpenInterpreter( + new ClassloaderInterpreter(repl, cl))); + } + + logger.info("Instantiate interpreter {}", className); + repl.setInterpreterGroup(interpreterGroup); + } catch (ClassNotFoundException | NoSuchMethodException | SecurityException + | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + e.printStackTrace(); + throw new TException(e); + } + } + + private Interpreter getInterpreter(String className) throws TException { + synchronized (interpreterGroup) { + for (Interpreter inp : interpreterGroup) { + if (inp.getClassName().equals(className)) { + return inp; + } + } + } + throw new TException(new InterpreterException("Interpreter instance " + + className + " not found")); + } + + @Override + public void open(String className) throws TException { + Interpreter intp = getInterpreter(className); + intp.open(); + } + + @Override + public void close(String className) throws TException { + Interpreter intp = getInterpreter(className); + intp.close(); + } + + + @Override + public RemoteInterpreterResult interpret(String className, String st, + RemoteInterpreterContext interpreterContext) throws TException { + Interpreter intp = getInterpreter(className); + InterpreterContext context = convert(interpreterContext); + + 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) { + } + } + } + + if (job.getStatus() == Status.ERROR) { + throw new TException(job.getException()); + } else { + if (intp.getFormType() == FormType.NATIVE) { + // serialize dynamic form + + } + + return convert((InterpreterResult) job.getReturn(), + context.getConfig(), + context.getGui()); + } + } + + class InterpretJobListener implements JobListener { + + @Override + public void onProgressUpdate(Job job, int progress) { + } + + @Override + public void beforeStatusChange(Job job, Status before, Status after) { + } + + @Override + public void afterStatusChange(Job job, Status before, Status after) { + synchronized (this) { + notifyAll(); + } + } + } + + class InterpretJob extends Job { + + private Interpreter interpreter; + private String script; + private InterpreterContext context; + + public InterpretJob( + String jobId, + String jobName, + JobListener listener, + long progressUpdateIntervalMsec, + Interpreter interpreter, + String script, + InterpreterContext context) { + super(jobId, jobName, listener, progressUpdateIntervalMsec); + this.interpreter = interpreter; + this.script = script; + this.context = context; + } + + @Override + public int progress() { + return 0; + } + + @Override + public Map<String, Object> info() { + return null; + } + + @Override + protected Object jobRun() throws Throwable { + InterpreterResult result = interpreter.interpret(script, context); + return result; + } + + @Override + protected boolean jobAbort() { + return false; + } + } + + + @Override + public void cancel(String className, RemoteInterpreterContext interpreterContext) + throws TException { + Interpreter intp = getInterpreter(className); + intp.cancel(convert(interpreterContext)); + } + + @Override + public int getProgress(String className, RemoteInterpreterContext interpreterContext) + throws TException { + Interpreter intp = getInterpreter(className); + return intp.getProgress(convert(interpreterContext)); + } + + + @Override + public String getFormType(String className) throws TException { + Interpreter intp = getInterpreter(className); + return intp.getFormType().toString(); + } + + @Override + public List<String> completion(String className, String buf, int cursor) throws TException { + Interpreter intp = getInterpreter(className); + return intp.completion(buf, cursor); + } + + private InterpreterContext convert(RemoteInterpreterContext ric) { + return new InterpreterContext( + ric.getParagraphId(), + ric.getParagraphTitle(), + ric.getParagraphText(), + (Map<String, Object>) gson.fromJson(ric.getConfig(), + new TypeToken<Map<String, Object>>() {}.getType()), + gson.fromJson(ric.getGui(), GUI.class)); + } + + 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)); + } + + @Override + public String getStatus(String jobId) + throws TException { + synchronized (interpreterGroup) { + for (Interpreter intp : interpreterGroup) { + for (Job job : intp.getScheduler().getJobsRunning()) { + if (jobId.equals(job.getId())) { + return job.getStatus().name(); + } + } + + for (Job job : intp.getScheduler().getJobsWaiting()) { + if (jobId.equals(job.getId())) { + return job.getStatus().name(); + } + } + } + } + return "Unknown"; + } +} http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterUtils.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterUtils.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterUtils.java new file mode 100644 index 0000000..27983ae --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterUtils.java @@ -0,0 +1,49 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.zeppelin.interpreter.remote; + +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.ServerSocket; +import java.net.Socket; + +/** + * + */ +public class RemoteInterpreterUtils { + public static int findRandomAvailablePortOnAllLocalInterfaces() throws IOException { + int port; + try (ServerSocket socket = new ServerSocket(0);) { + port = socket.getLocalPort(); + socket.close(); + } + return port; + } + + public static boolean checkIfRemoteEndpointAccessible(String host, int port) { + try { + Socket discover = new Socket(); + discover.setSoTimeout(1000); + discover.connect(new InetSocketAddress(host, port), 1000); + discover.close(); + return true; + } catch (IOException e) { + return false; + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterContext.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterContext.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterContext.java new file mode 100644 index 0000000..4284cf1 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterContext.java @@ -0,0 +1,786 @@ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.zeppelin.interpreter.thrift; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class RemoteInterpreterContext implements org.apache.thrift.TBase<RemoteInterpreterContext, RemoteInterpreterContext._Fields>, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); + + private static final org.apache.thrift.protocol.TField PARAGRAPH_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("paragraphId", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField PARAGRAPH_TITLE_FIELD_DESC = new org.apache.thrift.protocol.TField("paragraphTitle", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField PARAGRAPH_TEXT_FIELD_DESC = new org.apache.thrift.protocol.TField("paragraphText", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField CONFIG_FIELD_DESC = new org.apache.thrift.protocol.TField("config", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField GUI_FIELD_DESC = new org.apache.thrift.protocol.TField("gui", org.apache.thrift.protocol.TType.STRING, (short)5); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new RemoteInterpreterContextStandardSchemeFactory()); + schemes.put(TupleScheme.class, new RemoteInterpreterContextTupleSchemeFactory()); + } + + public String paragraphId; // required + public String paragraphTitle; // required + public String paragraphText; // required + public String config; // required + public String gui; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PARAGRAPH_ID((short)1, "paragraphId"), + PARAGRAPH_TITLE((short)2, "paragraphTitle"), + PARAGRAPH_TEXT((short)3, "paragraphText"), + CONFIG((short)4, "config"), + GUI((short)5, "gui"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // PARAGRAPH_ID + return PARAGRAPH_ID; + case 2: // PARAGRAPH_TITLE + return PARAGRAPH_TITLE; + case 3: // PARAGRAPH_TEXT + return PARAGRAPH_TEXT; + case 4: // CONFIG + return CONFIG; + case 5: // GUI + return GUI; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PARAGRAPH_ID, new org.apache.thrift.meta_data.FieldMetaData("paragraphId", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PARAGRAPH_TITLE, new org.apache.thrift.meta_data.FieldMetaData("paragraphTitle", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PARAGRAPH_TEXT, new org.apache.thrift.meta_data.FieldMetaData("paragraphText", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.CONFIG, new org.apache.thrift.meta_data.FieldMetaData("config", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.GUI, new org.apache.thrift.meta_data.FieldMetaData("gui", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RemoteInterpreterContext.class, metaDataMap); + } + + public RemoteInterpreterContext() { + } + + public RemoteInterpreterContext( + String paragraphId, + String paragraphTitle, + String paragraphText, + String config, + String gui) + { + this(); + this.paragraphId = paragraphId; + this.paragraphTitle = paragraphTitle; + this.paragraphText = paragraphText; + this.config = config; + this.gui = gui; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public RemoteInterpreterContext(RemoteInterpreterContext other) { + if (other.isSetParagraphId()) { + this.paragraphId = other.paragraphId; + } + if (other.isSetParagraphTitle()) { + this.paragraphTitle = other.paragraphTitle; + } + if (other.isSetParagraphText()) { + this.paragraphText = other.paragraphText; + } + if (other.isSetConfig()) { + this.config = other.config; + } + if (other.isSetGui()) { + this.gui = other.gui; + } + } + + public RemoteInterpreterContext deepCopy() { + return new RemoteInterpreterContext(this); + } + + @Override + public void clear() { + this.paragraphId = null; + this.paragraphTitle = null; + this.paragraphText = null; + this.config = null; + this.gui = null; + } + + public String getParagraphId() { + return this.paragraphId; + } + + public RemoteInterpreterContext setParagraphId(String paragraphId) { + this.paragraphId = paragraphId; + return this; + } + + public void unsetParagraphId() { + this.paragraphId = null; + } + + /** Returns true if field paragraphId is set (has been assigned a value) and false otherwise */ + public boolean isSetParagraphId() { + return this.paragraphId != null; + } + + public void setParagraphIdIsSet(boolean value) { + if (!value) { + this.paragraphId = null; + } + } + + public String getParagraphTitle() { + return this.paragraphTitle; + } + + public RemoteInterpreterContext setParagraphTitle(String paragraphTitle) { + this.paragraphTitle = paragraphTitle; + return this; + } + + public void unsetParagraphTitle() { + this.paragraphTitle = null; + } + + /** Returns true if field paragraphTitle is set (has been assigned a value) and false otherwise */ + public boolean isSetParagraphTitle() { + return this.paragraphTitle != null; + } + + public void setParagraphTitleIsSet(boolean value) { + if (!value) { + this.paragraphTitle = null; + } + } + + public String getParagraphText() { + return this.paragraphText; + } + + public RemoteInterpreterContext setParagraphText(String paragraphText) { + this.paragraphText = paragraphText; + return this; + } + + public void unsetParagraphText() { + this.paragraphText = null; + } + + /** Returns true if field paragraphText is set (has been assigned a value) and false otherwise */ + public boolean isSetParagraphText() { + return this.paragraphText != null; + } + + public void setParagraphTextIsSet(boolean value) { + if (!value) { + this.paragraphText = null; + } + } + + public String getConfig() { + return this.config; + } + + public RemoteInterpreterContext setConfig(String config) { + this.config = config; + return this; + } + + public void unsetConfig() { + this.config = null; + } + + /** Returns true if field config is set (has been assigned a value) and false otherwise */ + public boolean isSetConfig() { + return this.config != null; + } + + public void setConfigIsSet(boolean value) { + if (!value) { + this.config = null; + } + } + + public String getGui() { + return this.gui; + } + + public RemoteInterpreterContext setGui(String gui) { + this.gui = gui; + return this; + } + + public void unsetGui() { + this.gui = null; + } + + /** Returns true if field gui is set (has been assigned a value) and false otherwise */ + public boolean isSetGui() { + return this.gui != null; + } + + public void setGuiIsSet(boolean value) { + if (!value) { + this.gui = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PARAGRAPH_ID: + if (value == null) { + unsetParagraphId(); + } else { + setParagraphId((String)value); + } + break; + + case PARAGRAPH_TITLE: + if (value == null) { + unsetParagraphTitle(); + } else { + setParagraphTitle((String)value); + } + break; + + case PARAGRAPH_TEXT: + if (value == null) { + unsetParagraphText(); + } else { + setParagraphText((String)value); + } + break; + + case CONFIG: + if (value == null) { + unsetConfig(); + } else { + setConfig((String)value); + } + break; + + case GUI: + if (value == null) { + unsetGui(); + } else { + setGui((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PARAGRAPH_ID: + return getParagraphId(); + + case PARAGRAPH_TITLE: + return getParagraphTitle(); + + case PARAGRAPH_TEXT: + return getParagraphText(); + + case CONFIG: + return getConfig(); + + case GUI: + return getGui(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case PARAGRAPH_ID: + return isSetParagraphId(); + case PARAGRAPH_TITLE: + return isSetParagraphTitle(); + case PARAGRAPH_TEXT: + return isSetParagraphText(); + case CONFIG: + return isSetConfig(); + case GUI: + return isSetGui(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof RemoteInterpreterContext) + return this.equals((RemoteInterpreterContext)that); + return false; + } + + public boolean equals(RemoteInterpreterContext that) { + if (that == null) + return false; + + boolean this_present_paragraphId = true && this.isSetParagraphId(); + boolean that_present_paragraphId = true && that.isSetParagraphId(); + if (this_present_paragraphId || that_present_paragraphId) { + if (!(this_present_paragraphId && that_present_paragraphId)) + return false; + if (!this.paragraphId.equals(that.paragraphId)) + return false; + } + + boolean this_present_paragraphTitle = true && this.isSetParagraphTitle(); + boolean that_present_paragraphTitle = true && that.isSetParagraphTitle(); + if (this_present_paragraphTitle || that_present_paragraphTitle) { + if (!(this_present_paragraphTitle && that_present_paragraphTitle)) + return false; + if (!this.paragraphTitle.equals(that.paragraphTitle)) + return false; + } + + boolean this_present_paragraphText = true && this.isSetParagraphText(); + boolean that_present_paragraphText = true && that.isSetParagraphText(); + if (this_present_paragraphText || that_present_paragraphText) { + if (!(this_present_paragraphText && that_present_paragraphText)) + return false; + if (!this.paragraphText.equals(that.paragraphText)) + return false; + } + + boolean this_present_config = true && this.isSetConfig(); + boolean that_present_config = true && that.isSetConfig(); + if (this_present_config || that_present_config) { + if (!(this_present_config && that_present_config)) + return false; + if (!this.config.equals(that.config)) + return false; + } + + boolean this_present_gui = true && this.isSetGui(); + boolean that_present_gui = true && that.isSetGui(); + if (this_present_gui || that_present_gui) { + if (!(this_present_gui && that_present_gui)) + return false; + if (!this.gui.equals(that.gui)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(RemoteInterpreterContext other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + RemoteInterpreterContext typedOther = (RemoteInterpreterContext)other; + + lastComparison = Boolean.valueOf(isSetParagraphId()).compareTo(typedOther.isSetParagraphId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParagraphId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paragraphId, typedOther.paragraphId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetParagraphTitle()).compareTo(typedOther.isSetParagraphTitle()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParagraphTitle()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paragraphTitle, typedOther.paragraphTitle); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetParagraphText()).compareTo(typedOther.isSetParagraphText()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParagraphText()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paragraphText, typedOther.paragraphText); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetConfig()).compareTo(typedOther.isSetConfig()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetConfig()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.config, typedOther.config); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetGui()).compareTo(typedOther.isSetGui()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetGui()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gui, typedOther.gui); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("RemoteInterpreterContext("); + boolean first = true; + + sb.append("paragraphId:"); + if (this.paragraphId == null) { + sb.append("null"); + } else { + sb.append(this.paragraphId); + } + first = false; + if (!first) sb.append(", "); + sb.append("paragraphTitle:"); + if (this.paragraphTitle == null) { + sb.append("null"); + } else { + sb.append(this.paragraphTitle); + } + first = false; + if (!first) sb.append(", "); + sb.append("paragraphText:"); + if (this.paragraphText == null) { + sb.append("null"); + } else { + sb.append(this.paragraphText); + } + first = false; + if (!first) sb.append(", "); + sb.append("config:"); + if (this.config == null) { + sb.append("null"); + } else { + sb.append(this.config); + } + first = false; + if (!first) sb.append(", "); + sb.append("gui:"); + if (this.gui == null) { + sb.append("null"); + } else { + sb.append(this.gui); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class RemoteInterpreterContextStandardSchemeFactory implements SchemeFactory { + public RemoteInterpreterContextStandardScheme getScheme() { + return new RemoteInterpreterContextStandardScheme(); + } + } + + private static class RemoteInterpreterContextStandardScheme extends StandardScheme<RemoteInterpreterContext> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, RemoteInterpreterContext struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // PARAGRAPH_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.paragraphId = iprot.readString(); + struct.setParagraphIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PARAGRAPH_TITLE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.paragraphTitle = iprot.readString(); + struct.setParagraphTitleIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PARAGRAPH_TEXT + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.paragraphText = iprot.readString(); + struct.setParagraphTextIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // CONFIG + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.config = iprot.readString(); + struct.setConfigIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // GUI + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.gui = iprot.readString(); + struct.setGuiIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, RemoteInterpreterContext struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.paragraphId != null) { + oprot.writeFieldBegin(PARAGRAPH_ID_FIELD_DESC); + oprot.writeString(struct.paragraphId); + oprot.writeFieldEnd(); + } + if (struct.paragraphTitle != null) { + oprot.writeFieldBegin(PARAGRAPH_TITLE_FIELD_DESC); + oprot.writeString(struct.paragraphTitle); + oprot.writeFieldEnd(); + } + if (struct.paragraphText != null) { + oprot.writeFieldBegin(PARAGRAPH_TEXT_FIELD_DESC); + oprot.writeString(struct.paragraphText); + oprot.writeFieldEnd(); + } + if (struct.config != null) { + oprot.writeFieldBegin(CONFIG_FIELD_DESC); + oprot.writeString(struct.config); + oprot.writeFieldEnd(); + } + if (struct.gui != null) { + oprot.writeFieldBegin(GUI_FIELD_DESC); + oprot.writeString(struct.gui); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class RemoteInterpreterContextTupleSchemeFactory implements SchemeFactory { + public RemoteInterpreterContextTupleScheme getScheme() { + return new RemoteInterpreterContextTupleScheme(); + } + } + + private static class RemoteInterpreterContextTupleScheme extends TupleScheme<RemoteInterpreterContext> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, RemoteInterpreterContext struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetParagraphId()) { + optionals.set(0); + } + if (struct.isSetParagraphTitle()) { + optionals.set(1); + } + if (struct.isSetParagraphText()) { + optionals.set(2); + } + if (struct.isSetConfig()) { + optionals.set(3); + } + if (struct.isSetGui()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetParagraphId()) { + oprot.writeString(struct.paragraphId); + } + if (struct.isSetParagraphTitle()) { + oprot.writeString(struct.paragraphTitle); + } + if (struct.isSetParagraphText()) { + oprot.writeString(struct.paragraphText); + } + if (struct.isSetConfig()) { + oprot.writeString(struct.config); + } + if (struct.isSetGui()) { + oprot.writeString(struct.gui); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, RemoteInterpreterContext struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.paragraphId = iprot.readString(); + struct.setParagraphIdIsSet(true); + } + if (incoming.get(1)) { + struct.paragraphTitle = iprot.readString(); + struct.setParagraphTitleIsSet(true); + } + if (incoming.get(2)) { + struct.paragraphText = iprot.readString(); + struct.setParagraphTextIsSet(true); + } + if (incoming.get(3)) { + struct.config = iprot.readString(); + struct.setConfigIsSet(true); + } + if (incoming.get(4)) { + struct.gui = iprot.readString(); + struct.setGuiIsSet(true); + } + } + } + +} + http://git-wip-us.apache.org/repos/asf/incubator-zeppelin/blob/669d408d/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterResult.java ---------------------------------------------------------------------- diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterResult.java new file mode 100644 index 0000000..5a68bd0 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterResult.java @@ -0,0 +1,786 @@ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.zeppelin.interpreter.thrift; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class RemoteInterpreterResult implements org.apache.thrift.TBase<RemoteInterpreterResult, RemoteInterpreterResult._Fields>, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); + + private static final org.apache.thrift.protocol.TField CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("code", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField MSG_FIELD_DESC = new org.apache.thrift.protocol.TField("msg", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField CONFIG_FIELD_DESC = new org.apache.thrift.protocol.TField("config", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField GUI_FIELD_DESC = new org.apache.thrift.protocol.TField("gui", org.apache.thrift.protocol.TType.STRING, (short)5); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new RemoteInterpreterResultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new RemoteInterpreterResultTupleSchemeFactory()); + } + + public String code; // required + public String type; // required + public String msg; // required + public String config; // required + public String gui; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + CODE((short)1, "code"), + TYPE((short)2, "type"), + MSG((short)3, "msg"), + CONFIG((short)4, "config"), + GUI((short)5, "gui"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // CODE + return CODE; + case 2: // TYPE + return TYPE; + case 3: // MSG + return MSG; + case 4: // CONFIG + return CONFIG; + case 5: // GUI + return GUI; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.CODE, new org.apache.thrift.meta_data.FieldMetaData("code", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.MSG, new org.apache.thrift.meta_data.FieldMetaData("msg", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.CONFIG, new org.apache.thrift.meta_data.FieldMetaData("config", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.GUI, new org.apache.thrift.meta_data.FieldMetaData("gui", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RemoteInterpreterResult.class, metaDataMap); + } + + public RemoteInterpreterResult() { + } + + public RemoteInterpreterResult( + String code, + String type, + String msg, + String config, + String gui) + { + this(); + this.code = code; + this.type = type; + this.msg = msg; + this.config = config; + this.gui = gui; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public RemoteInterpreterResult(RemoteInterpreterResult other) { + if (other.isSetCode()) { + this.code = other.code; + } + if (other.isSetType()) { + this.type = other.type; + } + if (other.isSetMsg()) { + this.msg = other.msg; + } + if (other.isSetConfig()) { + this.config = other.config; + } + if (other.isSetGui()) { + this.gui = other.gui; + } + } + + public RemoteInterpreterResult deepCopy() { + return new RemoteInterpreterResult(this); + } + + @Override + public void clear() { + this.code = null; + this.type = null; + this.msg = null; + this.config = null; + this.gui = null; + } + + public String getCode() { + return this.code; + } + + public RemoteInterpreterResult setCode(String code) { + this.code = code; + return this; + } + + public void unsetCode() { + this.code = null; + } + + /** Returns true if field code is set (has been assigned a value) and false otherwise */ + public boolean isSetCode() { + return this.code != null; + } + + public void setCodeIsSet(boolean value) { + if (!value) { + this.code = null; + } + } + + public String getType() { + return this.type; + } + + public RemoteInterpreterResult setType(String type) { + this.type = type; + return this; + } + + public void unsetType() { + this.type = null; + } + + /** Returns true if field type is set (has been assigned a value) and false otherwise */ + public boolean isSetType() { + return this.type != null; + } + + public void setTypeIsSet(boolean value) { + if (!value) { + this.type = null; + } + } + + public String getMsg() { + return this.msg; + } + + public RemoteInterpreterResult setMsg(String msg) { + this.msg = msg; + return this; + } + + public void unsetMsg() { + this.msg = null; + } + + /** Returns true if field msg is set (has been assigned a value) and false otherwise */ + public boolean isSetMsg() { + return this.msg != null; + } + + public void setMsgIsSet(boolean value) { + if (!value) { + this.msg = null; + } + } + + public String getConfig() { + return this.config; + } + + public RemoteInterpreterResult setConfig(String config) { + this.config = config; + return this; + } + + public void unsetConfig() { + this.config = null; + } + + /** Returns true if field config is set (has been assigned a value) and false otherwise */ + public boolean isSetConfig() { + return this.config != null; + } + + public void setConfigIsSet(boolean value) { + if (!value) { + this.config = null; + } + } + + public String getGui() { + return this.gui; + } + + public RemoteInterpreterResult setGui(String gui) { + this.gui = gui; + return this; + } + + public void unsetGui() { + this.gui = null; + } + + /** Returns true if field gui is set (has been assigned a value) and false otherwise */ + public boolean isSetGui() { + return this.gui != null; + } + + public void setGuiIsSet(boolean value) { + if (!value) { + this.gui = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case CODE: + if (value == null) { + unsetCode(); + } else { + setCode((String)value); + } + break; + + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((String)value); + } + break; + + case MSG: + if (value == null) { + unsetMsg(); + } else { + setMsg((String)value); + } + break; + + case CONFIG: + if (value == null) { + unsetConfig(); + } else { + setConfig((String)value); + } + break; + + case GUI: + if (value == null) { + unsetGui(); + } else { + setGui((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case CODE: + return getCode(); + + case TYPE: + return getType(); + + case MSG: + return getMsg(); + + case CONFIG: + return getConfig(); + + case GUI: + return getGui(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case CODE: + return isSetCode(); + case TYPE: + return isSetType(); + case MSG: + return isSetMsg(); + case CONFIG: + return isSetConfig(); + case GUI: + return isSetGui(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof RemoteInterpreterResult) + return this.equals((RemoteInterpreterResult)that); + return false; + } + + public boolean equals(RemoteInterpreterResult that) { + if (that == null) + return false; + + boolean this_present_code = true && this.isSetCode(); + boolean that_present_code = true && that.isSetCode(); + if (this_present_code || that_present_code) { + if (!(this_present_code && that_present_code)) + return false; + if (!this.code.equals(that.code)) + return false; + } + + boolean this_present_type = true && this.isSetType(); + boolean that_present_type = true && that.isSetType(); + if (this_present_type || that_present_type) { + if (!(this_present_type && that_present_type)) + return false; + if (!this.type.equals(that.type)) + return false; + } + + boolean this_present_msg = true && this.isSetMsg(); + boolean that_present_msg = true && that.isSetMsg(); + if (this_present_msg || that_present_msg) { + if (!(this_present_msg && that_present_msg)) + return false; + if (!this.msg.equals(that.msg)) + return false; + } + + boolean this_present_config = true && this.isSetConfig(); + boolean that_present_config = true && that.isSetConfig(); + if (this_present_config || that_present_config) { + if (!(this_present_config && that_present_config)) + return false; + if (!this.config.equals(that.config)) + return false; + } + + boolean this_present_gui = true && this.isSetGui(); + boolean that_present_gui = true && that.isSetGui(); + if (this_present_gui || that_present_gui) { + if (!(this_present_gui && that_present_gui)) + return false; + if (!this.gui.equals(that.gui)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(RemoteInterpreterResult other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + RemoteInterpreterResult typedOther = (RemoteInterpreterResult)other; + + lastComparison = Boolean.valueOf(isSetCode()).compareTo(typedOther.isSetCode()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCode()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.code, typedOther.code); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, typedOther.type); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMsg()).compareTo(typedOther.isSetMsg()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMsg()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, typedOther.msg); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetConfig()).compareTo(typedOther.isSetConfig()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetConfig()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.config, typedOther.config); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetGui()).compareTo(typedOther.isSetGui()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetGui()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.gui, typedOther.gui); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("RemoteInterpreterResult("); + boolean first = true; + + sb.append("code:"); + if (this.code == null) { + sb.append("null"); + } else { + sb.append(this.code); + } + first = false; + if (!first) sb.append(", "); + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; + if (!first) sb.append(", "); + sb.append("msg:"); + if (this.msg == null) { + sb.append("null"); + } else { + sb.append(this.msg); + } + first = false; + if (!first) sb.append(", "); + sb.append("config:"); + if (this.config == null) { + sb.append("null"); + } else { + sb.append(this.config); + } + first = false; + if (!first) sb.append(", "); + sb.append("gui:"); + if (this.gui == null) { + sb.append("null"); + } else { + sb.append(this.gui); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class RemoteInterpreterResultStandardSchemeFactory implements SchemeFactory { + public RemoteInterpreterResultStandardScheme getScheme() { + return new RemoteInterpreterResultStandardScheme(); + } + } + + private static class RemoteInterpreterResultStandardScheme extends StandardScheme<RemoteInterpreterResult> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, RemoteInterpreterResult struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // CODE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.code = iprot.readString(); + struct.setCodeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.type = iprot.readString(); + struct.setTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // MSG + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.msg = iprot.readString(); + struct.setMsgIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // CONFIG + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.config = iprot.readString(); + struct.setConfigIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // GUI + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.gui = iprot.readString(); + struct.setGuiIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, RemoteInterpreterResult struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.code != null) { + oprot.writeFieldBegin(CODE_FIELD_DESC); + oprot.writeString(struct.code); + oprot.writeFieldEnd(); + } + if (struct.type != null) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeString(struct.type); + oprot.writeFieldEnd(); + } + if (struct.msg != null) { + oprot.writeFieldBegin(MSG_FIELD_DESC); + oprot.writeString(struct.msg); + oprot.writeFieldEnd(); + } + if (struct.config != null) { + oprot.writeFieldBegin(CONFIG_FIELD_DESC); + oprot.writeString(struct.config); + oprot.writeFieldEnd(); + } + if (struct.gui != null) { + oprot.writeFieldBegin(GUI_FIELD_DESC); + oprot.writeString(struct.gui); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class RemoteInterpreterResultTupleSchemeFactory implements SchemeFactory { + public RemoteInterpreterResultTupleScheme getScheme() { + return new RemoteInterpreterResultTupleScheme(); + } + } + + private static class RemoteInterpreterResultTupleScheme extends TupleScheme<RemoteInterpreterResult> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, RemoteInterpreterResult struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetCode()) { + optionals.set(0); + } + if (struct.isSetType()) { + optionals.set(1); + } + if (struct.isSetMsg()) { + optionals.set(2); + } + if (struct.isSetConfig()) { + optionals.set(3); + } + if (struct.isSetGui()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetCode()) { + oprot.writeString(struct.code); + } + if (struct.isSetType()) { + oprot.writeString(struct.type); + } + if (struct.isSetMsg()) { + oprot.writeString(struct.msg); + } + if (struct.isSetConfig()) { + oprot.writeString(struct.config); + } + if (struct.isSetGui()) { + oprot.writeString(struct.gui); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, RemoteInterpreterResult struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.code = iprot.readString(); + struct.setCodeIsSet(true); + } + if (incoming.get(1)) { + struct.type = iprot.readString(); + struct.setTypeIsSet(true); + } + if (incoming.get(2)) { + struct.msg = iprot.readString(); + struct.setMsgIsSet(true); + } + if (incoming.get(3)) { + struct.config = iprot.readString(); + struct.setConfigIsSet(true); + } + if (incoming.get(4)) { + struct.gui = iprot.readString(); + struct.setGuiIsSet(true); + } + } + } + +} +
