From 6e1f219993d4d98f27cdba697b69a0a641f116f6 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Fri, 11 Nov 2016 12:14:12 +0900 Subject: [PATCH 01/23] code base workflow for remote zeppelin server control default thrift transaction. --- .../remote/RemoteInterpreterEventClient.java | 20 + .../remote/RemoteInterpreterEventPoller.java | 47 ++ .../remote/RemoteInterpreterServer.java | 10 + .../thrift/InterpreterCompletion.java | 2 +- .../thrift/RemoteApplicationResult.java | 2 +- .../thrift/RemoteInterpreterContext.java | 2 +- .../thrift/RemoteInterpreterEvent.java | 2 +- .../thrift/RemoteInterpreterEventType.java | 5 +- .../thrift/RemoteInterpreterResult.java | 2 +- .../thrift/RemoteInterpreterService.java | 744 +++++++++++++++++- .../RemoteZeppelinServerControlEvent.java | 62 ++ .../RemoteZeppelinServerController.java | 641 +++++++++++++++ .../RemoteZeppelinServerResourceType.java | 59 ++ .../thrift/ZeppelinServerResource.java | 641 +++++++++++++++ ...ZeppelinServerResourceParagraphRunner.java | 625 +++++++++++++++ .../thrift/RemoteInterpreterService.thrift | 35 + 16 files changed, 2892 insertions(+), 7 deletions(-) create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java index c59a6f60ce3..819331e81da 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java @@ -21,6 +21,9 @@ import org.apache.zeppelin.interpreter.InterpreterContextRunner; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; +import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent; +import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; +import org.apache.zeppelin.interpreter.thrift.ZeppelinServerResourceParagraphRunner; import org.apache.zeppelin.resource.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,6 +51,23 @@ public class RemoteInterpreterEventClient implements ResourcePoolConnector { private final Map getResourceResponse = new HashMap<>(); private final Gson gson = new Gson(); + // cloverhearts + /** + * Run paragraph + * @param runner + */ + public void getZeppelinServerNoteRunner( + String eventOwnerKey, ZeppelinServerResourceParagraphRunner runner) { + RemoteZeppelinServerController eventBody = new RemoteZeppelinServerController(); + eventBody.setType(RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT); + eventBody.setEventOwnerKey(eventOwnerKey); + eventBody.setMsg(gson.toJson(runner)); + + sendEvent(new RemoteInterpreterEvent( + RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_CONTROL, + gson.toJson(eventBody))); + } + /** * Run paragraph * @param runner diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index f7fee490daa..effc7ea4e98 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -28,6 +28,9 @@ import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; +import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent; +import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; +import org.apache.zeppelin.interpreter.thrift.ZeppelinServerResourceParagraphRunner; import org.apache.zeppelin.resource.Resource; import org.apache.zeppelin.resource.ResourceId; import org.apache.zeppelin.resource.ResourcePool; @@ -195,6 +198,12 @@ public void run() { String status = appStatusUpdate.get("status"); appListener.onStatusChange(noteId, paragraphId, appId, status); + } else if (event.getType() == RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_CONTROL) { + RemoteZeppelinServerController remoteControlEvent = gson.fromJson( + event.getData(), RemoteZeppelinServerController.class); + //cloverhearts + progressRemoteZeppelinControlEvent(remoteControlEvent); + } logger.debug("Event from remoteproceess {}", event.getType()); } catch (Exception e) { @@ -206,6 +215,44 @@ public void run() { } } + private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController event) { + logger.info("clover - received RemoteInterpreterEvent"); + Gson gson = new Gson(); + String eventOwnerKey = event.getEventOwnerKey(); + Client interpreterServer = null; + boolean broken = false; + try { + interpreterServer = interpreterProcess.getClient(); + + if (event.getType() == RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT) { + ZeppelinServerResourceParagraphRunner runner = gson.fromJson( + event.getMsg(), ZeppelinServerResourceParagraphRunner.class); + + RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); + resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); + resResource.setEventOwnerKey(eventOwnerKey); + resResource.setMsg("test123123"); + interpreterServer.remoteZeppelinServerControlFeedback(resResource); + logger.info("get runner noteid {} paragraphid {}", + runner.getNoteId(), runner.getParagraphId()); + } + + } catch (Exception e) { + broken = true; + logger.error("Can't get RemoteInterpreterEvent", e); + waitQuietly(); + + } finally { + interpreterProcess.releaseClient(interpreterServer, broken); + } + + if (broken == true) { + return; + } + + logger.info("clover - remote event {}", event.getType()); + } + private void sendResourcePoolResponseGetAll(ResourceSet resourceSet) { Client client = null; boolean broken = false; 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 index cde6a7ba7ef..d26f35e7ac1 100644 --- 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 @@ -336,6 +336,12 @@ public RemoteInterpreterResult interpret(String noteId, String className, String context.getGui()); } + @Override + public void remoteZeppelinServerControlFeedback( + RemoteZeppelinServerController response) throws TException { + logger.info("clover remote zeppelin server controller feedback {}", response); + logger.info("clover remote zeppelin server conteroller body {}", response.getMsg()); + } class InterpretJobListener implements JobListener { @@ -585,6 +591,10 @@ public ParagraphRunner(RemoteInterpreterServer server, String noteId, String par @Override public void run() { + ZeppelinServerResourceParagraphRunner test = new ZeppelinServerResourceParagraphRunner(); + test.setNoteId("TEST NOTE"); + test.setParagraphId("TEST PARAGRAPH"); + server.eventClient.getZeppelinServerNoteRunner("IamOWNER", test); server.eventClient.run(this); } } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java index 9ceba88826d..7dadd4f23d7 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-6-8") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") public class InterpreterCompletion implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InterpreterCompletion"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java index a192899daa1..75a2a78338e 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-5-7") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") public class RemoteApplicationResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteApplicationResult"); 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 index f8b63ff3422..d0b2ecedb82 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-6-8") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") public class RemoteInterpreterContext implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java index 0db5697bbf5..f235c28d46a 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-6-8") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") public class RemoteInterpreterEvent implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterEvent"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java index 955461951f3..2df81c00092 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java @@ -39,7 +39,8 @@ public enum RemoteInterpreterEventType implements org.apache.thrift.TEnum { OUTPUT_APPEND(8), OUTPUT_UPDATE(9), ANGULAR_REGISTRY_PUSH(10), - APP_STATUS_UPDATE(11); + APP_STATUS_UPDATE(11), + REMOTE_ZEPPELIN_SERVER_CONTROL(12); private final int value; @@ -82,6 +83,8 @@ public static RemoteInterpreterEventType findByValue(int value) { return ANGULAR_REGISTRY_PUSH; case 11: return APP_STATUS_UPDATE; + case 12: + return REMOTE_ZEPPELIN_SERVER_CONTROL; default: return null; } 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 index 1af0ce0b2b5..e034086a5ee 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-6-8") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") public class RemoteInterpreterResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java index e3ddeebc664..814da9f2581 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-6-8") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") public class RemoteInterpreterService { public interface Iface { @@ -102,6 +102,8 @@ public interface Iface { public RemoteApplicationResult runApplication(String applicationInstanceId) throws org.apache.thrift.TException; + public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response) throws org.apache.thrift.TException; + } public interface AsyncIface { @@ -152,6 +154,8 @@ public interface AsyncIface { public void runApplication(String applicationInstanceId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + } public static class Client extends org.apache.thrift.TServiceClient implements Iface { @@ -700,6 +704,26 @@ public RemoteApplicationResult recv_runApplication() throws org.apache.thrift.TE throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "runApplication failed: unknown result"); } + public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response) throws org.apache.thrift.TException + { + send_remoteZeppelinServerControlFeedback(response); + recv_remoteZeppelinServerControlFeedback(); + } + + public void send_remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response) throws org.apache.thrift.TException + { + remoteZeppelinServerControlFeedback_args args = new remoteZeppelinServerControlFeedback_args(); + args.setResponse(response); + sendBase("remoteZeppelinServerControlFeedback", args); + } + + public void recv_remoteZeppelinServerControlFeedback() throws org.apache.thrift.TException + { + remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); + receiveBase(result, "remoteZeppelinServerControlFeedback"); + return; + } + } public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface { public static class Factory implements org.apache.thrift.async.TAsyncClientFactory { @@ -1544,6 +1568,38 @@ public RemoteApplicationResult getResult() throws org.apache.thrift.TException { } } + public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + remoteZeppelinServerControlFeedback_call method_call = new remoteZeppelinServerControlFeedback_call(response, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class remoteZeppelinServerControlFeedback_call extends org.apache.thrift.async.TAsyncMethodCall { + private RemoteZeppelinServerController response; + public remoteZeppelinServerControlFeedback_call(RemoteZeppelinServerController response, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.response = response; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("remoteZeppelinServerControlFeedback", org.apache.thrift.protocol.TMessageType.CALL, 0)); + remoteZeppelinServerControlFeedback_args args = new remoteZeppelinServerControlFeedback_args(); + args.setResponse(response); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_remoteZeppelinServerControlFeedback(); + } + } + } public static class Processor extends org.apache.thrift.TBaseProcessor implements org.apache.thrift.TProcessor { @@ -1580,6 +1636,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public remoteZeppelinServerControlFeedback() { + super("remoteZeppelinServerControlFeedback"); + } + + public remoteZeppelinServerControlFeedback_args getEmptyArgsInstance() { + return new remoteZeppelinServerControlFeedback_args(); + } + + protected boolean isOneway() { + return false; + } + + public remoteZeppelinServerControlFeedback_result getResult(I iface, remoteZeppelinServerControlFeedback_args args) throws org.apache.thrift.TException { + remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); + iface.remoteZeppelinServerControlFeedback(args.response); + return result; + } + } + } public static class AsyncProcessor extends org.apache.thrift.TBaseAsyncProcessor { @@ -2081,6 +2158,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { + public remoteZeppelinServerControlFeedback() { + super("remoteZeppelinServerControlFeedback"); + } + + public remoteZeppelinServerControlFeedback_args getEmptyArgsInstance() { + return new remoteZeppelinServerControlFeedback_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, remoteZeppelinServerControlFeedback_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.remoteZeppelinServerControlFeedback(args.response,resultHandler); + } + } + } public static class createInterpreter_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { @@ -22001,4 +22129,618 @@ public void read(org.apache.thrift.protocol.TProtocol prot, runApplication_resul } + public static class remoteZeppelinServerControlFeedback_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("remoteZeppelinServerControlFeedback_args"); + + private static final org.apache.thrift.protocol.TField RESPONSE_FIELD_DESC = new org.apache.thrift.protocol.TField("response", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new remoteZeppelinServerControlFeedback_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new remoteZeppelinServerControlFeedback_argsTupleSchemeFactory()); + } + + public RemoteZeppelinServerController response; // 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 { + RESPONSE((short)1, "response"); + + private static final Map byName = new HashMap(); + + 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: // RESPONSE + return RESPONSE; + 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.RESPONSE, new org.apache.thrift.meta_data.FieldMetaData("response", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RemoteZeppelinServerController.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(remoteZeppelinServerControlFeedback_args.class, metaDataMap); + } + + public remoteZeppelinServerControlFeedback_args() { + } + + public remoteZeppelinServerControlFeedback_args( + RemoteZeppelinServerController response) + { + this(); + this.response = response; + } + + /** + * Performs a deep copy on other. + */ + public remoteZeppelinServerControlFeedback_args(remoteZeppelinServerControlFeedback_args other) { + if (other.isSetResponse()) { + this.response = new RemoteZeppelinServerController(other.response); + } + } + + public remoteZeppelinServerControlFeedback_args deepCopy() { + return new remoteZeppelinServerControlFeedback_args(this); + } + + @Override + public void clear() { + this.response = null; + } + + public RemoteZeppelinServerController getResponse() { + return this.response; + } + + public remoteZeppelinServerControlFeedback_args setResponse(RemoteZeppelinServerController response) { + this.response = response; + return this; + } + + public void unsetResponse() { + this.response = null; + } + + /** Returns true if field response is set (has been assigned a value) and false otherwise */ + public boolean isSetResponse() { + return this.response != null; + } + + public void setResponseIsSet(boolean value) { + if (!value) { + this.response = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RESPONSE: + if (value == null) { + unsetResponse(); + } else { + setResponse((RemoteZeppelinServerController)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RESPONSE: + return getResponse(); + + } + 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 RESPONSE: + return isSetResponse(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof remoteZeppelinServerControlFeedback_args) + return this.equals((remoteZeppelinServerControlFeedback_args)that); + return false; + } + + public boolean equals(remoteZeppelinServerControlFeedback_args that) { + if (that == null) + return false; + + boolean this_present_response = true && this.isSetResponse(); + boolean that_present_response = true && that.isSetResponse(); + if (this_present_response || that_present_response) { + if (!(this_present_response && that_present_response)) + return false; + if (!this.response.equals(that.response)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_response = true && (isSetResponse()); + list.add(present_response); + if (present_response) + list.add(response); + + return list.hashCode(); + } + + @Override + public int compareTo(remoteZeppelinServerControlFeedback_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetResponse()).compareTo(other.isSetResponse()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetResponse()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.response, other.response); + 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("remoteZeppelinServerControlFeedback_args("); + boolean first = true; + + sb.append("response:"); + if (this.response == null) { + sb.append("null"); + } else { + sb.append(this.response); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (response != null) { + response.validate(); + } + } + + 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 remoteZeppelinServerControlFeedback_argsStandardSchemeFactory implements SchemeFactory { + public remoteZeppelinServerControlFeedback_argsStandardScheme getScheme() { + return new remoteZeppelinServerControlFeedback_argsStandardScheme(); + } + } + + private static class remoteZeppelinServerControlFeedback_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServerControlFeedback_args 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: // RESPONSE + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.response = new RemoteZeppelinServerController(); + struct.response.read(iprot); + struct.setResponseIsSet(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, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.response != null) { + oprot.writeFieldBegin(RESPONSE_FIELD_DESC); + struct.response.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class remoteZeppelinServerControlFeedback_argsTupleSchemeFactory implements SchemeFactory { + public remoteZeppelinServerControlFeedback_argsTupleScheme getScheme() { + return new remoteZeppelinServerControlFeedback_argsTupleScheme(); + } + } + + private static class remoteZeppelinServerControlFeedback_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetResponse()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetResponse()) { + struct.response.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.response = new RemoteZeppelinServerController(); + struct.response.read(iprot); + struct.setResponseIsSet(true); + } + } + } + + } + + public static class remoteZeppelinServerControlFeedback_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("remoteZeppelinServerControlFeedback_result"); + + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new remoteZeppelinServerControlFeedback_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new remoteZeppelinServerControlFeedback_resultTupleSchemeFactory()); + } + + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { +; + + private static final Map byName = new HashMap(); + + 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) { + 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; + } + } + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(remoteZeppelinServerControlFeedback_result.class, metaDataMap); + } + + public remoteZeppelinServerControlFeedback_result() { + } + + /** + * Performs a deep copy on other. + */ + public remoteZeppelinServerControlFeedback_result(remoteZeppelinServerControlFeedback_result other) { + } + + public remoteZeppelinServerControlFeedback_result deepCopy() { + return new remoteZeppelinServerControlFeedback_result(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof remoteZeppelinServerControlFeedback_result) + return this.equals((remoteZeppelinServerControlFeedback_result)that); + return false; + } + + public boolean equals(remoteZeppelinServerControlFeedback_result that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + return list.hashCode(); + } + + @Override + public int compareTo(remoteZeppelinServerControlFeedback_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("remoteZeppelinServerControlFeedback_result("); + boolean first = true; + + 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 remoteZeppelinServerControlFeedback_resultStandardSchemeFactory implements SchemeFactory { + public remoteZeppelinServerControlFeedback_resultStandardScheme getScheme() { + return new remoteZeppelinServerControlFeedback_resultStandardScheme(); + } + } + + private static class remoteZeppelinServerControlFeedback_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServerControlFeedback_result 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) { + 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, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class remoteZeppelinServerControlFeedback_resultTupleSchemeFactory implements SchemeFactory { + public remoteZeppelinServerControlFeedback_resultTupleScheme getScheme() { + return new remoteZeppelinServerControlFeedback_resultTupleScheme(); + } + } + + private static class remoteZeppelinServerControlFeedback_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java new file mode 100644 index 00000000000..44d61abf720 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java @@ -0,0 +1,62 @@ +/** + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.zeppelin.interpreter.thrift; + + +import java.util.Map; +import java.util.HashMap; +import org.apache.thrift.TEnum; + +public enum RemoteZeppelinServerControlEvent implements org.apache.thrift.TEnum { + REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT(1), + RES_RESOURCE_PARAGRAPH_RUN_CONTEXT(2); + + private final int value; + + private RemoteZeppelinServerControlEvent(int value) { + this.value = value; + } + + /** + * Get the integer value of this enum value, as defined in the Thrift IDL. + */ + public int getValue() { + return value; + } + + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static RemoteZeppelinServerControlEvent findByValue(int value) { + switch (value) { + case 1: + return REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT; + case 2: + return RES_RESOURCE_PARAGRAPH_RUN_CONTEXT; + default: + return null; + } + } +} diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java new file mode 100644 index 00000000000..9b3e6d65f44 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java @@ -0,0 +1,641 @@ +/** + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * 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 org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +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 javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +public class RemoteZeppelinServerController implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteZeppelinServerController"); + + private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField EVENT_OWNER_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("eventOwnerKey", 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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new RemoteZeppelinServerControllerStandardSchemeFactory()); + schemes.put(TupleScheme.class, new RemoteZeppelinServerControllerTupleSchemeFactory()); + } + + /** + * + * @see RemoteZeppelinServerControlEvent + */ + public RemoteZeppelinServerControlEvent type; // required + public String eventOwnerKey; // required + public String msg; // 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 { + /** + * + * @see RemoteZeppelinServerControlEvent + */ + TYPE((short)1, "type"), + EVENT_OWNER_KEY((short)2, "eventOwnerKey"), + MSG((short)3, "msg"); + + private static final Map byName = new HashMap(); + + 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: // TYPE + return TYPE; + case 2: // EVENT_OWNER_KEY + return EVENT_OWNER_KEY; + case 3: // MSG + return MSG; + 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.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, RemoteZeppelinServerControlEvent.class))); + tmpMap.put(_Fields.EVENT_OWNER_KEY, new org.apache.thrift.meta_data.FieldMetaData("eventOwnerKey", 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))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RemoteZeppelinServerController.class, metaDataMap); + } + + public RemoteZeppelinServerController() { + } + + public RemoteZeppelinServerController( + RemoteZeppelinServerControlEvent type, + String eventOwnerKey, + String msg) + { + this(); + this.type = type; + this.eventOwnerKey = eventOwnerKey; + this.msg = msg; + } + + /** + * Performs a deep copy on other. + */ + public RemoteZeppelinServerController(RemoteZeppelinServerController other) { + if (other.isSetType()) { + this.type = other.type; + } + if (other.isSetEventOwnerKey()) { + this.eventOwnerKey = other.eventOwnerKey; + } + if (other.isSetMsg()) { + this.msg = other.msg; + } + } + + public RemoteZeppelinServerController deepCopy() { + return new RemoteZeppelinServerController(this); + } + + @Override + public void clear() { + this.type = null; + this.eventOwnerKey = null; + this.msg = null; + } + + /** + * + * @see RemoteZeppelinServerControlEvent + */ + public RemoteZeppelinServerControlEvent getType() { + return this.type; + } + + /** + * + * @see RemoteZeppelinServerControlEvent + */ + public RemoteZeppelinServerController setType(RemoteZeppelinServerControlEvent 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 getEventOwnerKey() { + return this.eventOwnerKey; + } + + public RemoteZeppelinServerController setEventOwnerKey(String eventOwnerKey) { + this.eventOwnerKey = eventOwnerKey; + return this; + } + + public void unsetEventOwnerKey() { + this.eventOwnerKey = null; + } + + /** Returns true if field eventOwnerKey is set (has been assigned a value) and false otherwise */ + public boolean isSetEventOwnerKey() { + return this.eventOwnerKey != null; + } + + public void setEventOwnerKeyIsSet(boolean value) { + if (!value) { + this.eventOwnerKey = null; + } + } + + public String getMsg() { + return this.msg; + } + + public RemoteZeppelinServerController 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 void setFieldValue(_Fields field, Object value) { + switch (field) { + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((RemoteZeppelinServerControlEvent)value); + } + break; + + case EVENT_OWNER_KEY: + if (value == null) { + unsetEventOwnerKey(); + } else { + setEventOwnerKey((String)value); + } + break; + + case MSG: + if (value == null) { + unsetMsg(); + } else { + setMsg((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TYPE: + return getType(); + + case EVENT_OWNER_KEY: + return getEventOwnerKey(); + + case MSG: + return getMsg(); + + } + 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 TYPE: + return isSetType(); + case EVENT_OWNER_KEY: + return isSetEventOwnerKey(); + case MSG: + return isSetMsg(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof RemoteZeppelinServerController) + return this.equals((RemoteZeppelinServerController)that); + return false; + } + + public boolean equals(RemoteZeppelinServerController that) { + if (that == null) + 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_eventOwnerKey = true && this.isSetEventOwnerKey(); + boolean that_present_eventOwnerKey = true && that.isSetEventOwnerKey(); + if (this_present_eventOwnerKey || that_present_eventOwnerKey) { + if (!(this_present_eventOwnerKey && that_present_eventOwnerKey)) + return false; + if (!this.eventOwnerKey.equals(that.eventOwnerKey)) + 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; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_type = true && (isSetType()); + list.add(present_type); + if (present_type) + list.add(type.getValue()); + + boolean present_eventOwnerKey = true && (isSetEventOwnerKey()); + list.add(present_eventOwnerKey); + if (present_eventOwnerKey) + list.add(eventOwnerKey); + + boolean present_msg = true && (isSetMsg()); + list.add(present_msg); + if (present_msg) + list.add(msg); + + return list.hashCode(); + } + + @Override + public int compareTo(RemoteZeppelinServerController other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEventOwnerKey()).compareTo(other.isSetEventOwnerKey()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEventOwnerKey()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventOwnerKey, other.eventOwnerKey); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMsg()).compareTo(other.isSetMsg()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMsg()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, other.msg); + 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("RemoteZeppelinServerController("); + boolean first = true; + + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; + if (!first) sb.append(", "); + sb.append("eventOwnerKey:"); + if (this.eventOwnerKey == null) { + sb.append("null"); + } else { + sb.append(this.eventOwnerKey); + } + first = false; + if (!first) sb.append(", "); + sb.append("msg:"); + if (this.msg == null) { + sb.append("null"); + } else { + sb.append(this.msg); + } + 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 RemoteZeppelinServerControllerStandardSchemeFactory implements SchemeFactory { + public RemoteZeppelinServerControllerStandardScheme getScheme() { + return new RemoteZeppelinServerControllerStandardScheme(); + } + } + + private static class RemoteZeppelinServerControllerStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, RemoteZeppelinServerController 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: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent.findByValue(iprot.readI32()); + struct.setTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // EVENT_OWNER_KEY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.eventOwnerKey = iprot.readString(); + struct.setEventOwnerKeyIsSet(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; + 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, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.type != null) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeI32(struct.type.getValue()); + oprot.writeFieldEnd(); + } + if (struct.eventOwnerKey != null) { + oprot.writeFieldBegin(EVENT_OWNER_KEY_FIELD_DESC); + oprot.writeString(struct.eventOwnerKey); + oprot.writeFieldEnd(); + } + if (struct.msg != null) { + oprot.writeFieldBegin(MSG_FIELD_DESC); + oprot.writeString(struct.msg); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class RemoteZeppelinServerControllerTupleSchemeFactory implements SchemeFactory { + public RemoteZeppelinServerControllerTupleScheme getScheme() { + return new RemoteZeppelinServerControllerTupleScheme(); + } + } + + private static class RemoteZeppelinServerControllerTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetType()) { + optionals.set(0); + } + if (struct.isSetEventOwnerKey()) { + optionals.set(1); + } + if (struct.isSetMsg()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetType()) { + oprot.writeI32(struct.type.getValue()); + } + if (struct.isSetEventOwnerKey()) { + oprot.writeString(struct.eventOwnerKey); + } + if (struct.isSetMsg()) { + oprot.writeString(struct.msg); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent.findByValue(iprot.readI32()); + struct.setTypeIsSet(true); + } + if (incoming.get(1)) { + struct.eventOwnerKey = iprot.readString(); + struct.setEventOwnerKeyIsSet(true); + } + if (incoming.get(2)) { + struct.msg = iprot.readString(); + struct.setMsgIsSet(true); + } + } + } + +} + diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java new file mode 100644 index 00000000000..114b6864d17 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java @@ -0,0 +1,59 @@ +/** + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.zeppelin.interpreter.thrift; + + +import java.util.Map; +import java.util.HashMap; +import org.apache.thrift.TEnum; + +public enum RemoteZeppelinServerResourceType implements org.apache.thrift.TEnum { + RESOURCE_PARAGRAPH_RUN_CONTEXT(1); + + private final int value; + + private RemoteZeppelinServerResourceType(int value) { + this.value = value; + } + + /** + * Get the integer value of this enum value, as defined in the Thrift IDL. + */ + public int getValue() { + return value; + } + + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static RemoteZeppelinServerResourceType findByValue(int value) { + switch (value) { + case 1: + return RESOURCE_PARAGRAPH_RUN_CONTEXT; + default: + return null; + } + } +} diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java new file mode 100644 index 00000000000..f841f60ab40 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java @@ -0,0 +1,641 @@ +/** + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * 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 org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +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 javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +public class ZeppelinServerResource implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResource"); + + private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)1); + private static final org.apache.thrift.protocol.TField EVENT_OWNER_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("eventOwnerKey", 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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new ZeppelinServerResourceStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ZeppelinServerResourceTupleSchemeFactory()); + } + + /** + * + * @see RemoteZeppelinServerResourceType + */ + public RemoteZeppelinServerResourceType type; // required + public String eventOwnerKey; // required + public String msg; // 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 { + /** + * + * @see RemoteZeppelinServerResourceType + */ + TYPE((short)1, "type"), + EVENT_OWNER_KEY((short)2, "eventOwnerKey"), + MSG((short)3, "msg"); + + private static final Map byName = new HashMap(); + + 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: // TYPE + return TYPE; + case 2: // EVENT_OWNER_KEY + return EVENT_OWNER_KEY; + case 3: // MSG + return MSG; + 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.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, RemoteZeppelinServerResourceType.class))); + tmpMap.put(_Fields.EVENT_OWNER_KEY, new org.apache.thrift.meta_data.FieldMetaData("eventOwnerKey", 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))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ZeppelinServerResource.class, metaDataMap); + } + + public ZeppelinServerResource() { + } + + public ZeppelinServerResource( + RemoteZeppelinServerResourceType type, + String eventOwnerKey, + String msg) + { + this(); + this.type = type; + this.eventOwnerKey = eventOwnerKey; + this.msg = msg; + } + + /** + * Performs a deep copy on other. + */ + public ZeppelinServerResource(ZeppelinServerResource other) { + if (other.isSetType()) { + this.type = other.type; + } + if (other.isSetEventOwnerKey()) { + this.eventOwnerKey = other.eventOwnerKey; + } + if (other.isSetMsg()) { + this.msg = other.msg; + } + } + + public ZeppelinServerResource deepCopy() { + return new ZeppelinServerResource(this); + } + + @Override + public void clear() { + this.type = null; + this.eventOwnerKey = null; + this.msg = null; + } + + /** + * + * @see RemoteZeppelinServerResourceType + */ + public RemoteZeppelinServerResourceType getType() { + return this.type; + } + + /** + * + * @see RemoteZeppelinServerResourceType + */ + public ZeppelinServerResource setType(RemoteZeppelinServerResourceType 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 getEventOwnerKey() { + return this.eventOwnerKey; + } + + public ZeppelinServerResource setEventOwnerKey(String eventOwnerKey) { + this.eventOwnerKey = eventOwnerKey; + return this; + } + + public void unsetEventOwnerKey() { + this.eventOwnerKey = null; + } + + /** Returns true if field eventOwnerKey is set (has been assigned a value) and false otherwise */ + public boolean isSetEventOwnerKey() { + return this.eventOwnerKey != null; + } + + public void setEventOwnerKeyIsSet(boolean value) { + if (!value) { + this.eventOwnerKey = null; + } + } + + public String getMsg() { + return this.msg; + } + + public ZeppelinServerResource 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 void setFieldValue(_Fields field, Object value) { + switch (field) { + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((RemoteZeppelinServerResourceType)value); + } + break; + + case EVENT_OWNER_KEY: + if (value == null) { + unsetEventOwnerKey(); + } else { + setEventOwnerKey((String)value); + } + break; + + case MSG: + if (value == null) { + unsetMsg(); + } else { + setMsg((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TYPE: + return getType(); + + case EVENT_OWNER_KEY: + return getEventOwnerKey(); + + case MSG: + return getMsg(); + + } + 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 TYPE: + return isSetType(); + case EVENT_OWNER_KEY: + return isSetEventOwnerKey(); + case MSG: + return isSetMsg(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ZeppelinServerResource) + return this.equals((ZeppelinServerResource)that); + return false; + } + + public boolean equals(ZeppelinServerResource that) { + if (that == null) + 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_eventOwnerKey = true && this.isSetEventOwnerKey(); + boolean that_present_eventOwnerKey = true && that.isSetEventOwnerKey(); + if (this_present_eventOwnerKey || that_present_eventOwnerKey) { + if (!(this_present_eventOwnerKey && that_present_eventOwnerKey)) + return false; + if (!this.eventOwnerKey.equals(that.eventOwnerKey)) + 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; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_type = true && (isSetType()); + list.add(present_type); + if (present_type) + list.add(type.getValue()); + + boolean present_eventOwnerKey = true && (isSetEventOwnerKey()); + list.add(present_eventOwnerKey); + if (present_eventOwnerKey) + list.add(eventOwnerKey); + + boolean present_msg = true && (isSetMsg()); + list.add(present_msg); + if (present_msg) + list.add(msg); + + return list.hashCode(); + } + + @Override + public int compareTo(ZeppelinServerResource other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEventOwnerKey()).compareTo(other.isSetEventOwnerKey()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEventOwnerKey()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventOwnerKey, other.eventOwnerKey); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMsg()).compareTo(other.isSetMsg()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMsg()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, other.msg); + 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("ZeppelinServerResource("); + boolean first = true; + + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; + if (!first) sb.append(", "); + sb.append("eventOwnerKey:"); + if (this.eventOwnerKey == null) { + sb.append("null"); + } else { + sb.append(this.eventOwnerKey); + } + first = false; + if (!first) sb.append(", "); + sb.append("msg:"); + if (this.msg == null) { + sb.append("null"); + } else { + sb.append(this.msg); + } + 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 ZeppelinServerResourceStandardSchemeFactory implements SchemeFactory { + public ZeppelinServerResourceStandardScheme getScheme() { + return new ZeppelinServerResourceStandardScheme(); + } + } + + private static class ZeppelinServerResourceStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ZeppelinServerResource 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: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerResourceType.findByValue(iprot.readI32()); + struct.setTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // EVENT_OWNER_KEY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.eventOwnerKey = iprot.readString(); + struct.setEventOwnerKeyIsSet(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; + 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, ZeppelinServerResource struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.type != null) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeI32(struct.type.getValue()); + oprot.writeFieldEnd(); + } + if (struct.eventOwnerKey != null) { + oprot.writeFieldBegin(EVENT_OWNER_KEY_FIELD_DESC); + oprot.writeString(struct.eventOwnerKey); + oprot.writeFieldEnd(); + } + if (struct.msg != null) { + oprot.writeFieldBegin(MSG_FIELD_DESC); + oprot.writeString(struct.msg); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ZeppelinServerResourceTupleSchemeFactory implements SchemeFactory { + public ZeppelinServerResourceTupleScheme getScheme() { + return new ZeppelinServerResourceTupleScheme(); + } + } + + private static class ZeppelinServerResourceTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResource struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetType()) { + optionals.set(0); + } + if (struct.isSetEventOwnerKey()) { + optionals.set(1); + } + if (struct.isSetMsg()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetType()) { + oprot.writeI32(struct.type.getValue()); + } + if (struct.isSetEventOwnerKey()) { + oprot.writeString(struct.eventOwnerKey); + } + if (struct.isSetMsg()) { + oprot.writeString(struct.msg); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResource struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerResourceType.findByValue(iprot.readI32()); + struct.setTypeIsSet(true); + } + if (incoming.get(1)) { + struct.eventOwnerKey = iprot.readString(); + struct.setEventOwnerKeyIsSet(true); + } + if (incoming.get(2)) { + struct.msg = iprot.readString(); + struct.setMsgIsSet(true); + } + } + } + +} + diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java new file mode 100644 index 00000000000..bac6d812546 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java @@ -0,0 +1,625 @@ +/** + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * 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 org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +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 javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResourceParagraphRunner"); + + private static final org.apache.thrift.protocol.TField NOTE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("noteId", org.apache.thrift.protocol.TType.STRING, (short)1); + 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)2); + private static final org.apache.thrift.protocol.TField RUNNERS_FIELD_DESC = new org.apache.thrift.protocol.TField("runners", org.apache.thrift.protocol.TType.STRING, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new ZeppelinServerResourceParagraphRunnerStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ZeppelinServerResourceParagraphRunnerTupleSchemeFactory()); + } + + public String noteId; // required + public String paragraphId; // required + public String runners; // 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 { + NOTE_ID((short)1, "noteId"), + PARAGRAPH_ID((short)2, "paragraphId"), + RUNNERS((short)3, "runners"); + + private static final Map byName = new HashMap(); + + 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: // NOTE_ID + return NOTE_ID; + case 2: // PARAGRAPH_ID + return PARAGRAPH_ID; + case 3: // RUNNERS + return RUNNERS; + 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.NOTE_ID, new org.apache.thrift.meta_data.FieldMetaData("noteId", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + 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.RUNNERS, new org.apache.thrift.meta_data.FieldMetaData("runners", 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(ZeppelinServerResourceParagraphRunner.class, metaDataMap); + } + + public ZeppelinServerResourceParagraphRunner() { + } + + public ZeppelinServerResourceParagraphRunner( + String noteId, + String paragraphId, + String runners) + { + this(); + this.noteId = noteId; + this.paragraphId = paragraphId; + this.runners = runners; + } + + /** + * Performs a deep copy on other. + */ + public ZeppelinServerResourceParagraphRunner(ZeppelinServerResourceParagraphRunner other) { + if (other.isSetNoteId()) { + this.noteId = other.noteId; + } + if (other.isSetParagraphId()) { + this.paragraphId = other.paragraphId; + } + if (other.isSetRunners()) { + this.runners = other.runners; + } + } + + public ZeppelinServerResourceParagraphRunner deepCopy() { + return new ZeppelinServerResourceParagraphRunner(this); + } + + @Override + public void clear() { + this.noteId = null; + this.paragraphId = null; + this.runners = null; + } + + public String getNoteId() { + return this.noteId; + } + + public ZeppelinServerResourceParagraphRunner setNoteId(String noteId) { + this.noteId = noteId; + return this; + } + + public void unsetNoteId() { + this.noteId = null; + } + + /** Returns true if field noteId is set (has been assigned a value) and false otherwise */ + public boolean isSetNoteId() { + return this.noteId != null; + } + + public void setNoteIdIsSet(boolean value) { + if (!value) { + this.noteId = null; + } + } + + public String getParagraphId() { + return this.paragraphId; + } + + public ZeppelinServerResourceParagraphRunner 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 getRunners() { + return this.runners; + } + + public ZeppelinServerResourceParagraphRunner setRunners(String runners) { + this.runners = runners; + return this; + } + + public void unsetRunners() { + this.runners = null; + } + + /** Returns true if field runners is set (has been assigned a value) and false otherwise */ + public boolean isSetRunners() { + return this.runners != null; + } + + public void setRunnersIsSet(boolean value) { + if (!value) { + this.runners = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NOTE_ID: + if (value == null) { + unsetNoteId(); + } else { + setNoteId((String)value); + } + break; + + case PARAGRAPH_ID: + if (value == null) { + unsetParagraphId(); + } else { + setParagraphId((String)value); + } + break; + + case RUNNERS: + if (value == null) { + unsetRunners(); + } else { + setRunners((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NOTE_ID: + return getNoteId(); + + case PARAGRAPH_ID: + return getParagraphId(); + + case RUNNERS: + return getRunners(); + + } + 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 NOTE_ID: + return isSetNoteId(); + case PARAGRAPH_ID: + return isSetParagraphId(); + case RUNNERS: + return isSetRunners(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ZeppelinServerResourceParagraphRunner) + return this.equals((ZeppelinServerResourceParagraphRunner)that); + return false; + } + + public boolean equals(ZeppelinServerResourceParagraphRunner that) { + if (that == null) + return false; + + boolean this_present_noteId = true && this.isSetNoteId(); + boolean that_present_noteId = true && that.isSetNoteId(); + if (this_present_noteId || that_present_noteId) { + if (!(this_present_noteId && that_present_noteId)) + return false; + if (!this.noteId.equals(that.noteId)) + 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_runners = true && this.isSetRunners(); + boolean that_present_runners = true && that.isSetRunners(); + if (this_present_runners || that_present_runners) { + if (!(this_present_runners && that_present_runners)) + return false; + if (!this.runners.equals(that.runners)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_noteId = true && (isSetNoteId()); + list.add(present_noteId); + if (present_noteId) + list.add(noteId); + + boolean present_paragraphId = true && (isSetParagraphId()); + list.add(present_paragraphId); + if (present_paragraphId) + list.add(paragraphId); + + boolean present_runners = true && (isSetRunners()); + list.add(present_runners); + if (present_runners) + list.add(runners); + + return list.hashCode(); + } + + @Override + public int compareTo(ZeppelinServerResourceParagraphRunner other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetNoteId()).compareTo(other.isSetNoteId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNoteId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.noteId, other.noteId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetParagraphId()).compareTo(other.isSetParagraphId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParagraphId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paragraphId, other.paragraphId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetRunners()).compareTo(other.isSetRunners()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRunners()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.runners, other.runners); + 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("ZeppelinServerResourceParagraphRunner("); + boolean first = true; + + sb.append("noteId:"); + if (this.noteId == null) { + sb.append("null"); + } else { + sb.append(this.noteId); + } + first = false; + if (!first) sb.append(", "); + sb.append("paragraphId:"); + if (this.paragraphId == null) { + sb.append("null"); + } else { + sb.append(this.paragraphId); + } + first = false; + if (!first) sb.append(", "); + sb.append("runners:"); + if (this.runners == null) { + sb.append("null"); + } else { + sb.append(this.runners); + } + 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 ZeppelinServerResourceParagraphRunnerStandardSchemeFactory implements SchemeFactory { + public ZeppelinServerResourceParagraphRunnerStandardScheme getScheme() { + return new ZeppelinServerResourceParagraphRunnerStandardScheme(); + } + } + + private static class ZeppelinServerResourceParagraphRunnerStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ZeppelinServerResourceParagraphRunner 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: // NOTE_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.noteId = iprot.readString(); + struct.setNoteIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // 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 3: // RUNNERS + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.runners = iprot.readString(); + struct.setRunnersIsSet(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, ZeppelinServerResourceParagraphRunner struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.noteId != null) { + oprot.writeFieldBegin(NOTE_ID_FIELD_DESC); + oprot.writeString(struct.noteId); + oprot.writeFieldEnd(); + } + if (struct.paragraphId != null) { + oprot.writeFieldBegin(PARAGRAPH_ID_FIELD_DESC); + oprot.writeString(struct.paragraphId); + oprot.writeFieldEnd(); + } + if (struct.runners != null) { + oprot.writeFieldBegin(RUNNERS_FIELD_DESC); + oprot.writeString(struct.runners); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ZeppelinServerResourceParagraphRunnerTupleSchemeFactory implements SchemeFactory { + public ZeppelinServerResourceParagraphRunnerTupleScheme getScheme() { + return new ZeppelinServerResourceParagraphRunnerTupleScheme(); + } + } + + private static class ZeppelinServerResourceParagraphRunnerTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResourceParagraphRunner struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetNoteId()) { + optionals.set(0); + } + if (struct.isSetParagraphId()) { + optionals.set(1); + } + if (struct.isSetRunners()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetNoteId()) { + oprot.writeString(struct.noteId); + } + if (struct.isSetParagraphId()) { + oprot.writeString(struct.paragraphId); + } + if (struct.isSetRunners()) { + oprot.writeString(struct.runners); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResourceParagraphRunner struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.noteId = iprot.readString(); + struct.setNoteIdIsSet(true); + } + if (incoming.get(1)) { + struct.paragraphId = iprot.readString(); + struct.setParagraphIdIsSet(true); + } + if (incoming.get(2)) { + struct.runners = iprot.readString(); + struct.setRunnersIsSet(true); + } + } + } + +} + diff --git a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift index 32be4a4a0a8..7a88b98c307 100644 --- a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift +++ b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift @@ -50,8 +50,10 @@ enum RemoteInterpreterEventType { OUTPUT_UPDATE = 9, ANGULAR_REGISTRY_PUSH = 10, APP_STATUS_UPDATE = 11, + REMOTE_ZEPPELIN_SERVER_CONTROL = 12 } + struct RemoteInterpreterEvent { 1: RemoteInterpreterEventType type, 2: string data // json serialized data @@ -62,6 +64,37 @@ struct RemoteApplicationResult { 2: string msg } +/* + cloverhearts + remote interpreter process --> request --> zeppelin server + */ +enum RemoteZeppelinServerControlEvent { + REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT = 1, + RES_RESOURCE_PARAGRAPH_RUN_CONTEXT = 2 +} + +enum RemoteZeppelinServerResourceType { + RESOURCE_PARAGRAPH_RUN_CONTEXT = 1 +} + +struct ZeppelinServerResourceParagraphRunner { + 1: string noteId, + 2: string paragraphId, + 3: string runners +} + +struct ZeppelinServerResource { + 1: RemoteZeppelinServerResourceType type, + 2: string eventOwnerKey, + 3: string msg +} + +struct RemoteZeppelinServerController { + 1: RemoteZeppelinServerControlEvent type, + 2: string eventOwnerKey + 3: string msg +} + /* * The below variables(name, value) will be connected to getCompletions in paragraph.controller.js * @@ -109,4 +142,6 @@ service RemoteInterpreterService { RemoteApplicationResult loadApplication(1: string applicationInstanceId, 2: string packageInfo, 3: string noteId, 4: string paragraphId); RemoteApplicationResult unloadApplication(1: string applicationInstanceId); RemoteApplicationResult runApplication(1: string applicationInstanceId); + + void remoteZeppelinServerControlFeedback(1: RemoteZeppelinServerController response); } From 0570ae804b8c39e0b2e74c23ad13c57ee4c5a213 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Mon, 14 Nov 2016 21:22:51 +0900 Subject: [PATCH 02/23] add remote works controller class and include interpreter factory --- .../zeppelin/spark/ZeppelinContext.java | 13 ++ .../interpreter/RemoteWorksController.java | 29 +++++ .../interpreter/remote/RemoteInterpreter.java | 17 ++- .../remote/RemoteInterpreterEventClient.java | 1 + .../remote/RemoteInterpreterEventPoller.java | 40 +++++- .../RemoteInterpreterManagedProcess.java | 9 +- .../remote/RemoteInterpreterProcess.java | 6 +- .../RemoteInterpreterRunningProcess.java | 4 +- .../remote/RemoteInterpreterServer.java | 12 +- .../thrift/InterpreterCompletion.java | 2 +- .../thrift/RemoteApplicationResult.java | 2 +- .../thrift/RemoteInterpreterContext.java | 2 +- .../thrift/RemoteInterpreterEvent.java | 2 +- .../thrift/RemoteInterpreterResult.java | 2 +- .../thrift/RemoteInterpreterService.java | 2 +- .../RemoteZeppelinServerController.java | 2 +- .../thrift/ZeppelinServerResource.java | 2 +- ...ZeppelinServerResourceParagraphRunner.java | 115 +----------------- .../thrift/RemoteInterpreterService.thrift | 3 +- .../remote/RemoteAngularObjectTest.java | 1 + .../RemoteInterpreterOutputTestStream.java | 1 + .../remote/RemoteInterpreterProcessTest.java | 2 +- .../remote/RemoteInterpreterTest.java | 8 +- .../resource/DistributedResourcePoolTest.java | 6 +- .../scheduler/RemoteSchedulerTest.java | 2 + .../zeppelin/server/ZeppelinServer.java | 5 + .../interpreter/InterpreterFactory.java | 15 ++- .../apache/zeppelin/notebook/Paragraph.java | 5 + .../remoteworks/RemoteWorksManager.java | 100 +++++++++++++++ 29 files changed, 269 insertions(+), 141 deletions(-) create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java create mode 100644 zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java diff --git a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java index ff21c7a2f2d..e29dc9407eb 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java @@ -328,6 +328,19 @@ public void run(String id, InterpreterContext context) { throw new InterpreterException("Paragraph " + id + " not found"); } + /** + * get Zeppelin Paragraph Runner from zeppelin server + */ + @ZeppelinApi + public List getInterpreterContextRunner( + String noteId, String paragraphId) { + List runners = new LinkedList<>(); + + + + return runners; + } + /** * Run paragraph at idx * @param idx diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java new file mode 100644 index 00000000000..e6c6ca552cf --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java @@ -0,0 +1,29 @@ +/* + * 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; + +import java.util.List; + +/** + * zeppelin job for Remote works controller by interpreter + * + */ +public interface RemoteWorksController { + List getRunner(String noteId); + InterpreterContextRunner getRunner(String noteId, String paragraphId); +} 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 index 0ce7921de4a..cf1256f0be8 100644 --- 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 @@ -45,6 +45,7 @@ public class RemoteInterpreter extends Interpreter { private final RemoteInterpreterProcessListener remoteInterpreterProcessListener; private final ApplicationEventListener applicationEventListener; + private final RemoteWorksController remoteWorksController; Logger logger = LoggerFactory.getLogger(RemoteInterpreter.class); Gson gson = new Gson(); private String interpreterRunner; @@ -72,7 +73,8 @@ public RemoteInterpreter(Properties property, int connectTimeout, int maxPoolSize, RemoteInterpreterProcessListener remoteInterpreterProcessListener, - ApplicationEventListener appListener) { + ApplicationEventListener appListener, + RemoteWorksController remoteWorksController) { super(property); this.noteId = noteId; this.className = className; @@ -85,6 +87,7 @@ public RemoteInterpreter(Properties property, this.maxPoolSize = maxPoolSize; this.remoteInterpreterProcessListener = remoteInterpreterProcessListener; this.applicationEventListener = appListener; + this.remoteWorksController = remoteWorksController; } @@ -100,7 +103,8 @@ public RemoteInterpreter( int connectTimeout, int maxPoolSize, RemoteInterpreterProcessListener remoteInterpreterProcessListener, - ApplicationEventListener appListener) { + ApplicationEventListener appListener, + RemoteWorksController remoteWorksController) { super(property); this.noteId = noteId; this.className = className; @@ -111,6 +115,7 @@ public RemoteInterpreter( this.maxPoolSize = maxPoolSize; this.remoteInterpreterProcessListener = remoteInterpreterProcessListener; this.applicationEventListener = appListener; + this.remoteWorksController = remoteWorksController; } @@ -125,7 +130,8 @@ public RemoteInterpreter( Map env, int connectTimeout, RemoteInterpreterProcessListener remoteInterpreterProcessListener, - ApplicationEventListener appListener) { + ApplicationEventListener appListener, + RemoteWorksController remoteWorksController) { super(property); this.className = className; this.noteId = noteId; @@ -138,6 +144,7 @@ public RemoteInterpreter( this.maxPoolSize = 10; this.remoteInterpreterProcessListener = remoteInterpreterProcessListener; this.applicationEventListener = appListener; + this.remoteWorksController = remoteWorksController; } private Map getEnvFromInterpreterProperty(Properties property) { @@ -181,13 +188,15 @@ public RemoteInterpreterProcess getInterpreterProcess() { connectTimeout, remoteInterpreterProcessListener, applicationEventListener, + remoteWorksController, host, port); } else { // create new remote process remoteProcess = new RemoteInterpreterManagedProcess( interpreterRunner, interpreterPath, localRepoPath, env, connectTimeout, - remoteInterpreterProcessListener, applicationEventListener); + remoteInterpreterProcessListener, applicationEventListener, + remoteWorksController); } intpGroup.setRemoteInterpreterProcess(remoteProcess); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java index 819331e81da..323340b7436 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java @@ -61,6 +61,7 @@ public void getZeppelinServerNoteRunner( RemoteZeppelinServerController eventBody = new RemoteZeppelinServerController(); eventBody.setType(RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT); eventBody.setEventOwnerKey(eventOwnerKey); + logger.info("clover gson.toJson(runner) - " + gson.toJson(runner)); eventBody.setMsg(gson.toJson(runner)); sendEvent(new RemoteInterpreterEvent( diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index effc7ea4e98..1226a95c841 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -25,6 +25,7 @@ import org.apache.zeppelin.helium.ApplicationEventListener; import org.apache.zeppelin.interpreter.InterpreterContextRunner; import org.apache.zeppelin.interpreter.InterpreterGroup; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; @@ -61,12 +62,15 @@ public class RemoteInterpreterEventPoller extends Thread { private RemoteInterpreterProcess interpreterProcess; private InterpreterGroup interpreterGroup; + private RemoteWorksController remoteWorkController; public RemoteInterpreterEventPoller( RemoteInterpreterProcessListener listener, - ApplicationEventListener appListener) { + ApplicationEventListener appListener, + RemoteWorksController remoteWorkController) { this.listener = listener; this.appListener = appListener; + this.remoteWorkController = remoteWorkController; shutdown = false; } @@ -78,6 +82,14 @@ public void setInterpreterGroup(InterpreterGroup interpreterGroup) { this.interpreterGroup = interpreterGroup; } + public RemoteWorksController getRemoteWorkController() { + return remoteWorkController; + } + + public void setRemoteWorkController(RemoteWorksController remoteWorkController) { + this.remoteWorkController = remoteWorkController; + } + @Override public void run() { Client client = null; @@ -223,15 +235,37 @@ private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController e boolean broken = false; try { interpreterServer = interpreterProcess.getClient(); - + List interpreterContextRunners = new LinkedList<>(); + List remoteRunners = new LinkedList<>(); if (event.getType() == RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT) { ZeppelinServerResourceParagraphRunner runner = gson.fromJson( event.getMsg(), ZeppelinServerResourceParagraphRunner.class); + logger.info("clover req note id {} p id {} - msg {}", + runner.getNoteId(), runner.getParagraphId(), event.getMsg()); RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); resResource.setEventOwnerKey(eventOwnerKey); - resResource.setMsg("test123123"); + if (runner.getParagraphId() != null) { + InterpreterContextRunner intpRunner = remoteWorkController.getRunner( + runner.getNoteId(), runner.getParagraphId()); + interpreterContextRunners.add(intpRunner); + } else { + interpreterContextRunners = remoteWorkController.getRunner(runner.getNoteId()); + } + + logger.info("clover remotework count 1 {}", interpreterContextRunners.size()); + + for (InterpreterContextRunner r : interpreterContextRunners) { + remoteRunners.add( + new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) + ); + } + + logger.info("clover remotework count 2 {}", remoteRunners.size()); + + resResource.setMsg(gson.toJson(remoteRunners)); + interpreterServer.remoteZeppelinServerControlFeedback(resResource); logger.info("get runner noteid {} paragraphid {}", runner.getNoteId(), runner.getParagraphId()); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java index ddab105570b..b77689f1803 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java @@ -21,6 +21,7 @@ import org.apache.commons.exec.environment.EnvironmentUtils; import org.apache.zeppelin.helium.ApplicationEventListener; import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -43,6 +44,7 @@ public class RemoteInterpreterManagedProcess extends RemoteInterpreterProcess private int port = -1; private final String interpreterDir; private final String localRepoDir; + private RemoteWorksController remoteWorksController; private Map env; @@ -53,13 +55,15 @@ public RemoteInterpreterManagedProcess( Map env, int connectTimeout, RemoteInterpreterProcessListener listener, - ApplicationEventListener appListener) { - super(new RemoteInterpreterEventPoller(listener, appListener), + ApplicationEventListener appListener, + RemoteWorksController remoteWorksController) { + super(new RemoteInterpreterEventPoller(listener, appListener, remoteWorksController), connectTimeout); this.interpreterRunner = intpRunner; this.env = env; this.interpreterDir = intpDir; this.localRepoDir = localRepoDir; + this.remoteWorksController = remoteWorksController; } @@ -75,6 +79,7 @@ public RemoteInterpreterManagedProcess( this.env = env; this.interpreterDir = intpDir; this.localRepoDir = localRepoDir; + this.remoteWorksController = remoteInterpreterEventPoller.getRemoteWorkController(); } @Override 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 index 62727bcee6b..17247c1c99a 100644 --- 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 @@ -24,6 +24,7 @@ import org.apache.zeppelin.interpreter.Constants; import org.apache.zeppelin.interpreter.InterpreterException; import org.apache.zeppelin.interpreter.InterpreterGroup; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,8 +49,9 @@ public abstract class RemoteInterpreterProcess { public RemoteInterpreterProcess( int connectTimeout, RemoteInterpreterProcessListener listener, - ApplicationEventListener appListener) { - this(new RemoteInterpreterEventPoller(listener, appListener), + ApplicationEventListener appListener, + RemoteWorksController remoteWorksController) { + this(new RemoteInterpreterEventPoller(listener, appListener, remoteWorksController), connectTimeout); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java index 42e6250e3ca..570a128d348 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java @@ -17,6 +17,7 @@ package org.apache.zeppelin.interpreter.remote; import org.apache.zeppelin.helium.ApplicationEventListener; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -32,10 +33,11 @@ public RemoteInterpreterRunningProcess( int connectTimeout, RemoteInterpreterProcessListener listener, ApplicationEventListener appListener, + RemoteWorksController remoteWorksController, String host, int port ) { - super(connectTimeout, listener, appListener); + super(connectTimeout, listener, appListener, remoteWorksController); this.host = host; this.port = port; } 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 index d26f35e7ac1..9f807aba86a 100644 --- 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 @@ -341,6 +341,14 @@ public void remoteZeppelinServerControlFeedback( RemoteZeppelinServerController response) throws TException { logger.info("clover remote zeppelin server controller feedback {}", response); logger.info("clover remote zeppelin server conteroller body {}", response.getMsg()); + + if (response.getType() == RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT) { + List runners = gson.fromJson(response.getMsg(), + new TypeToken>() {}.getType()); + for (ZeppelinServerResourceParagraphRunner r : runners) { + logger.info("clover runner nid {} pid {}", r.getNoteId(), r.getParagraphId()); + } + } } class InterpretJobListener implements JobListener { @@ -592,8 +600,8 @@ public ParagraphRunner(RemoteInterpreterServer server, String noteId, String par @Override public void run() { ZeppelinServerResourceParagraphRunner test = new ZeppelinServerResourceParagraphRunner(); - test.setNoteId("TEST NOTE"); - test.setParagraphId("TEST PARAGRAPH"); + test.setNoteId(getNoteId()); + test.setParagraphId(getParagraphId()); server.eventClient.getZeppelinServerNoteRunner("IamOWNER", test); server.eventClient.run(this); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java index 7dadd4f23d7..d122ae5083c 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class InterpreterCompletion implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InterpreterCompletion"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java index 75a2a78338e..b7568218377 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class RemoteApplicationResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteApplicationResult"); 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 index d0b2ecedb82..cd9cc46f544 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class RemoteInterpreterContext implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java index f235c28d46a..de56431f505 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class RemoteInterpreterEvent implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterEvent"); 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 index e034086a5ee..289b6fc8f49 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class RemoteInterpreterResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java index 814da9f2581..5793c010368 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class RemoteInterpreterService { public interface Iface { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java index 9b3e6d65f44..1cb80116b1c 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class RemoteZeppelinServerController implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteZeppelinServerController"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java index f841f60ab40..60c5927e497 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class ZeppelinServerResource implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResource"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java index bac6d812546..88e75b35c28 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java @@ -51,13 +51,12 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-11") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResourceParagraphRunner"); private static final org.apache.thrift.protocol.TField NOTE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("noteId", org.apache.thrift.protocol.TType.STRING, (short)1); 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)2); - private static final org.apache.thrift.protocol.TField RUNNERS_FIELD_DESC = new org.apache.thrift.protocol.TField("runners", org.apache.thrift.protocol.TType.STRING, (short)3); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -67,13 +66,11 @@ public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift. public String noteId; // required public String paragraphId; // required - public String runners; // 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 { NOTE_ID((short)1, "noteId"), - PARAGRAPH_ID((short)2, "paragraphId"), - RUNNERS((short)3, "runners"); + PARAGRAPH_ID((short)2, "paragraphId"); private static final Map byName = new HashMap(); @@ -92,8 +89,6 @@ public static _Fields findByThriftId(int fieldId) { return NOTE_ID; case 2: // PARAGRAPH_ID return PARAGRAPH_ID; - case 3: // RUNNERS - return RUNNERS; default: return null; } @@ -141,8 +136,6 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); 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.RUNNERS, new org.apache.thrift.meta_data.FieldMetaData("runners", 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(ZeppelinServerResourceParagraphRunner.class, metaDataMap); } @@ -152,13 +145,11 @@ public ZeppelinServerResourceParagraphRunner() { public ZeppelinServerResourceParagraphRunner( String noteId, - String paragraphId, - String runners) + String paragraphId) { this(); this.noteId = noteId; this.paragraphId = paragraphId; - this.runners = runners; } /** @@ -171,9 +162,6 @@ public ZeppelinServerResourceParagraphRunner(ZeppelinServerResourceParagraphRunn if (other.isSetParagraphId()) { this.paragraphId = other.paragraphId; } - if (other.isSetRunners()) { - this.runners = other.runners; - } } public ZeppelinServerResourceParagraphRunner deepCopy() { @@ -184,7 +172,6 @@ public ZeppelinServerResourceParagraphRunner deepCopy() { public void clear() { this.noteId = null; this.paragraphId = null; - this.runners = null; } public String getNoteId() { @@ -235,30 +222,6 @@ public void setParagraphIdIsSet(boolean value) { } } - public String getRunners() { - return this.runners; - } - - public ZeppelinServerResourceParagraphRunner setRunners(String runners) { - this.runners = runners; - return this; - } - - public void unsetRunners() { - this.runners = null; - } - - /** Returns true if field runners is set (has been assigned a value) and false otherwise */ - public boolean isSetRunners() { - return this.runners != null; - } - - public void setRunnersIsSet(boolean value) { - if (!value) { - this.runners = null; - } - } - public void setFieldValue(_Fields field, Object value) { switch (field) { case NOTE_ID: @@ -277,14 +240,6 @@ public void setFieldValue(_Fields field, Object value) { } break; - case RUNNERS: - if (value == null) { - unsetRunners(); - } else { - setRunners((String)value); - } - break; - } } @@ -296,9 +251,6 @@ public Object getFieldValue(_Fields field) { case PARAGRAPH_ID: return getParagraphId(); - case RUNNERS: - return getRunners(); - } throw new IllegalStateException(); } @@ -314,8 +266,6 @@ public boolean isSet(_Fields field) { return isSetNoteId(); case PARAGRAPH_ID: return isSetParagraphId(); - case RUNNERS: - return isSetRunners(); } throw new IllegalStateException(); } @@ -351,15 +301,6 @@ public boolean equals(ZeppelinServerResourceParagraphRunner that) { return false; } - boolean this_present_runners = true && this.isSetRunners(); - boolean that_present_runners = true && that.isSetRunners(); - if (this_present_runners || that_present_runners) { - if (!(this_present_runners && that_present_runners)) - return false; - if (!this.runners.equals(that.runners)) - return false; - } - return true; } @@ -377,11 +318,6 @@ public int hashCode() { if (present_paragraphId) list.add(paragraphId); - boolean present_runners = true && (isSetRunners()); - list.add(present_runners); - if (present_runners) - list.add(runners); - return list.hashCode(); } @@ -413,16 +349,6 @@ public int compareTo(ZeppelinServerResourceParagraphRunner other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetRunners()).compareTo(other.isSetRunners()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetRunners()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.runners, other.runners); - if (lastComparison != 0) { - return lastComparison; - } - } return 0; } @@ -458,14 +384,6 @@ public String toString() { sb.append(this.paragraphId); } first = false; - if (!first) sb.append(", "); - sb.append("runners:"); - if (this.runners == null) { - sb.append("null"); - } else { - sb.append(this.runners); - } - first = false; sb.append(")"); return sb.toString(); } @@ -525,14 +443,6 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, ZeppelinServerResou org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 3: // RUNNERS - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.runners = iprot.readString(); - struct.setRunnersIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -558,11 +468,6 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, ZeppelinServerReso oprot.writeString(struct.paragraphId); oprot.writeFieldEnd(); } - if (struct.runners != null) { - oprot.writeFieldBegin(RUNNERS_FIELD_DESC); - oprot.writeString(struct.runners); - oprot.writeFieldEnd(); - } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -587,25 +492,19 @@ public void write(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResou if (struct.isSetParagraphId()) { optionals.set(1); } - if (struct.isSetRunners()) { - optionals.set(2); - } - oprot.writeBitSet(optionals, 3); + oprot.writeBitSet(optionals, 2); if (struct.isSetNoteId()) { oprot.writeString(struct.noteId); } if (struct.isSetParagraphId()) { oprot.writeString(struct.paragraphId); } - if (struct.isSetRunners()) { - oprot.writeString(struct.runners); - } } @Override public void read(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResourceParagraphRunner struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { struct.noteId = iprot.readString(); struct.setNoteIdIsSet(true); @@ -614,10 +513,6 @@ public void read(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResour struct.paragraphId = iprot.readString(); struct.setParagraphIdIsSet(true); } - if (incoming.get(2)) { - struct.runners = iprot.readString(); - struct.setRunnersIsSet(true); - } } } diff --git a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift index 7a88b98c307..0cfd489e25f 100644 --- a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift +++ b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift @@ -79,8 +79,7 @@ enum RemoteZeppelinServerResourceType { struct ZeppelinServerResourceParagraphRunner { 1: string noteId, - 2: string paragraphId, - 3: string runners + 2: string paragraphId } struct ZeppelinServerResource { diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteAngularObjectTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteAngularObjectTest.java index c8f665031df..b78a484f86a 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteAngularObjectTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteAngularObjectTest.java @@ -74,6 +74,7 @@ public void setUp() throws Exception { env, 10 * 1000, null, + null, null ); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java index 2ba62c30172..fb6d25b352a 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java @@ -71,6 +71,7 @@ private RemoteInterpreter createMockInterpreter() { env, 10 * 1000, this, + null, null); intpGroup.get("note").add(intp); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java index 01582821308..74cd2b0cd94 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java @@ -43,7 +43,7 @@ public void testStartStop() { InterpreterGroup intpGroup = new InterpreterGroup(); RemoteInterpreterManagedProcess rip = new RemoteInterpreterManagedProcess( INTERPRETER_SCRIPT, "nonexists", "fakeRepo", new HashMap(), - 10 * 1000, null, null); + 10 * 1000, null, null, null); assertFalse(rip.isRunning()); assertEquals(0, rip.referenceCount()); assertEquals(1, rip.reference(intpGroup)); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterTest.java index bdb8edc04cd..d613be01d0a 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterTest.java @@ -90,6 +90,7 @@ private RemoteInterpreter createMockInterpreterA(Properties p, String noteId) { env, 10 * 1000, null, + null, null); } @@ -108,6 +109,7 @@ private RemoteInterpreter createMockInterpreterB(Properties p, String noteId) { env, 10 * 1000, null, + null, null); } @@ -207,6 +209,7 @@ public void testRemoteSchedulerSharing() throws TTransportException, IOException env, 10 * 1000, null, + null, null); @@ -223,6 +226,7 @@ public void testRemoteSchedulerSharing() throws TTransportException, IOException env, 10 * 1000, null, + null, null); intpGroup.get("note").add(intpB); @@ -687,7 +691,8 @@ public void should_push_local_angular_repo_to_remote() throws Exception { //Given final Client client = Mockito.mock(Client.class); final RemoteInterpreter intr = new RemoteInterpreter(new Properties(), "noteId", - MockInterpreterA.class.getName(), "runner", "path","localRepo", env, 10 * 1000, null, null); + MockInterpreterA.class.getName(), + "runner", "path","localRepo", env, 10 * 1000, null, null, null); final AngularObjectRegistry registry = new AngularObjectRegistry("spark", null); registry.add("name", "DuyHai DOAN", "nodeId", "paragraphId"); final InterpreterGroup interpreterGroup = new InterpreterGroup("groupId"); @@ -733,6 +738,7 @@ public void testEnvronmentAndPropertySet() { env, 10 * 1000, null, + null, null); intpGroup.put("note", new LinkedList()); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java index 4bd2681bf15..df96a0991f0 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java @@ -70,6 +70,7 @@ public void setUp() throws Exception { env, 10 * 1000, null, + null, null ); @@ -88,6 +89,7 @@ public void setUp() throws Exception { env, 10 * 1000, null, + null, null ); @@ -112,11 +114,11 @@ public void setUp() throws Exception { intp1.open(); intp2.open(); - eventPoller1 = new RemoteInterpreterEventPoller(null, null); + eventPoller1 = new RemoteInterpreterEventPoller(null, null, null); eventPoller1.setInterpreterGroup(intpGroup1); eventPoller1.setInterpreterProcess(intpGroup1.getRemoteInterpreterProcess()); - eventPoller2 = new RemoteInterpreterEventPoller(null, null); + eventPoller2 = new RemoteInterpreterEventPoller(null, null, null); eventPoller2.setInterpreterGroup(intpGroup2); eventPoller2.setInterpreterProcess(intpGroup2.getRemoteInterpreterProcess()); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java index 49de4a70539..b558aabd07d 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java @@ -81,6 +81,7 @@ public void test() throws Exception { env, 10 * 1000, this, + null, null); intpGroup.put("note", new LinkedList()); @@ -170,6 +171,7 @@ public void testAbortOnPending() throws Exception { env, 10 * 1000, this, + null, null); intpGroup.put("note", new LinkedList()); diff --git a/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java b/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java index eec99736073..b7a086c5031 100644 --- a/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java +++ b/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java @@ -39,6 +39,7 @@ import org.apache.zeppelin.notebook.Notebook; import org.apache.zeppelin.notebook.NotebookAuthorization; import org.apache.zeppelin.notebook.repo.NotebookRepoSync; +import org.apache.zeppelin.remoteworks.RemoteWorksManager; import org.apache.zeppelin.rest.ConfigurationsRestApi; import org.apache.zeppelin.rest.CredentialRestApi; import org.apache.zeppelin.rest.HeliumRestApi; @@ -91,6 +92,7 @@ public class ZeppelinServer extends Application { private NotebookAuthorization notebookAuthorization; private Credentials credentials; private DependencyResolver depResolver; + private RemoteWorksManager remoteWorksManager; public ZeppelinServer() throws Exception { ZeppelinConfiguration conf = ZeppelinConfiguration.create(); @@ -118,6 +120,9 @@ public ZeppelinServer() throws Exception { notebook.addNotebookEventListener(heliumApplicationFactory); notebook.addNotebookEventListener(notebookWsServer.getNotebookInformationListener()); + + remoteWorksManager = new RemoteWorksManager(notebook); + replFactory.setRemoteController(remoteWorksManager.getInstance()); } public static void main(String[] args) throws InterruptedException { diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java index ce740b73f92..f0686b6ef6c 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java @@ -112,6 +112,8 @@ public class InterpreterFactory implements InterpreterGroupFactory { private Map> interpreterBindings = new HashMap<>(); private List interpreterRepositories; + private RemoteWorksController remoteWorksController; + private Gson gson; private InterpreterOption defaultOption; @@ -141,7 +143,6 @@ public InterpreterFactory(ZeppelinConfiguration conf, remoteInterpreterProcessListener, appEventListener, depResolver, shiroEnabled); } - public InterpreterFactory(ZeppelinConfiguration conf, InterpreterOption defaultOption, AngularObjectRegistryListener angularObjectRegistryListener, RemoteInterpreterProcessListener remoteInterpreterProcessListener, @@ -278,6 +279,14 @@ public boolean accept(Path entry) throws IOException { } } + public RemoteWorksController getRemoteWorksController() { + return remoteWorksController; + } + + public void setRemoteController(RemoteWorksController remoteController) { + this.remoteWorksController = remoteController; + } + private InterpreterSetting createFromInterpreterSettingRef(String name) { Preconditions.checkNotNull(name, "reference name should be not null"); InterpreterSetting settingRef = interpreterSettingsRef.get(name); @@ -1103,7 +1112,7 @@ private Interpreter connectToRemoteRepl(String noteId, String className, String int maxPoolSize = conf.getInt(ConfVars.ZEPPELIN_INTERPRETER_MAX_POOL_SIZE); LazyOpenInterpreter intp = new LazyOpenInterpreter( new RemoteInterpreter(property, noteId, className, host, port, connectTimeout, maxPoolSize, - remoteInterpreterProcessListener, appEventListener)); + remoteInterpreterProcessListener, appEventListener, remoteWorksController)); return intp; } @@ -1116,7 +1125,7 @@ private Interpreter createRemoteRepl(String interpreterPath, String noteId, Stri RemoteInterpreter remoteInterpreter = new RemoteInterpreter(property, noteId, className, conf.getInterpreterRemoteRunnerPath(), interpreterPath, localRepoPath, connectTimeout, maxPoolSize, - remoteInterpreterProcessListener, appEventListener); + remoteInterpreterProcessListener, appEventListener, remoteWorksController); remoteInterpreter.addEnv(env); return new LazyOpenInterpreter(remoteInterpreter); diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java index a1daeb5471e..5c8611c9e57 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java @@ -453,6 +453,7 @@ private InterpreterContext getInterpreterContext(InterpreterOutput output) { resourcePool = intpGroup.getInterpreterGroup(getUser(), note.getId()).getResourcePool(); } + //cloverhearts List runners = new LinkedList<>(); for (Paragraph p : note.getParagraphs()) { runners.add(new ParagraphRunner(note, note.getId(), p.getId())); @@ -482,6 +483,10 @@ private InterpreterContext getInterpreterContext(InterpreterOutput output) { return interpreterContext; } + public InterpreterContextRunner getInterpreterContextRunner() { + return new ParagraphRunner(note, note.getId(), getId()); + } + static class ParagraphRunner extends InterpreterContextRunner { private transient Note note; diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java new file mode 100644 index 00000000000..b34af318e9a --- /dev/null +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java @@ -0,0 +1,100 @@ +/* + * 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.remoteworks; + +import org.apache.zeppelin.interpreter.InterpreterContextRunner; +import org.apache.zeppelin.interpreter.RemoteWorksController; +import org.apache.zeppelin.notebook.Note; +import org.apache.zeppelin.notebook.Notebook; +import org.apache.zeppelin.notebook.Paragraph; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.LinkedList; +import java.util.List; + +/** + * Zeppelin Server RemoteWorkController Singleton. + */ +public class RemoteWorksManager { + private static final Logger LOG = LoggerFactory.getLogger(RemoteWorksManager.class); + private static NotebookJobManager instance; + + public RemoteWorksManager(Notebook notebook) { + if (RemoteWorksManager.instance == null) { + RemoteWorksManager.instance = new NotebookJobManager(notebook); + } + } + + public static NotebookJobManager getInstance() { + return RemoteWorksManager.instance; + } + + private class NotebookJobManager implements RemoteWorksController { + private transient Notebook notebook; + + public NotebookJobManager(Notebook notebook) { + setNotebook(notebook); + } + + private void setNotebook(Notebook notebook) { + this.notebook = notebook; + } + + private Notebook getNotebook() throws NullPointerException { + if (notebook == null) { + throw new NullPointerException("Notebook instance is Null"); + } + return notebook; + } + + public List getRunner(String noteId) { + List runners = new LinkedList<>(); + try { + Note note = getNotebook().getNote(noteId); + if (note != null) { + for (Paragraph paragraph : note.getParagraphs()) { + runners.add(paragraph.getInterpreterContextRunner()); + } + } + } catch (NullPointerException e) { + LOG.warn(e.getMessage()); + } + + return runners; + } + + public InterpreterContextRunner getRunner(String noteId, String paragraphId) { + InterpreterContextRunner runner = null; + try { + Note note = getNotebook().getNote(noteId); + if (note != null) { + Paragraph paragraph = note.getParagraph(paragraphId); + if (paragraph != null) { + runner = paragraph.getInterpreterContextRunner(); + } + } + } catch (NullPointerException e) { + LOG.warn(e.getMessage()); + } + return runner; + } + + } + +} From 25232387d1693ecbaed9af98aada09bdd6b92e7b Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Mon, 14 Nov 2016 23:46:26 +0900 Subject: [PATCH 03/23] Implement eventForWait class --- .../remote/RemoteInterpreterServer.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) 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 index 9f807aba86a..d3aa34070be 100644 --- 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 @@ -23,7 +23,10 @@ import java.lang.reflect.InvocationTargetException; import java.net.URL; import java.nio.ByteBuffer; +import java.rmi.server.RemoteServer; import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeoutException; import org.apache.thrift.TException; import org.apache.thrift.server.TThreadPoolServer; @@ -79,6 +82,9 @@ public class RemoteInterpreterServer private final Map runningApplications = Collections.synchronizedMap(new HashMap()); + private Map remoteWorksResponsePool = + Collections.synchronizedMap(new HashMap()); + public RemoteInterpreterServer(int port) throws TTransportException { this.port = port; @@ -343,11 +349,14 @@ public void remoteZeppelinServerControlFeedback( logger.info("clover remote zeppelin server conteroller body {}", response.getMsg()); if (response.getType() == RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT) { + List intpContextRunners = new LinkedList<>(); List runners = gson.fromJson(response.getMsg(), new TypeToken>() {}.getType()); for (ZeppelinServerResourceParagraphRunner r : runners) { logger.info("clover runner nid {} pid {}", r.getNoteId(), r.getParagraphId()); + intpContextRunners.add(new ParagraphRunner(this, r.getNoteId(), r.getParagraphId())); } + remoteWorksResponsePool.put(response.getEventOwnerKey(), intpContextRunners); } } @@ -607,6 +616,38 @@ public void run() { } } + static class RemoteServerController { + //clover + private final long DEFAULT_TIMEOUT_VALUE = 30000; + private Map remoteWorksResponsePool; + public RemoteServerController(Map remoteWorksResponsePool) { + this.remoteWorksResponsePool = remoteWorksResponsePool; + } + + public boolean waitForEvent(String eventOwnerKey) throws InterruptedException { + return waitForEvent(eventOwnerKey, DEFAULT_TIMEOUT_VALUE); + } + + public boolean waitForEvent(String eventOwnerKey, long timeout) throws InterruptedException { + boolean wasGetData = false; + long now = System.currentTimeMillis(); + long endTime = System.currentTimeMillis() + timeout; + + while (endTime <= now) { + if (this.remoteWorksResponsePool.containsKey(eventOwnerKey) == true) { + wasGetData = true; + break; + } + now = System.currentTimeMillis(); + sleep(500); + } + + return wasGetData; + } + + + } + private RemoteInterpreterResult convert(InterpreterResult result, Map config, GUI gui) { return new RemoteInterpreterResult( From 3d34f9e0bb1d88304feafa37b0a69b1601854698 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 15 Nov 2016 19:49:51 +0900 Subject: [PATCH 04/23] Implement getParagraphRunner transaction. --- .../zeppelin/alluxio/AlluxioInterpreter.java | 14 ++- .../zeppelin/angular/AngularInterpreter.java | 10 +++ .../bigquery/BigQueryInterpreter.java | 14 ++- .../cassandra/CassandraInterpreter.java | 14 ++- .../ElasticsearchInterpreter.java | 10 +++ .../apache/zeppelin/file/FileInterpreter.java | 11 +++ .../zeppelin/flink/FlinkInterpreter.java | 15 ++-- .../zeppelin/hbase/HbaseInterpreter.java | 9 ++ .../zeppelin/ignite/IgniteInterpreter.java | 9 ++ .../zeppelin/ignite/IgniteSqlInterpreter.java | 15 ++-- .../apache/zeppelin/jdbc/JDBCInterpreter.java | 14 ++- .../zeppelin/kylin/KylinInterpreter.java | 14 ++- .../apache/zeppelin/lens/LensInterpreter.java | 14 ++- .../zeppelin/livy/LivyPySparkInterpreter.java | 9 ++ .../zeppelin/livy/LivySparkInterpreter.java | 9 ++ .../zeppelin/livy/LivySparkRInterpreter.java | 9 ++ .../livy/LivySparkSQLInterpreter.java | 9 ++ .../apache/zeppelin/markdown/Markdown.java | 15 ++-- .../apache/zeppelin/pig/PigInterpreter.java | 9 ++ .../zeppelin/pig/PigQueryInterpreter.java | 9 ++ .../postgresql/PostgreSqlInterpreter.java | 14 ++- .../zeppelin/python/PythonInterpreter.java | 14 ++- .../python/PythonInterpreterPandasSql.java | 15 ++-- .../zeppelin/shell/ShellInterpreter.java | 9 ++ .../apache/zeppelin/spark/DepInterpreter.java | 15 ++-- .../zeppelin/spark/PySparkInterpreter.java | 17 ++-- .../zeppelin/spark/SparkInterpreter.java | 30 ++++--- .../zeppelin/spark/SparkSqlInterpreter.java | 16 ++-- .../zeppelin/spark/ZeppelinContext.java | 85 +++++++++++++------ .../interpreter/ClassloaderInterpreter.java | 9 ++ .../zeppelin/interpreter/Interpreter.java | 13 +++ .../interpreter/LazyOpenInterpreter.java | 9 ++ .../interpreter/RemoteWorksController.java | 4 +- .../interpreter/dev/DevInterpreter.java | 16 ++-- .../interpreter/remote/RemoteInterpreter.java | 9 ++ .../remote/RemoteInterpreterEventPoller.java | 6 +- .../remote/RemoteInterpreterServer.java | 85 +++++++++++++++---- .../remote/mock/MockInterpreterA.java | 15 ++-- .../remote/mock/MockInterpreterAngular.java | 14 ++- .../remote/mock/MockInterpreterB.java | 17 ++-- .../remote/mock/MockInterpreterEnv.java | 9 ++ .../mock/MockInterpreterOutputStream.java | 9 ++ .../mock/MockInterpreterResourcePool.java | 14 ++- .../interpreter/mock/MockInterpreter1.java | 10 +++ .../remoteworks/RemoteWorksManager.java | 33 +++---- .../interpreter/mock/MockInterpreter1.java | 10 +++ .../interpreter/mock/MockInterpreter11.java | 10 +++ .../interpreter/mock/MockInterpreter2.java | 9 ++ 48 files changed, 575 insertions(+), 173 deletions(-) diff --git a/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java b/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java index 79e10b6f95d..bea45de9d1c 100644 --- a/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java +++ b/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java @@ -23,10 +23,7 @@ import java.io.ByteArrayOutputStream; import java.util.*; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.slf4j.Logger; @@ -89,6 +86,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] lines = splitAndRemoveEmpty(st, "\n"); diff --git a/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java b/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java index f8ff350d096..5f8ed2affe0 100644 --- a/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java +++ b/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java @@ -26,6 +26,7 @@ import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.InterpreterResult.Type; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -47,6 +48,15 @@ public void open() { public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { return new InterpreterResult(Code.SUCCESS, Type.ANGULAR, st); diff --git a/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java b/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java index 33e196003b0..4a6d27ce4b6 100644 --- a/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java +++ b/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java @@ -51,10 +51,7 @@ import java.util.Properties; import java.util.Set; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; @@ -290,6 +287,15 @@ public void close() { service = null; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String sql, InterpreterContext contextInterpreter) { logger.info("Run SQL command '{}'", sql); diff --git a/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java b/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java index 47d8e3a53cb..71f4e17ef2a 100644 --- a/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java +++ b/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java @@ -19,10 +19,7 @@ import com.datastax.driver.core.Cluster; import com.datastax.driver.core.ProtocolOptions.Compression; import com.datastax.driver.core.Session; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -195,6 +192,15 @@ public void close() { cluster.close(); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { return helper.interpret(session, st, context); diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java index 549b5f25efd..60d8699182a 100644 --- a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java +++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java @@ -37,6 +37,7 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.elasticsearch.action.delete.DeleteResponse; import org.elasticsearch.action.get.GetResponse; @@ -149,6 +150,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String cmd, InterpreterContext interpreterContext) { logger.info("Run Elasticsearch command '" + cmd + "'"); diff --git a/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java b/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java index 9aa36058222..7ed30862ff4 100644 --- a/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java +++ b/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java @@ -23,6 +23,7 @@ import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.InterpreterResult.Type; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -100,6 +101,16 @@ protected String getNewPath(String argument){ // Handle the command handling uniformly across all file systems + + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { logger.info("Run File command '" + cmd + "'"); diff --git a/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java b/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java index 8b9b4ec14ca..333ed5c2d78 100644 --- a/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java +++ b/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java @@ -35,12 +35,8 @@ import org.apache.flink.runtime.messages.JobManagerMessages; import org.apache.flink.runtime.minicluster.LocalFlinkMiniCluster; import org.apache.flink.runtime.util.EnvironmentInformation; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.InterpreterUtils; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -242,6 +238,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String line, InterpreterContext context) { if (line == null || line.trim().length() == 0) { diff --git a/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java b/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java index 6c2460d6701..17f69c916dc 100644 --- a/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java +++ b/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java @@ -110,6 +110,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String cmd, InterpreterContext interpreterContext) { try { diff --git a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java index 66dac1b54f2..03cf5a3b07e 100644 --- a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java +++ b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java @@ -275,6 +275,15 @@ public InterpreterResult interpret(String line, InterpreterContext context) { public void cancel(InterpreterContext context) { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + private InterpreterResult interpret(String[] lines) { String[] linesToRun = new String[lines.length + 1]; System.arraycopy(lines, 0, linesToRun, 0, lines.length); diff --git a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java index 9a651f8816f..685774faf74 100644 --- a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java +++ b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java @@ -16,11 +16,7 @@ */ package org.apache.zeppelin.ignite; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; @@ -117,6 +113,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { if (connEx != null) { diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java index 0fbbda37455..9fa6ed8cac9 100644 --- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java +++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java @@ -30,10 +30,7 @@ import org.apache.commons.pool2.ObjectPool; import org.apache.commons.pool2.impl.GenericObjectPool; import org.apache.hadoop.security.UserGroupInformation; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.jdbc.security.JDBCSecurityImpl; @@ -441,6 +438,15 @@ private String replaceReservedChars(boolean isTableResponseType, String str) { return (!isTableResponseType) ? str : str.replace(TAB, WHITESPACE).replace(NEWLINE, WHITESPACE); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { logger.info("Run SQL command '{}'", cmd); diff --git a/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java b/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java index 8523e49fbdf..25dd56e4178 100755 --- a/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java +++ b/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java @@ -24,10 +24,7 @@ import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.HttpClientBuilder; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -69,6 +66,15 @@ public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { try { diff --git a/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java b/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java index f0c9062409f..ba8f01ca441 100644 --- a/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java +++ b/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java @@ -31,10 +31,7 @@ import org.apache.lens.client.LensClientConfig; import org.apache.lens.client.LensClientSingletonWrapper; import org.apache.lens.cli.commands.BaseLensCommand; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; @@ -247,6 +244,15 @@ private String modifyQueryStatement(String st) { return sb.toString(); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String input, InterpreterContext context) { if (input == null || input.length() == 0) { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java index bd342a2e3ed..b49a9b28e64 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java @@ -55,6 +55,15 @@ public void close() { livyHelper.closeSession(userSessionMap); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java index 9a9dd8080ee..1cc51cbde3e 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java @@ -71,6 +71,15 @@ public void close() { livyHelper.closeSession(userSessionMap); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java index 753b378e9a1..d75b747295e 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java @@ -55,6 +55,15 @@ public void close() { livyHelper.closeSession(userSessionMap); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java index 3d4a0f4e428..823720fb9cb 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java @@ -54,6 +54,15 @@ public void close() { livyHelper.closeSession(userSessionMap); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java b/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java index a811eabaa62..35c820ff495 100644 --- a/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java +++ b/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java @@ -21,12 +21,8 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.InterpreterUtils; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -84,6 +80,15 @@ public void open() { @Override public void close() {} + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String markdownText, InterpreterContext interpreterContext) { String html; diff --git a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java index 8cd1efc929e..30d25343f43 100644 --- a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java +++ b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java @@ -25,6 +25,7 @@ import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -69,6 +70,14 @@ public void close() { pigServer = null; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { diff --git a/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java b/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java index 1a7634a9db4..9cb66e0866b 100644 --- a/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java +++ b/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java @@ -63,6 +63,15 @@ public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { // '-' is invalid for pig alias diff --git a/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java b/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java index 88c22d4e2ad..d7907fb5878 100644 --- a/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java +++ b/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java @@ -28,10 +28,7 @@ import java.util.Properties; import java.util.Set; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; @@ -283,6 +280,15 @@ private String replaceReservedChars(boolean isTableResponseType, String str) { return (!isTableResponseType) ? str : str.replace(TAB, WhITESPACE).replace(NEWLINE, WhITESPACE); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { logger.info("Run SQL command '{}'", cmd); diff --git a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java index e2fb999db29..4f778e9e86b 100644 --- a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java +++ b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java @@ -28,12 +28,9 @@ import java.util.regex.Pattern; import org.apache.zeppelin.display.GUI; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.InterpreterHookRegistry.HookType; -import org.apache.zeppelin.interpreter.InterpreterGroup; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Job; import org.apache.zeppelin.scheduler.Scheduler; @@ -132,6 +129,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { if (cmd == null || cmd.isEmpty()) { diff --git a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java index 381066fe270..ba0092ef00e 100644 --- a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java +++ b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java @@ -20,11 +20,7 @@ import java.io.IOException; import java.util.Properties; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterResult; -import org.apache.zeppelin.interpreter.LazyOpenInterpreter; -import org.apache.zeppelin.interpreter.WrappedInterpreter; +import org.apache.zeppelin.interpreter.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -90,6 +86,15 @@ public void close() { python.close(); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { LOG.info("Running SQL query: '{}' over Pandas DataFrame", st); diff --git a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java index 838c6f15358..e2bbf658904 100644 --- a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java +++ b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java @@ -36,6 +36,7 @@ import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -69,6 +70,14 @@ public void open() { @Override public void close() {} + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { diff --git a/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java index 478d0bc794c..d9280f06aa5 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java @@ -34,12 +34,8 @@ import com.google.common.reflect.TypeToken; import com.google.gson.Gson; import org.apache.spark.repl.SparkILoop; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterGroup; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.spark.dep.SparkDependencyContext; @@ -196,6 +192,15 @@ private void createIMain() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + private Results.Result interpret(String line) { return (Results.Result) Utils.invokeMethod( intp, diff --git a/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java index 6a76bfbd0bd..2583e9af784 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java @@ -45,14 +45,8 @@ import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaSparkContext; import org.apache.spark.sql.SQLContext; -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.*; import org.apache.zeppelin.interpreter.InterpreterHookRegistry.HookType; -import org.apache.zeppelin.interpreter.LazyOpenInterpreter; -import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.spark.dep.SparkDependencyContext; @@ -312,6 +306,15 @@ public void appendOutput(String message) throws IOException { outputStream.getInterpreterOutput().write(message); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { SparkInterpreter sparkInterpreter = getSparkInterpreter(); diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java index 53bf30b9533..d855e00569b 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java @@ -46,15 +46,9 @@ import org.apache.spark.scheduler.Pool; import org.apache.spark.sql.SQLContext; import org.apache.spark.ui.jobs.JobProgressListener; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterHookRegistry; -import org.apache.zeppelin.interpreter.InterpreterProperty; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.InterpreterUtils; -import org.apache.zeppelin.interpreter.WrappedInterpreter; +import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; import org.apache.zeppelin.resource.ResourcePool; import org.apache.zeppelin.resource.WellKnownResourceName; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; @@ -113,6 +107,8 @@ public class SparkInterpreter extends Interpreter { private SparkOutputStream out; private SparkDependencyResolver dep; + private RemoteWorksController remoteWorksController; + /** * completer - org.apache.spark.repl.SparkJLineCompletion (scala 2.10) */ @@ -819,7 +815,7 @@ public void open() { hooks = getInterpreterGroup().getInterpreterHookRegistry(); - z = new ZeppelinContext(sc, sqlc, null, dep, hooks, + z = new ZeppelinContext(sc, sqlc, null, dep, hooks, getRemoteZeppelinServerController(), Integer.parseInt(getProperty("zeppelin.spark.maxResult"))); interpret("@transient val _binder = new java.util.HashMap[String, Object]()"); @@ -1045,10 +1041,20 @@ private String getCompletionTargetString(String text, int cursor) { return resultCompletionText; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + this.remoteWorksController = zServer; + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return this.remoteWorksController; + } + /* - * this method doesn't work in scala 2.11 - * Somehow intp.valueOfTerm returns scala.None always with -Yrepl-class-based option - */ + * this method doesn't work in scala 2.11 + * Somehow intp.valueOfTerm returns scala.None always with -Yrepl-class-based option + */ public Object getValue(String name) { Object ret = Utils.invokeMethod( intp, "valueOfTerm", new Class[]{String.class}, new Object[]{name}); diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java index fc8923c4172..9afad2a3e49 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java @@ -25,13 +25,8 @@ import org.apache.spark.SparkContext; import org.apache.spark.sql.SQLContext; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.LazyOpenInterpreter; -import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -86,6 +81,15 @@ public boolean concurrentSQL() { @Override public void close() {} + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { SQLContext sqlc = null; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java index e29dc9407eb..2b35c673a3c 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java @@ -41,10 +41,7 @@ import org.apache.zeppelin.display.AngularObjectWatcher; import org.apache.zeppelin.display.GUI; import org.apache.zeppelin.display.Input.ParamOption; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterContextRunner; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterHookRegistry; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.spark.dep.SparkDependencyResolver; import org.apache.zeppelin.resource.Resource; import org.apache.zeppelin.resource.ResourcePool; @@ -73,17 +70,20 @@ public class ZeppelinContext { private int maxResult; private List supportedClasses; private InterpreterHookRegistry hooks; + private RemoteWorksController remoteWorksController; public ZeppelinContext(SparkContext sc, SQLContext sql, InterpreterContext interpreterContext, SparkDependencyResolver dep, InterpreterHookRegistry hooks, + RemoteWorksController remoteWorksController, int maxResult) { this.sc = sc; this.sqlContext = sql; this.interpreterContext = interpreterContext; this.dep = dep; this.hooks = hooks; + this.remoteWorksController = remoteWorksController; this.maxResult = maxResult; this.supportedClasses = new ArrayList<>(); try { @@ -298,45 +298,79 @@ public static String showDF(SparkContext sc, return msg.toString(); } + + /** + * Run paragraph by id + * @param noteId + * @param paragraphId + */ + @ZeppelinApi + public void run(String noteId, String paragraphId) { + run(noteId, paragraphId, interpreterContext); + } + /** * Run paragraph by id - * @param id + * @param paragraphId */ @ZeppelinApi - public void run(String id) { - run(id, interpreterContext); + public void run(String paragraphId) { + String noteId = interpreterContext.getNoteId(); + run(noteId, paragraphId, interpreterContext); } /** * Run paragraph by id - * @param id + * @param noteId * @param context */ @ZeppelinApi - public void run(String id, InterpreterContext context) { - if (id.equals(context.getParagraphId())) { + public void run(String noteId, String paragraphId, InterpreterContext context) { + if (paragraphId.equals(context.getParagraphId())) { throw new InterpreterException("Can not run current Paragraph"); } - for (InterpreterContextRunner r : context.getRunners()) { - if (id.equals(r.getParagraphId())) { - r.run(); - return; - } + List runners = getInterpreterContextRunner(noteId, paragraphId); + + if (runners.size() <= 0) { + throw new InterpreterException("Paragraph " + paragraphId + " not found " + runners.size()); + } + + for (InterpreterContextRunner r : runners) { + r.run(); } - throw new InterpreterException("Paragraph " + id + " not found"); } + /** * get Zeppelin Paragraph Runner from zeppelin server + * @param noteId + */ + @ZeppelinApi + public List getInterpreterContextRunner(String noteId) { + List runners = new LinkedList<>(); + + if (remoteWorksController != null) { + runners = remoteWorksController.getRemoteContextRunner(noteId); + } + + return runners; + } + + /** + * get Zeppelin Paragraph Runner from zeppelin server + * @param noteId + * @param paragraphId */ @ZeppelinApi public List getInterpreterContextRunner( String noteId, String paragraphId) { List runners = new LinkedList<>(); - + if (remoteWorksController != null) { + runners = remoteWorksController.getRemoteContextRunner(noteId, paragraphId); + } return runners; } @@ -347,7 +381,8 @@ public List getInterpreterContextRunner( */ @ZeppelinApi public void run(int idx) { - run(idx, interpreterContext); + String noteId = interpreterContext.getNoteId(); + run(noteId, idx, interpreterContext); } /** @@ -355,12 +390,13 @@ public void run(int idx) { * @param idx index starting from 0 * @param context interpreter context */ - public void run(int idx, InterpreterContext context) { - if (idx >= context.getRunners().size()) { + public void run(String noteId, int idx, InterpreterContext context) { + List runners = getInterpreterContextRunner(noteId); + if (idx >= runners.size()) { throw new InterpreterException("Index out of bound"); } - InterpreterContextRunner runner = context.getRunners().get(idx); + InterpreterContextRunner runner = runners.get(idx); if (runner.getParagraphId().equals(context.getParagraphId())) { throw new InterpreterException("Can not run current Paragraph"); } @@ -379,13 +415,14 @@ public void run(List paragraphIdOrIdx) { */ @ZeppelinApi public void run(List paragraphIdOrIdx, InterpreterContext context) { + String noteId = context.getNoteId(); for (Object idOrIdx : paragraphIdOrIdx) { if (idOrIdx instanceof String) { - String id = (String) idOrIdx; - run(id, context); + String paragraphId = (String) idOrIdx; + run(noteId, paragraphId, context); } else if (idOrIdx instanceof Integer) { Integer idx = (Integer) idOrIdx; - run(idx, context); + run(noteId, idx, context); } else { throw new InterpreterException("Paragraph " + idOrIdx + " not found"); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java index e20f7c5427e..5c99d6edb08 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java @@ -50,6 +50,15 @@ public ClassLoader getClassloader() { return cl; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { ClassLoader oldcl = Thread.currentThread().getContextClassLoader(); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java index c068e048190..2f48281cc6b 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java @@ -196,6 +196,19 @@ public InterpreterGroup getInterpreterGroup() { return this.interpreterGroup; } + /** + * setup Remote Zeppelin Server Controller interface + * @param zServer + */ + @ZeppelinApi + public abstract void setRemoteZeppelinServerController(RemoteWorksController zServer); + + /** + * get Remote Zeppelin Server Controller interface + */ + @ZeppelinApi + public abstract RemoteWorksController getRemoteZeppelinServerController(); + public URL[] getClassloaderUrls() { return classloaderUrls; } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java index 425ae20a4f1..cf9721709d2 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java @@ -88,6 +88,15 @@ public boolean isOpen() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { open(); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java index e6c6ca552cf..e1410d61abb 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteWorksController.java @@ -24,6 +24,6 @@ * */ public interface RemoteWorksController { - List getRunner(String noteId); - InterpreterContextRunner getRunner(String noteId, String paragraphId); + List getRemoteContextRunner(String noteId); + List getRemoteContextRunner(String noteId, String paragraphId); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java index eb21d5870f9..7b7f7d0af7f 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java @@ -20,12 +20,7 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterContextRunner; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; /** @@ -79,6 +74,15 @@ public void rerun() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { this.context = context; 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 index cf1256f0be8..658d7806fc6 100644 --- 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 @@ -302,6 +302,15 @@ public void close() { } } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { if (logger.isDebugEnabled()) { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index 1226a95c841..91787691368 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -247,11 +247,11 @@ private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController e resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); resResource.setEventOwnerKey(eventOwnerKey); if (runner.getParagraphId() != null) { - InterpreterContextRunner intpRunner = remoteWorkController.getRunner( + interpreterContextRunners = remoteWorkController.getRemoteContextRunner( runner.getNoteId(), runner.getParagraphId()); - interpreterContextRunners.add(intpRunner); } else { - interpreterContextRunners = remoteWorkController.getRunner(runner.getNoteId()); + interpreterContextRunners = remoteWorkController.getRemoteContextRunner( + runner.getNoteId()); } logger.info("clover remotework count 1 {}", interpreterContextRunners.size()); 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 index d3aa34070be..69314f1a166 100644 --- 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 @@ -68,6 +68,7 @@ public class RemoteInterpreterServer InterpreterHookRegistry hookRegistry; DistributedResourcePool resourcePool; private ApplicationLoader appLoader; + private RemoteWorksController remoteServerController; Gson gson = new Gson(); @@ -82,8 +83,7 @@ public class RemoteInterpreterServer private final Map runningApplications = Collections.synchronizedMap(new HashMap()); - private Map remoteWorksResponsePool = - Collections.synchronizedMap(new HashMap()); + private Map remoteWorksResponsePool; public RemoteInterpreterServer(int port) throws TTransportException { this.port = port; @@ -92,6 +92,8 @@ public RemoteInterpreterServer(int port) throws TTransportException { TServerSocket serverTransport = new TServerSocket(port); server = new TThreadPoolServer( new TThreadPoolServer.Args(serverTransport).processor(processor)); + remoteWorksResponsePool = Collections.synchronizedMap(new HashMap()); + remoteServerController = new ZeppelinRemoteWorksController(this, remoteWorksResponsePool); } @Override @@ -181,8 +183,8 @@ public void createInterpreter(String interpreterGroupId, String noteId, String Constructor constructor = replClass.getConstructor(new Class[] {Properties.class}); Interpreter repl = constructor.newInstance(p); - repl.setClassloaderUrls(new URL[]{}); + repl.setRemoteZeppelinServerController(remoteServerController); synchronized (interpreterGroup) { List interpreters = interpreterGroup.get(noteId); @@ -347,16 +349,20 @@ public void remoteZeppelinServerControlFeedback( RemoteZeppelinServerController response) throws TException { logger.info("clover remote zeppelin server controller feedback {}", response); logger.info("clover remote zeppelin server conteroller body {}", response.getMsg()); - if (response.getType() == RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT) { List intpContextRunners = new LinkedList<>(); List runners = gson.fromJson(response.getMsg(), new TypeToken>() {}.getType()); + logger.info("clover get runner size " + runners.size()); for (ZeppelinServerResourceParagraphRunner r : runners) { - logger.info("clover runner nid {} pid {}", r.getNoteId(), r.getParagraphId()); + logger.info("clover runner nid " + r.getNoteId() + " pid " + r.getParagraphId()); intpContextRunners.add(new ParagraphRunner(this, r.getNoteId(), r.getParagraphId())); } - remoteWorksResponsePool.put(response.getEventOwnerKey(), intpContextRunners); + synchronized (this.remoteWorksResponsePool) { + this.remoteWorksResponsePool.put(response.getEventOwnerKey(), intpContextRunners); + logger.info("clover feedback remoteWorks {} count {}", + response.getEventOwnerKey(), remoteWorksResponsePool.size()); + } } } @@ -598,7 +604,7 @@ public void onUpdate(InterpreterOutput out, byte[] output) { static class ParagraphRunner extends InterpreterContextRunner { - + Logger logger = LoggerFactory.getLogger(ParagraphRunner.class); private transient RemoteInterpreterServer server; public ParagraphRunner(RemoteInterpreterServer server, String noteId, String paragraphId) { @@ -608,20 +614,28 @@ public ParagraphRunner(RemoteInterpreterServer server, String noteId, String par @Override public void run() { - ZeppelinServerResourceParagraphRunner test = new ZeppelinServerResourceParagraphRunner(); - test.setNoteId(getNoteId()); - test.setParagraphId(getParagraphId()); - server.eventClient.getZeppelinServerNoteRunner("IamOWNER", test); + logger.info("clover call run"); server.eventClient.run(this); } } - static class RemoteServerController { + static class ZeppelinRemoteWorksController implements RemoteWorksController{ //clover - private final long DEFAULT_TIMEOUT_VALUE = 30000; + Logger logger = LoggerFactory.getLogger(ZeppelinRemoteWorksController.class); + + private final long DEFAULT_TIMEOUT_VALUE = 300000; private Map remoteWorksResponsePool; - public RemoteServerController(Map remoteWorksResponsePool) { + private RemoteInterpreterServer server; + public ZeppelinRemoteWorksController( + RemoteInterpreterServer server, Map remoteWorksResponsePool) { this.remoteWorksResponsePool = remoteWorksResponsePool; + this.server = server; + } + + public String generateOwnerKey() { + String hashKeyText = new String("ownerKey" + System.currentTimeMillis()); + String hashKey = String.valueOf(hashKeyText.hashCode()); + return hashKey; } public boolean waitForEvent(String eventOwnerKey) throws InterruptedException { @@ -633,18 +647,55 @@ public boolean waitForEvent(String eventOwnerKey, long timeout) throws Interrupt long now = System.currentTimeMillis(); long endTime = System.currentTimeMillis() + timeout; - while (endTime <= now) { - if (this.remoteWorksResponsePool.containsKey(eventOwnerKey) == true) { - wasGetData = true; + while (endTime >= now) { + logger.info("clover sleep... size {} key {}", + this.remoteWorksResponsePool.size(), eventOwnerKey); + synchronized (this.remoteWorksResponsePool) { + wasGetData = this.remoteWorksResponsePool.containsKey(eventOwnerKey); + } + if (wasGetData == true) { + logger.info("clover found!!!!!!!!!!!!!"); break; } now = System.currentTimeMillis(); sleep(500); } + logger.info("clover out {}", wasGetData); return wasGetData; } + @Override + public List getRemoteContextRunner(String noteId) { + return getRemoteContextRunner(noteId, null); + } + + public List getRemoteContextRunner( + String noteId, String paragraphID) { + + List runners = null; + String ownerKey = generateOwnerKey(); + + logger.info("clover request owner key {}", ownerKey); + ZeppelinServerResourceParagraphRunner resource = new ZeppelinServerResourceParagraphRunner(); + resource.setNoteId(noteId); + resource.setParagraphId(paragraphID); + server.eventClient.getZeppelinServerNoteRunner(ownerKey, resource); + + try { + this.waitForEvent(ownerKey); + } catch (Exception e) { + logger.info("clover timeout Interrupt getRemoteContextRunner ", e); + return new LinkedList<>(); + } + synchronized (this.remoteWorksResponsePool) { + runners = (List) this.remoteWorksResponsePool.get(ownerKey); + this.remoteWorksResponsePool.remove(ownerKey); + } + logger.info("clover out time {} {}", runners.size(), System.currentTimeMillis()); + return runners; + } + } diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java index cb367cabc36..bc3b561ac65 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java @@ -20,11 +20,7 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; @@ -60,6 +56,15 @@ public String getLastStatement() { return lastSt; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { try { diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java index 76b29259d95..312a87eaa06 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java @@ -23,10 +23,7 @@ import org.apache.zeppelin.display.AngularObjectRegistry; import org.apache.zeppelin.display.AngularObjectWatcher; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; @@ -56,6 +53,15 @@ public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] stmt = st.split(" "); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java index d31a5492d75..8b93f731bf4 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java @@ -20,14 +20,8 @@ import java.util.List; import java.util.Properties; -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.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; @@ -54,6 +48,15 @@ public void open() { public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { MockInterpreterA intpA = getInterpreterA(); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java index 10146b85161..7d87221c0e0 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java @@ -48,6 +48,15 @@ public void open() { public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] cmd = st.split(" "); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java index 85a8444b3c2..ca1a1413ae4 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java @@ -57,6 +57,15 @@ public String getLastStatement() { return lastSt; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] ret = st.split(":"); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java index e49306d22a7..35397b64f8d 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java @@ -24,10 +24,7 @@ import com.google.gson.Gson; import org.apache.zeppelin.display.AngularObjectRegistry; import org.apache.zeppelin.display.AngularObjectWatcher; -import org.apache.zeppelin.interpreter.Interpreter; -import org.apache.zeppelin.interpreter.InterpreterContext; -import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; -import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.resource.Resource; @@ -59,6 +56,15 @@ public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] stmt = st.split(" "); diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java b/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java index b8343c0633a..c8b7bbe7fc4 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java @@ -24,6 +24,7 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -43,6 +44,15 @@ public void open() { public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { return new InterpreterResult(InterpreterResult.Code.SUCCESS, "repl1: "+st); diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java index b34af318e9a..b89e1025067 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java @@ -63,30 +63,25 @@ private Notebook getNotebook() throws NullPointerException { return notebook; } - public List getRunner(String noteId) { - List runners = new LinkedList<>(); - try { - Note note = getNotebook().getNote(noteId); - if (note != null) { - for (Paragraph paragraph : note.getParagraphs()) { - runners.add(paragraph.getInterpreterContextRunner()); - } - } - } catch (NullPointerException e) { - LOG.warn(e.getMessage()); - } - - return runners; + public List getRemoteContextRunner(String noteId) { + return getRemoteContextRunner(noteId, null); } - public InterpreterContextRunner getRunner(String noteId, String paragraphId) { - InterpreterContextRunner runner = null; + public List getRemoteContextRunner( + String noteId, String paragraphId) { + List runner = new LinkedList<>(); try { Note note = getNotebook().getNote(noteId); if (note != null) { - Paragraph paragraph = note.getParagraph(paragraphId); - if (paragraph != null) { - runner = paragraph.getInterpreterContextRunner(); + if (paragraphId != null) { + Paragraph paragraph = note.getParagraph(paragraphId); + if (paragraph != null) { + runner.add(paragraph.getInterpreterContextRunner()); + } + } else { + for (Paragraph p : note.getParagraphs()) { + runner.add(p.getInterpreterContextRunner()); + } } } } catch (NullPointerException e) { diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java index e462f7289f1..cbbd6065214 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java @@ -25,6 +25,7 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -53,6 +54,15 @@ public boolean isOpen() { return open; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { InterpreterResult result; diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java index fc307265cd2..e8bdc941696 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java @@ -25,6 +25,7 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -44,6 +45,15 @@ public void open() { public void close() { } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { return new InterpreterResult(InterpreterResult.Code.SUCCESS, "repl11: "+st); diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java index 93f99ae942b..4335ca8410f 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java @@ -25,6 +25,7 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -52,6 +53,14 @@ public boolean isOpen() { return open; } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } @Override public InterpreterResult interpret(String st, InterpreterContext context) { From 3ed556c50d858495df11065275642699c4f0a435 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 15 Nov 2016 20:02:43 +0900 Subject: [PATCH 05/23] remove debug console message. --- .../remote/RemoteInterpreterEventClient.java | 2 -- .../remote/RemoteInterpreterEventPoller.java | 11 ----------- .../remote/RemoteInterpreterServer.java | 16 +--------------- .../main/thrift/RemoteInterpreterService.thrift | 1 - .../org/apache/zeppelin/notebook/Paragraph.java | 1 - 5 files changed, 1 insertion(+), 30 deletions(-) diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java index 323340b7436..f3177762751 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java @@ -51,7 +51,6 @@ public class RemoteInterpreterEventClient implements ResourcePoolConnector { private final Map getResourceResponse = new HashMap<>(); private final Gson gson = new Gson(); - // cloverhearts /** * Run paragraph * @param runner @@ -61,7 +60,6 @@ public void getZeppelinServerNoteRunner( RemoteZeppelinServerController eventBody = new RemoteZeppelinServerController(); eventBody.setType(RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT); eventBody.setEventOwnerKey(eventOwnerKey); - logger.info("clover gson.toJson(runner) - " + gson.toJson(runner)); eventBody.setMsg(gson.toJson(runner)); sendEvent(new RemoteInterpreterEvent( diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index 91787691368..5eb1ac25242 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -213,7 +213,6 @@ public void run() { } else if (event.getType() == RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_CONTROL) { RemoteZeppelinServerController remoteControlEvent = gson.fromJson( event.getData(), RemoteZeppelinServerController.class); - //cloverhearts progressRemoteZeppelinControlEvent(remoteControlEvent); } @@ -228,7 +227,6 @@ public void run() { } private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController event) { - logger.info("clover - received RemoteInterpreterEvent"); Gson gson = new Gson(); String eventOwnerKey = event.getEventOwnerKey(); Client interpreterServer = null; @@ -241,8 +239,6 @@ private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController e ZeppelinServerResourceParagraphRunner runner = gson.fromJson( event.getMsg(), ZeppelinServerResourceParagraphRunner.class); - logger.info("clover req note id {} p id {} - msg {}", - runner.getNoteId(), runner.getParagraphId(), event.getMsg()); RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); resResource.setEventOwnerKey(eventOwnerKey); @@ -254,21 +250,15 @@ private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController e runner.getNoteId()); } - logger.info("clover remotework count 1 {}", interpreterContextRunners.size()); - for (InterpreterContextRunner r : interpreterContextRunners) { remoteRunners.add( new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) ); } - logger.info("clover remotework count 2 {}", remoteRunners.size()); - resResource.setMsg(gson.toJson(remoteRunners)); interpreterServer.remoteZeppelinServerControlFeedback(resResource); - logger.info("get runner noteid {} paragraphid {}", - runner.getNoteId(), runner.getParagraphId()); } } catch (Exception e) { @@ -284,7 +274,6 @@ private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController e return; } - logger.info("clover - remote event {}", event.getType()); } private void sendResourcePoolResponseGetAll(ResourceSet resourceSet) { 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 index 69314f1a166..2cfecf571f1 100644 --- 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 @@ -347,21 +347,16 @@ public RemoteInterpreterResult interpret(String noteId, String className, String @Override public void remoteZeppelinServerControlFeedback( RemoteZeppelinServerController response) throws TException { - logger.info("clover remote zeppelin server controller feedback {}", response); - logger.info("clover remote zeppelin server conteroller body {}", response.getMsg()); + logger.info("remote zeppelin server controller feedback {}", response); if (response.getType() == RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT) { List intpContextRunners = new LinkedList<>(); List runners = gson.fromJson(response.getMsg(), new TypeToken>() {}.getType()); - logger.info("clover get runner size " + runners.size()); for (ZeppelinServerResourceParagraphRunner r : runners) { - logger.info("clover runner nid " + r.getNoteId() + " pid " + r.getParagraphId()); intpContextRunners.add(new ParagraphRunner(this, r.getNoteId(), r.getParagraphId())); } synchronized (this.remoteWorksResponsePool) { this.remoteWorksResponsePool.put(response.getEventOwnerKey(), intpContextRunners); - logger.info("clover feedback remoteWorks {} count {}", - response.getEventOwnerKey(), remoteWorksResponsePool.size()); } } } @@ -614,13 +609,11 @@ public ParagraphRunner(RemoteInterpreterServer server, String noteId, String par @Override public void run() { - logger.info("clover call run"); server.eventClient.run(this); } } static class ZeppelinRemoteWorksController implements RemoteWorksController{ - //clover Logger logger = LoggerFactory.getLogger(ZeppelinRemoteWorksController.class); private final long DEFAULT_TIMEOUT_VALUE = 300000; @@ -648,19 +641,15 @@ public boolean waitForEvent(String eventOwnerKey, long timeout) throws Interrupt long endTime = System.currentTimeMillis() + timeout; while (endTime >= now) { - logger.info("clover sleep... size {} key {}", - this.remoteWorksResponsePool.size(), eventOwnerKey); synchronized (this.remoteWorksResponsePool) { wasGetData = this.remoteWorksResponsePool.containsKey(eventOwnerKey); } if (wasGetData == true) { - logger.info("clover found!!!!!!!!!!!!!"); break; } now = System.currentTimeMillis(); sleep(500); } - logger.info("clover out {}", wasGetData); return wasGetData; } @@ -676,7 +665,6 @@ public List getRemoteContextRunner( List runners = null; String ownerKey = generateOwnerKey(); - logger.info("clover request owner key {}", ownerKey); ZeppelinServerResourceParagraphRunner resource = new ZeppelinServerResourceParagraphRunner(); resource.setNoteId(noteId); resource.setParagraphId(paragraphID); @@ -685,14 +673,12 @@ public List getRemoteContextRunner( try { this.waitForEvent(ownerKey); } catch (Exception e) { - logger.info("clover timeout Interrupt getRemoteContextRunner ", e); return new LinkedList<>(); } synchronized (this.remoteWorksResponsePool) { runners = (List) this.remoteWorksResponsePool.get(ownerKey); this.remoteWorksResponsePool.remove(ownerKey); } - logger.info("clover out time {} {}", runners.size(), System.currentTimeMillis()); return runners; } diff --git a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift index 0cfd489e25f..fb1accbdb01 100644 --- a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift +++ b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift @@ -65,7 +65,6 @@ struct RemoteApplicationResult { } /* - cloverhearts remote interpreter process --> request --> zeppelin server */ enum RemoteZeppelinServerControlEvent { diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java index 5c8611c9e57..69abce444cf 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java @@ -453,7 +453,6 @@ private InterpreterContext getInterpreterContext(InterpreterOutput output) { resourcePool = intpGroup.getInterpreterGroup(getUser(), note.getId()).getResourcePool(); } - //cloverhearts List runners = new LinkedList<>(); for (Paragraph p : note.getParagraphs()) { runners.add(new ParagraphRunner(note, note.getId(), p.getId())); From 5a7886fd82d9dd06e1c0a39cd11f37128a9e5d46 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 15 Nov 2016 20:47:38 +0900 Subject: [PATCH 06/23] fix sio support --- .../scala/org/apache/zeppelin/scio/ScioInterpreter.scala | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala b/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala index 00d011f0129..8b838517a64 100644 --- a/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala +++ b/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala @@ -26,7 +26,7 @@ import com.google.cloud.dataflow.sdk.runners.inprocess.InProcessPipelineRunner import com.spotify.scio.repl.{ScioILoop, ScioReplClassLoader} import org.apache.zeppelin.interpreter.Interpreter.FormType import org.apache.zeppelin.interpreter.util.InterpreterOutputStream -import org.apache.zeppelin.interpreter.{Interpreter, InterpreterContext, InterpreterResult} +import org.apache.zeppelin.interpreter.{Interpreter, InterpreterContext, InterpreterResult, RemoteWorksController} import org.slf4j.LoggerFactory import scala.reflect.io.File @@ -153,6 +153,10 @@ class ScioInterpreter(property: Properties) extends Interpreter(property) { REPL.closeInterpreter() } + override def getRemoteZeppelinServerController: RemoteWorksController = null + + override def setRemoteZeppelinServerController(zServer: RemoteWorksController): Unit = {} + override def interpret(code: String, context: InterpreterContext): InterpreterResult = { val paragraphId = context.getParagraphId From 55e870403b8eb770192d36b1537c3bc90f953119 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 15 Nov 2016 22:55:52 +0900 Subject: [PATCH 07/23] support spark r --- .../org/apache/zeppelin/spark/SparkRInterpreter.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java index 06139496020..90ba85bea1b 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java @@ -94,6 +94,15 @@ public void open() { renderOptions = getProperty("zeppelin.R.render.options"); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } + @Override public InterpreterResult interpret(String lines, InterpreterContext interpreterContext) { From 3f75bd572112af7f951c6b06f31b28d1c2957352 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 15 Nov 2016 23:33:20 +0900 Subject: [PATCH 08/23] support scald --- .../apache/zeppelin/scalding/ScaldingInterpreter.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java index 282cd2e734f..005cbe0977b 100644 --- a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java +++ b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java @@ -24,6 +24,7 @@ import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; @@ -115,6 +116,14 @@ public void close() { interpreter.intp().close(); } + @Override + public void setRemoteZeppelinServerController(RemoteWorksController zServer) { + } + + @Override + public RemoteWorksController getRemoteZeppelinServerController() { + return null; + } @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { From 2628a20052390d9b161715d9fa720c52c6a18ffc Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Thu, 17 Nov 2016 17:26:47 +0900 Subject: [PATCH 09/23] fix thrift --- .../src/main/thrift/RemoteInterpreterService.thrift | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift index fb1accbdb01..95e134593c6 100644 --- a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift +++ b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift @@ -50,7 +50,8 @@ enum RemoteInterpreterEventType { OUTPUT_UPDATE = 9, ANGULAR_REGISTRY_PUSH = 10, APP_STATUS_UPDATE = 11, - REMOTE_ZEPPELIN_SERVER_CONTROL = 12 + META_INFOS = 12, + REMOTE_ZEPPELIN_SERVER_CONTROL = 13 } From 4b1ef0886713597666ae0761254d772e61c2565b Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Thu, 17 Nov 2016 17:28:11 +0900 Subject: [PATCH 10/23] fix thrift interface --- .../thrift/InterpreterCompletion.java | 2 +- .../thrift/RemoteApplicationResult.java | 2 +- .../thrift/RemoteInterpreterContext.java | 2 +- .../thrift/RemoteInterpreterEvent.java | 2 +- .../thrift/RemoteInterpreterEventType.java | 95 +++++++++++++++++++ .../thrift/RemoteInterpreterResult.java | 2 +- .../thrift/RemoteInterpreterService.java | 2 +- .../RemoteZeppelinServerController.java | 2 +- .../thrift/ZeppelinServerResource.java | 2 +- ...ZeppelinServerResourceParagraphRunner.java | 2 +- 10 files changed, 104 insertions(+), 9 deletions(-) create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java index d122ae5083c..cc7615e779a 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class InterpreterCompletion implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InterpreterCompletion"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java index b7568218377..95c5cf6ac74 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class RemoteApplicationResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteApplicationResult"); 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 index cd9cc46f544..5ad8a03cad3 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class RemoteInterpreterContext implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java index de56431f505..4bfbeeb8ec5 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class RemoteInterpreterEvent implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterEvent"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java new file mode 100644 index 00000000000..e6e1e9a7d2e --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java @@ -0,0 +1,95 @@ +/** + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.2) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.zeppelin.interpreter.thrift; + + +import java.util.Map; +import java.util.HashMap; +import org.apache.thrift.TEnum; + +public enum RemoteInterpreterEventType implements org.apache.thrift.TEnum { + NO_OP(1), + ANGULAR_OBJECT_ADD(2), + ANGULAR_OBJECT_UPDATE(3), + ANGULAR_OBJECT_REMOVE(4), + RUN_INTERPRETER_CONTEXT_RUNNER(5), + RESOURCE_POOL_GET_ALL(6), + RESOURCE_GET(7), + OUTPUT_APPEND(8), + OUTPUT_UPDATE(9), + ANGULAR_REGISTRY_PUSH(10), + APP_STATUS_UPDATE(11), + META_INFOS(12), + REMOTE_ZEPPELIN_SERVER_CONTROL(13); + + private final int value; + + private RemoteInterpreterEventType(int value) { + this.value = value; + } + + /** + * Get the integer value of this enum value, as defined in the Thrift IDL. + */ + public int getValue() { + return value; + } + + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static RemoteInterpreterEventType findByValue(int value) { + switch (value) { + case 1: + return NO_OP; + case 2: + return ANGULAR_OBJECT_ADD; + case 3: + return ANGULAR_OBJECT_UPDATE; + case 4: + return ANGULAR_OBJECT_REMOVE; + case 5: + return RUN_INTERPRETER_CONTEXT_RUNNER; + case 6: + return RESOURCE_POOL_GET_ALL; + case 7: + return RESOURCE_GET; + case 8: + return OUTPUT_APPEND; + case 9: + return OUTPUT_UPDATE; + case 10: + return ANGULAR_REGISTRY_PUSH; + case 11: + return APP_STATUS_UPDATE; + case 12: + return META_INFOS; + case 13: + return REMOTE_ZEPPELIN_SERVER_CONTROL; + default: + return null; + } + } +} 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 index 289b6fc8f49..edb0b0b056c 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class RemoteInterpreterResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java index 5793c010368..81beb633b89 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class RemoteInterpreterService { public interface Iface { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java index 1cb80116b1c..2f300fe619d 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class RemoteZeppelinServerController implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteZeppelinServerController"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java index 60c5927e497..9b00bd62572 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class ZeppelinServerResource implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResource"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java index 88e75b35c28..490a29cbd3c 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-14") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResourceParagraphRunner"); From c074f0751fb5a435f216fe0147ae4942bcc59173 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Thu, 17 Nov 2016 18:35:16 +0900 Subject: [PATCH 11/23] fix sio support --- .../scala/org/apache/zeppelin/scio/ScioInterpreter.scala | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala b/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala index 00d011f0129..ebe81a60102 100644 --- a/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala +++ b/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala @@ -26,6 +26,7 @@ import com.google.cloud.dataflow.sdk.runners.inprocess.InProcessPipelineRunner import com.spotify.scio.repl.{ScioILoop, ScioReplClassLoader} import org.apache.zeppelin.interpreter.Interpreter.FormType import org.apache.zeppelin.interpreter.util.InterpreterOutputStream +import org.apache.zeppelin.interpreter.RemoteWorksController import org.apache.zeppelin.interpreter.{Interpreter, InterpreterContext, InterpreterResult} import org.slf4j.LoggerFactory @@ -153,6 +154,10 @@ class ScioInterpreter(property: Properties) extends Interpreter(property) { REPL.closeInterpreter() } + override def getRemoteZeppelinServerController: RemoteWorksController = null + + override def setRemoteZeppelinServerController(zServer: RemoteWorksController): Unit = {} + override def interpret(code: String, context: InterpreterContext): InterpreterResult = { val paragraphId = context.getParagraphId From 8cbe46cbc84786d8f256a5ea3fbd1681554d2a69 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Fri, 18 Nov 2016 16:23:01 +0900 Subject: [PATCH 12/23] remote remoteworksController in interpreter.java --- .../zeppelin/alluxio/AlluxioInterpreter.java | 9 --- .../zeppelin/angular/AngularInterpreter.java | 9 --- .../bigquery/BigQueryInterpreter.java | 9 --- .../cassandra/CassandraInterpreter.java | 9 --- .../ElasticsearchInterpreter.java | 9 --- .../apache/zeppelin/file/FileInterpreter.java | 10 ---- .../zeppelin/flink/FlinkInterpreter.java | 9 --- .../zeppelin/hbase/HbaseInterpreter.java | 9 --- .../zeppelin/ignite/IgniteInterpreter.java | 9 --- .../zeppelin/ignite/IgniteSqlInterpreter.java | 9 --- .../apache/zeppelin/jdbc/JDBCInterpreter.java | 9 --- .../zeppelin/kylin/KylinInterpreter.java | 9 --- .../apache/zeppelin/lens/LensInterpreter.java | 9 --- .../zeppelin/livy/LivyPySparkInterpreter.java | 9 --- .../zeppelin/livy/LivySparkInterpreter.java | 9 --- .../zeppelin/livy/LivySparkRInterpreter.java | 9 --- .../livy/LivySparkSQLInterpreter.java | 9 --- .../apache/zeppelin/markdown/Markdown.java | 9 --- .../apache/zeppelin/pig/PigInterpreter.java | 9 --- .../zeppelin/pig/PigQueryInterpreter.java | 9 --- .../postgresql/PostgreSqlInterpreter.java | 9 --- .../zeppelin/python/PythonInterpreter.java | 9 --- .../python/PythonInterpreterPandasSql.java | 9 --- .../scalding/ScaldingInterpreter.java | 9 --- .../zeppelin/scio/ScioInterpreter.scala | 6 +- .../zeppelin/shell/ShellInterpreter.java | 9 --- .../apache/zeppelin/spark/DepInterpreter.java | 9 --- .../zeppelin/spark/PySparkInterpreter.java | 9 --- .../zeppelin/spark/SparkInterpreter.java | 12 +--- .../zeppelin/spark/SparkRInterpreter.java | 9 --- .../zeppelin/spark/SparkSqlInterpreter.java | 9 --- .../zeppelin/spark/ZeppelinContext.java | 2 - .../interpreter/ClassloaderInterpreter.java | 9 --- .../zeppelin/interpreter/Interpreter.java | 13 ---- .../interpreter/LazyOpenInterpreter.java | 9 --- .../interpreter/dev/DevInterpreter.java | 9 --- .../interpreter/remote/RemoteInterpreter.java | 14 +---- .../remote/RemoteInterpreterEventPoller.java | 60 ++++++++----------- .../RemoteInterpreterManagedProcess.java | 8 +-- .../remote/RemoteInterpreterProcess.java | 6 +- .../RemoteInterpreterRunningProcess.java | 3 +- .../remote/RemoteInterpreterServer.java | 3 - .../remote/RemoteInterpreterProcessTest.java | 2 +- .../remote/mock/MockInterpreterA.java | 9 --- .../remote/mock/MockInterpreterAngular.java | 9 --- .../remote/mock/MockInterpreterB.java | 9 --- .../remote/mock/MockInterpreterEnv.java | 9 --- .../mock/MockInterpreterOutputStream.java | 9 --- .../mock/MockInterpreterResourcePool.java | 9 --- .../resource/DistributedResourcePoolTest.java | 4 +- .../interpreter/mock/MockInterpreter1.java | 9 --- .../interpreter/mock/MockInterpreter1.java | 9 --- .../interpreter/mock/MockInterpreter11.java | 9 --- .../interpreter/mock/MockInterpreter2.java | 9 --- 54 files changed, 36 insertions(+), 476 deletions(-) diff --git a/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java b/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java index bea45de9d1c..3f504918250 100644 --- a/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java +++ b/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java @@ -86,15 +86,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] lines = splitAndRemoveEmpty(st, "\n"); diff --git a/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java b/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java index 5f8ed2affe0..7fc2df1fac9 100644 --- a/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java +++ b/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java @@ -48,15 +48,6 @@ public void open() { public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { return new InterpreterResult(Code.SUCCESS, Type.ANGULAR, st); diff --git a/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java b/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java index 4a6d27ce4b6..8d15638d311 100644 --- a/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java +++ b/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java @@ -287,15 +287,6 @@ public void close() { service = null; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String sql, InterpreterContext contextInterpreter) { logger.info("Run SQL command '{}'", sql); diff --git a/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java b/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java index 71f4e17ef2a..7b492bb00aa 100644 --- a/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java +++ b/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java @@ -192,15 +192,6 @@ public void close() { cluster.close(); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { return helper.interpret(session, st, context); diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java index 60d8699182a..5f0f7cee36b 100644 --- a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java +++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java @@ -150,15 +150,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext interpreterContext) { logger.info("Run Elasticsearch command '" + cmd + "'"); diff --git a/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java b/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java index 7ed30862ff4..efc9adf4eb6 100644 --- a/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java +++ b/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java @@ -101,16 +101,6 @@ protected String getNewPath(String argument){ // Handle the command handling uniformly across all file systems - - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { logger.info("Run File command '" + cmd + "'"); diff --git a/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java b/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java index 333ed5c2d78..3af09cd68bb 100644 --- a/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java +++ b/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java @@ -238,15 +238,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String line, InterpreterContext context) { if (line == null || line.trim().length() == 0) { diff --git a/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java b/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java index 17f69c916dc..6c2460d6701 100644 --- a/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java +++ b/hbase/src/main/java/org/apache/zeppelin/hbase/HbaseInterpreter.java @@ -110,15 +110,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext interpreterContext) { try { diff --git a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java index 03cf5a3b07e..66dac1b54f2 100644 --- a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java +++ b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteInterpreter.java @@ -275,15 +275,6 @@ public InterpreterResult interpret(String line, InterpreterContext context) { public void cancel(InterpreterContext context) { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - private InterpreterResult interpret(String[] lines) { String[] linesToRun = new String[lines.length + 1]; System.arraycopy(lines, 0, linesToRun, 0, lines.length); diff --git a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java index 685774faf74..08e426782fb 100644 --- a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java +++ b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java @@ -113,15 +113,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { if (connEx != null) { diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java index 9fa6ed8cac9..f42d62901d0 100644 --- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java +++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java @@ -438,15 +438,6 @@ private String replaceReservedChars(boolean isTableResponseType, String str) { return (!isTableResponseType) ? str : str.replace(TAB, WHITESPACE).replace(NEWLINE, WHITESPACE); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { logger.info("Run SQL command '{}'", cmd); diff --git a/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java b/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java index 25dd56e4178..7960cfdf297 100755 --- a/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java +++ b/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java @@ -66,15 +66,6 @@ public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { try { diff --git a/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java b/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java index ba8f01ca441..4b896d4a4b8 100644 --- a/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java +++ b/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java @@ -244,15 +244,6 @@ private String modifyQueryStatement(String st) { return sb.toString(); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String input, InterpreterContext context) { if (input == null || input.length() == 0) { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java index b49a9b28e64..bd342a2e3ed 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivyPySparkInterpreter.java @@ -55,15 +55,6 @@ public void close() { livyHelper.closeSession(userSessionMap); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java index 1cc51cbde3e..9a9dd8080ee 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkInterpreter.java @@ -71,15 +71,6 @@ public void close() { livyHelper.closeSession(userSessionMap); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java index d75b747295e..753b378e9a1 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkRInterpreter.java @@ -55,15 +55,6 @@ public void close() { livyHelper.closeSession(userSessionMap); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java index 823720fb9cb..3d4a0f4e428 100644 --- a/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java +++ b/livy/src/main/java/org/apache/zeppelin/livy/LivySparkSQLInterpreter.java @@ -54,15 +54,6 @@ public void close() { livyHelper.closeSession(userSessionMap); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String line, InterpreterContext interpreterContext) { try { diff --git a/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java b/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java index d0435de38cb..c711083a602 100644 --- a/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java +++ b/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java @@ -85,15 +85,6 @@ public void open() { public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String markdownText, InterpreterContext interpreterContext) { String html; diff --git a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java index 30d25343f43..21649b718d4 100644 --- a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java +++ b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java @@ -70,15 +70,6 @@ public void close() { pigServer = null; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { // remember the origial stdout, because we will redirect stdout to capture diff --git a/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java b/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java index 9cb66e0866b..1a7634a9db4 100644 --- a/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java +++ b/pig/src/main/java/org/apache/zeppelin/pig/PigQueryInterpreter.java @@ -63,15 +63,6 @@ public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { // '-' is invalid for pig alias diff --git a/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java b/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java index d7907fb5878..149854ba7ec 100644 --- a/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java +++ b/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java @@ -280,15 +280,6 @@ private String replaceReservedChars(boolean isTableResponseType, String str) { return (!isTableResponseType) ? str : str.replace(TAB, WhITESPACE).replace(NEWLINE, WhITESPACE); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { logger.info("Run SQL command '{}'", cmd); diff --git a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java index 4f778e9e86b..aa9832f4a79 100644 --- a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java +++ b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreter.java @@ -129,15 +129,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { if (cmd == null || cmd.isEmpty()) { diff --git a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java index ba0092ef00e..8c72fa1b7ea 100644 --- a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java +++ b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java @@ -86,15 +86,6 @@ public void close() { python.close(); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { LOG.info("Running SQL query: '{}' over Pandas DataFrame", st); diff --git a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java index 005cbe0977b..1b76b0662f4 100644 --- a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java +++ b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java @@ -116,15 +116,6 @@ public void close() { interpreter.intp().close(); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { String user = contextInterpreter.getAuthenticationInfo().getUser(); diff --git a/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala b/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala index 8b838517a64..00d011f0129 100644 --- a/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala +++ b/scio/src/main/scala/org/apache/zeppelin/scio/ScioInterpreter.scala @@ -26,7 +26,7 @@ import com.google.cloud.dataflow.sdk.runners.inprocess.InProcessPipelineRunner import com.spotify.scio.repl.{ScioILoop, ScioReplClassLoader} import org.apache.zeppelin.interpreter.Interpreter.FormType import org.apache.zeppelin.interpreter.util.InterpreterOutputStream -import org.apache.zeppelin.interpreter.{Interpreter, InterpreterContext, InterpreterResult, RemoteWorksController} +import org.apache.zeppelin.interpreter.{Interpreter, InterpreterContext, InterpreterResult} import org.slf4j.LoggerFactory import scala.reflect.io.File @@ -153,10 +153,6 @@ class ScioInterpreter(property: Properties) extends Interpreter(property) { REPL.closeInterpreter() } - override def getRemoteZeppelinServerController: RemoteWorksController = null - - override def setRemoteZeppelinServerController(zServer: RemoteWorksController): Unit = {} - override def interpret(code: String, context: InterpreterContext): InterpreterResult = { val paragraphId = context.getParagraphId diff --git a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java index e2bbf658904..1ae64b63d78 100644 --- a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java +++ b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java @@ -70,15 +70,6 @@ public void open() { @Override public void close() {} - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { LOGGER.debug("Run shell command '" + cmd + "'"); diff --git a/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java index d9280f06aa5..ebd2c415a15 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java @@ -192,15 +192,6 @@ private void createIMain() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - private Results.Result interpret(String line) { return (Results.Result) Utils.invokeMethod( intp, diff --git a/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java index 82a4b54da40..2f57ffcb663 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java @@ -307,15 +307,6 @@ public void appendOutput(String message) throws IOException { outputStream.getInterpreterOutput().write(message); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { SparkInterpreter sparkInterpreter = getSparkInterpreter(); diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java index e8ba6442dae..48f3e3d09af 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java @@ -818,7 +818,7 @@ public void open() { hooks = getInterpreterGroup().getInterpreterHookRegistry(); - z = new ZeppelinContext(sc, sqlc, null, dep, hooks, getRemoteZeppelinServerController(), + z = new ZeppelinContext(sc, sqlc, null, dep, hooks, Integer.parseInt(getProperty("zeppelin.spark.maxResult"))); interpret("@transient val _binder = new java.util.HashMap[String, Object]()"); @@ -1065,16 +1065,6 @@ private String getCompletionTargetString(String text, int cursor) { return resultCompletionText; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - this.remoteWorksController = zServer; - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return this.remoteWorksController; - } - /* * this method doesn't work in scala 2.11 * Somehow intp.valueOfTerm returns scala.None always with -Yrepl-class-based option diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java index de327829878..15ce6581698 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkRInterpreter.java @@ -94,15 +94,6 @@ public void open() { renderOptions = getProperty("zeppelin.R.render.options"); } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String lines, InterpreterContext interpreterContext) { diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java index 9ae5667fccd..ab7e8aac32e 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java @@ -81,15 +81,6 @@ public boolean concurrentSQL() { @Override public void close() {} - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { SQLContext sqlc = null; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java index 2b35c673a3c..75c9fc87bf0 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java @@ -76,14 +76,12 @@ public ZeppelinContext(SparkContext sc, SQLContext sql, InterpreterContext interpreterContext, SparkDependencyResolver dep, InterpreterHookRegistry hooks, - RemoteWorksController remoteWorksController, int maxResult) { this.sc = sc; this.sqlContext = sql; this.interpreterContext = interpreterContext; this.dep = dep; this.hooks = hooks; - this.remoteWorksController = remoteWorksController; this.maxResult = maxResult; this.supportedClasses = new ArrayList<>(); try { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java index 5c99d6edb08..e20f7c5427e 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/ClassloaderInterpreter.java @@ -50,15 +50,6 @@ public ClassLoader getClassloader() { return cl; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { ClassLoader oldcl = Thread.currentThread().getContextClassLoader(); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java index 2f48281cc6b..c068e048190 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/Interpreter.java @@ -196,19 +196,6 @@ public InterpreterGroup getInterpreterGroup() { return this.interpreterGroup; } - /** - * setup Remote Zeppelin Server Controller interface - * @param zServer - */ - @ZeppelinApi - public abstract void setRemoteZeppelinServerController(RemoteWorksController zServer); - - /** - * get Remote Zeppelin Server Controller interface - */ - @ZeppelinApi - public abstract RemoteWorksController getRemoteZeppelinServerController(); - public URL[] getClassloaderUrls() { return classloaderUrls; } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java index cf9721709d2..425ae20a4f1 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/LazyOpenInterpreter.java @@ -88,15 +88,6 @@ public boolean isOpen() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { open(); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java index 7b7f7d0af7f..8728d534b8b 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java @@ -74,15 +74,6 @@ public void rerun() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { this.context = context; 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 index 3da5a22c205..b2a4fbef534 100644 --- 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 @@ -45,7 +45,6 @@ public class RemoteInterpreter extends Interpreter { private final RemoteInterpreterProcessListener remoteInterpreterProcessListener; private final ApplicationEventListener applicationEventListener; - private final RemoteWorksController remoteWorksController; Logger logger = LoggerFactory.getLogger(RemoteInterpreter.class); Gson gson = new Gson(); private String interpreterRunner; @@ -196,15 +195,13 @@ public RemoteInterpreterProcess getInterpreterProcess() { connectTimeout, remoteInterpreterProcessListener, applicationEventListener, - remoteWorksController, host, port); } else { // create new remote process remoteProcess = new RemoteInterpreterManagedProcess( interpreterRunner, interpreterPath, localRepoPath, env, connectTimeout, - remoteInterpreterProcessListener, applicationEventListener, - remoteWorksController); + remoteInterpreterProcessListener, applicationEventListener); } intpGroup.setRemoteInterpreterProcess(remoteProcess); @@ -310,15 +307,6 @@ public void close() { } } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { if (logger.isDebugEnabled()) { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index 70e5abf4663..191b39034fe 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -62,15 +62,12 @@ public class RemoteInterpreterEventPoller extends Thread { private RemoteInterpreterProcess interpreterProcess; private InterpreterGroup interpreterGroup; - private RemoteWorksController remoteWorkController; public RemoteInterpreterEventPoller( RemoteInterpreterProcessListener listener, - ApplicationEventListener appListener, - RemoteWorksController remoteWorkController) { + ApplicationEventListener appListener) { this.listener = listener; this.appListener = appListener; - this.remoteWorkController = remoteWorkController; shutdown = false; } @@ -82,14 +79,6 @@ public void setInterpreterGroup(InterpreterGroup interpreterGroup) { this.interpreterGroup = interpreterGroup; } - public RemoteWorksController getRemoteWorkController() { - return remoteWorkController; - } - - public void setRemoteWorkController(RemoteWorksController remoteWorkController) { - this.remoteWorkController = remoteWorkController; - } - @Override public void run() { Client client = null; @@ -243,29 +232,30 @@ private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController e List interpreterContextRunners = new LinkedList<>(); List remoteRunners = new LinkedList<>(); if (event.getType() == RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT) { - ZeppelinServerResourceParagraphRunner runner = gson.fromJson( - event.getMsg(), ZeppelinServerResourceParagraphRunner.class); - - RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); - resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); - resResource.setEventOwnerKey(eventOwnerKey); - if (runner.getParagraphId() != null) { - interpreterContextRunners = remoteWorkController.getRemoteContextRunner( - runner.getNoteId(), runner.getParagraphId()); - } else { - interpreterContextRunners = remoteWorkController.getRemoteContextRunner( - runner.getNoteId()); - } - - for (InterpreterContextRunner r : interpreterContextRunners) { - remoteRunners.add( - new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) - ); - } - - resResource.setMsg(gson.toJson(remoteRunners)); - - interpreterServer.remoteZeppelinServerControlFeedback(resResource); +// ZeppelinServerResourceParagraphRunner runner = gson.fromJson( +// event.getMsg(), ZeppelinServerResourceParagraphRunner.class); +// +// RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); +// resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); +// resResource.setEventOwnerKey(eventOwnerKey); +// if (runner.getParagraphId() != null) { +// +// interpreterContextRunners = remoteWorkController.getRemoteContextRunner( +// runner.getNoteId(), runner.getParagraphId()); +// } else { +// interpreterContextRunners = remoteWorkController.getRemoteContextRunner( +// runner.getNoteId()); +// } +// +// for (InterpreterContextRunner r : interpreterContextRunners) { +// remoteRunners.add( +// new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) +// ); +// } +// +// resResource.setMsg(gson.toJson(remoteRunners)); +// +// interpreterServer.remoteZeppelinServerControlFeedback(resResource); } } catch (Exception e) { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java index 6c6cd748814..6ba0c281652 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java @@ -44,7 +44,6 @@ public class RemoteInterpreterManagedProcess extends RemoteInterpreterProcess private int port = -1; private final String interpreterDir; private final String localRepoDir; - private RemoteWorksController remoteWorksController; private Map env; @@ -55,15 +54,13 @@ public RemoteInterpreterManagedProcess( Map env, int connectTimeout, RemoteInterpreterProcessListener listener, - ApplicationEventListener appListener, - RemoteWorksController remoteWorksController) { - super(new RemoteInterpreterEventPoller(listener, appListener, remoteWorksController), + ApplicationEventListener appListener) { + super(new RemoteInterpreterEventPoller(listener, appListener), connectTimeout); this.interpreterRunner = intpRunner; this.env = env; this.interpreterDir = intpDir; this.localRepoDir = localRepoDir; - this.remoteWorksController = remoteWorksController; } @@ -79,7 +76,6 @@ public RemoteInterpreterManagedProcess( this.env = env; this.interpreterDir = intpDir; this.localRepoDir = localRepoDir; - this.remoteWorksController = remoteInterpreterEventPoller.getRemoteWorkController(); } @Override 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 index d784d3d9605..c7b2205226d 100644 --- 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 @@ -24,7 +24,6 @@ import org.apache.zeppelin.interpreter.Constants; import org.apache.zeppelin.interpreter.InterpreterException; import org.apache.zeppelin.interpreter.InterpreterGroup; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -49,9 +48,8 @@ public abstract class RemoteInterpreterProcess { public RemoteInterpreterProcess( int connectTimeout, RemoteInterpreterProcessListener listener, - ApplicationEventListener appListener, - RemoteWorksController remoteWorksController) { - this(new RemoteInterpreterEventPoller(listener, appListener, remoteWorksController), + ApplicationEventListener appListener) { + this(new RemoteInterpreterEventPoller(listener, appListener), connectTimeout); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java index abaf4dcd501..086aef727d0 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java @@ -33,11 +33,10 @@ public RemoteInterpreterRunningProcess( int connectTimeout, RemoteInterpreterProcessListener listener, ApplicationEventListener appListener, - RemoteWorksController remoteWorksController, String host, int port ) { - super(connectTimeout, listener, appListener, remoteWorksController); + super(connectTimeout, listener, appListener); this.host = host; this.port = port; } 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 index 0fac13d27dd..025934334f7 100644 --- 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 @@ -68,7 +68,6 @@ public class RemoteInterpreterServer InterpreterHookRegistry hookRegistry; DistributedResourcePool resourcePool; private ApplicationLoader appLoader; - private RemoteWorksController remoteServerController; Gson gson = new Gson(); @@ -93,7 +92,6 @@ public RemoteInterpreterServer(int port) throws TTransportException { server = new TThreadPoolServer( new TThreadPoolServer.Args(serverTransport).processor(processor)); remoteWorksResponsePool = Collections.synchronizedMap(new HashMap()); - remoteServerController = new ZeppelinRemoteWorksController(this, remoteWorksResponsePool); } @Override @@ -184,7 +182,6 @@ public void createInterpreter(String interpreterGroupId, String noteId, String replClass.getConstructor(new Class[] {Properties.class}); Interpreter repl = constructor.newInstance(p); repl.setClassloaderUrls(new URL[]{}); - repl.setRemoteZeppelinServerController(remoteServerController); synchronized (interpreterGroup) { List interpreters = interpreterGroup.get(noteId); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java index 7083feb23a2..99ab63b34a7 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessTest.java @@ -43,7 +43,7 @@ public void testStartStop() { InterpreterGroup intpGroup = new InterpreterGroup(); RemoteInterpreterManagedProcess rip = new RemoteInterpreterManagedProcess( INTERPRETER_SCRIPT, "nonexists", "fakeRepo", new HashMap(), - 10 * 1000, null, null, null); + 10 * 1000, null, null); assertFalse(rip.isRunning()); assertEquals(0, rip.referenceCount()); assertEquals(1, rip.reference(intpGroup, "anonymous", false)); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java index bc3b561ac65..7e2c5bef894 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java @@ -56,15 +56,6 @@ public String getLastStatement() { return lastSt; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { try { diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java index 312a87eaa06..7d21f5c6f6c 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java @@ -53,15 +53,6 @@ public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] stmt = st.split(" "); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java index 8b93f731bf4..df957568862 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java @@ -48,15 +48,6 @@ public void open() { public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { MockInterpreterA intpA = getInterpreterA(); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java index 7d87221c0e0..10146b85161 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterEnv.java @@ -48,15 +48,6 @@ public void open() { public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] cmd = st.split(" "); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java index ca1a1413ae4..85a8444b3c2 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterOutputStream.java @@ -57,15 +57,6 @@ public String getLastStatement() { return lastSt; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] ret = st.split(":"); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java index 35397b64f8d..02f628578dc 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java @@ -56,15 +56,6 @@ public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { String[] stmt = st.split(" "); diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java index c2dd972ba63..b76f0635074 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/resource/DistributedResourcePoolTest.java @@ -116,11 +116,11 @@ public void setUp() throws Exception { intp1.open(); intp2.open(); - eventPoller1 = new RemoteInterpreterEventPoller(null, null, null); + eventPoller1 = new RemoteInterpreterEventPoller(null, null); eventPoller1.setInterpreterGroup(intpGroup1); eventPoller1.setInterpreterProcess(intpGroup1.getRemoteInterpreterProcess()); - eventPoller2 = new RemoteInterpreterEventPoller(null, null, null); + eventPoller2 = new RemoteInterpreterEventPoller(null, null); eventPoller2.setInterpreterGroup(intpGroup2); eventPoller2.setInterpreterProcess(intpGroup2.getRemoteInterpreterProcess()); diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java b/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java index c8b7bbe7fc4..f4574131da4 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java @@ -44,15 +44,6 @@ public void open() { public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { return new InterpreterResult(InterpreterResult.Code.SUCCESS, "repl1: "+st); diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java index cbbd6065214..b2340b1f198 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java @@ -54,15 +54,6 @@ public boolean isOpen() { return open; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { InterpreterResult result; diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java index e8bdc941696..2abb2da3093 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java @@ -45,15 +45,6 @@ public void open() { public void close() { } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { return new InterpreterResult(InterpreterResult.Code.SUCCESS, "repl11: "+st); diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java index 4335ca8410f..d52bfbeaf7d 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java @@ -53,15 +53,6 @@ public boolean isOpen() { return open; } - @Override - public void setRemoteZeppelinServerController(RemoteWorksController zServer) { - } - - @Override - public RemoteWorksController getRemoteZeppelinServerController() { - return null; - } - @Override public InterpreterResult interpret(String st, InterpreterContext context) { InterpreterResult result; From 9ab05afe14971daaa8e4d2ab1a7d1ad04afc979f Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Fri, 18 Nov 2016 23:32:33 +0900 Subject: [PATCH 13/23] Change structure and remove remoteWorksManager --- .../zeppelin/angular/AngularInterpreter.java | 1 - .../ElasticsearchInterpreter.java | 1 - .../apache/zeppelin/file/FileInterpreter.java | 1 - .../zeppelin/spark/ZeppelinContext.java | 13 +- .../interpreter/InterpreterContext.java | 30 +- .../remote/RemoteInterpreterEventClient.java | 4 +- .../remote/RemoteInterpreterEventPoller.java | 97 ++- .../RemoteInterpreterProcessListener.java | 10 + .../remote/RemoteInterpreterServer.java | 29 +- .../thrift/InterpreterCompletion.java | 2 +- .../thrift/RemoteApplicationResult.java | 2 +- .../thrift/RemoteInterpreterContext.java | 2 +- .../thrift/RemoteInterpreterEvent.java | 2 +- .../thrift/RemoteInterpreterEventType.java | 4 +- .../thrift/RemoteInterpreterResult.java | 2 +- .../thrift/RemoteInterpreterService.java | 202 +++--- .../RemoteZeppelinServerControlEvent.java | 62 -- .../RemoteZeppelinServerController.java | 133 +--- .../RemoteZeppelinServerResourceType.java | 59 -- .../thrift/ZeppelinServerResource.java | 641 ------------------ ...ZeppelinServerResourceParagraphRunner.java | 2 +- .../thrift/RemoteInterpreterService.thrift | 23 +- .../RemoteInterpreterOutputTestStream.java | 5 + .../scheduler/RemoteSchedulerTest.java | 5 + .../zeppelin/server/ZeppelinServer.java | 5 - .../zeppelin/socket/NotebookServer.java | 33 + .../interpreter/InterpreterFactory.java | 10 - .../remoteworks/RemoteWorksManager.java | 95 --- 28 files changed, 290 insertions(+), 1185 deletions(-) delete mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java delete mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java delete mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java delete mode 100644 zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java diff --git a/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java b/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java index 7fc2df1fac9..f8ff350d096 100644 --- a/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java +++ b/angular/src/main/java/org/apache/zeppelin/angular/AngularInterpreter.java @@ -26,7 +26,6 @@ import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.InterpreterResult.Type; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java index 5f0f7cee36b..549b5f25efd 100644 --- a/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java +++ b/elasticsearch/src/main/java/org/apache/zeppelin/elasticsearch/ElasticsearchInterpreter.java @@ -37,7 +37,6 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.elasticsearch.action.delete.DeleteResponse; import org.elasticsearch.action.get.GetResponse; diff --git a/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java b/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java index efc9adf4eb6..9aa36058222 100644 --- a/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java +++ b/file/src/main/java/org/apache/zeppelin/file/FileInterpreter.java @@ -23,7 +23,6 @@ import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.InterpreterResult.Type; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java index 75c9fc87bf0..31b261892da 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java @@ -70,7 +70,6 @@ public class ZeppelinContext { private int maxResult; private List supportedClasses; private InterpreterHookRegistry hooks; - private RemoteWorksController remoteWorksController; public ZeppelinContext(SparkContext sc, SQLContext sql, InterpreterContext interpreterContext, @@ -328,7 +327,8 @@ public void run(String noteId, String paragraphId, InterpreterContext context) { throw new InterpreterException("Can not run current Paragraph"); } - List runners = getInterpreterContextRunner(noteId, paragraphId); + List runners = + getInterpreterContextRunner(noteId, paragraphId, context); if (runners.size() <= 0) { throw new InterpreterException("Paragraph " + paragraphId + " not found " + runners.size()); @@ -346,8 +346,10 @@ public void run(String noteId, String paragraphId, InterpreterContext context) { * @param noteId */ @ZeppelinApi - public List getInterpreterContextRunner(String noteId) { + public List getInterpreterContextRunner( + String noteId, InterpreterContext interpreterContext) { List runners = new LinkedList<>(); + RemoteWorksController remoteWorksController = interpreterContext.getRemoteWorksController(); if (remoteWorksController != null) { runners = remoteWorksController.getRemoteContextRunner(noteId); @@ -363,8 +365,9 @@ public List getInterpreterContextRunner(String noteId) */ @ZeppelinApi public List getInterpreterContextRunner( - String noteId, String paragraphId) { + String noteId, String paragraphId, InterpreterContext interpreterContext) { List runners = new LinkedList<>(); + RemoteWorksController remoteWorksController = interpreterContext.getRemoteWorksController(); if (remoteWorksController != null) { runners = remoteWorksController.getRemoteContextRunner(noteId, paragraphId); @@ -389,7 +392,7 @@ public void run(int idx) { * @param context interpreter context */ public void run(String noteId, int idx, InterpreterContext context) { - List runners = getInterpreterContextRunner(noteId); + List runners = getInterpreterContextRunner(noteId, context); if (idx >= runners.size()) { throw new InterpreterException("Index out of bound"); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/InterpreterContext.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/InterpreterContext.java index f8c9032e291..d0e2e4edc6a 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/InterpreterContext.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/InterpreterContext.java @@ -60,6 +60,7 @@ public static void remove() { private List runners; private String className; private RemoteEventClientWrapper client; + private RemoteWorksController remoteWorksController; public InterpreterContext(String noteId, String paragraphId, @@ -73,6 +74,23 @@ public InterpreterContext(String noteId, List runners, InterpreterOutput out ) { + this(noteId, paragraphId, paragraphTitle, paragraphText, authenticationInfo, config, gui, + angularObjectRegistry, resourcePool, runners, out, null); + } + + public InterpreterContext(String noteId, + String paragraphId, + String paragraphTitle, + String paragraphText, + AuthenticationInfo authenticationInfo, + Map config, + GUI gui, + AngularObjectRegistry angularObjectRegistry, + ResourcePool resourcePool, + List runners, + InterpreterOutput out, + RemoteWorksController remoteWorksController + ) { this.noteId = noteId; this.paragraphId = paragraphId; this.paragraphTitle = paragraphTitle; @@ -84,6 +102,7 @@ public InterpreterContext(String noteId, this.resourcePool = resourcePool; this.runners = runners; this.out = out; + this.remoteWorksController = remoteWorksController; } public InterpreterContext(String noteId, @@ -97,9 +116,10 @@ public InterpreterContext(String noteId, ResourcePool resourcePool, List contextRunners, InterpreterOutput output, + RemoteWorksController remoteWorksController, RemoteInterpreterEventClient eventClient) { this(noteId, paragraphId, paragraphTitle, paragraphText, authenticationInfo, config, gui, - angularObjectRegistry, resourcePool, contextRunners, output); + angularObjectRegistry, resourcePool, contextRunners, output, remoteWorksController); this.client = new RemoteEventClient(eventClient); } @@ -154,4 +174,12 @@ public void setClassName(String className) { public RemoteEventClientWrapper getClient() { return client; } + + public RemoteWorksController getRemoteWorksController() { + return remoteWorksController; + } + + public void setRemoteWorksController(RemoteWorksController remoteWorksController) { + this.remoteWorksController = remoteWorksController; + } } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java index e47357d5fe5..576dada3657 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java @@ -21,7 +21,6 @@ import org.apache.zeppelin.interpreter.InterpreterContextRunner; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; -import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent; import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; import org.apache.zeppelin.interpreter.thrift.ZeppelinServerResourceParagraphRunner; import org.apache.zeppelin.resource.*; @@ -58,12 +57,11 @@ public class RemoteInterpreterEventClient implements ResourcePoolConnector { public void getZeppelinServerNoteRunner( String eventOwnerKey, ZeppelinServerResourceParagraphRunner runner) { RemoteZeppelinServerController eventBody = new RemoteZeppelinServerController(); - eventBody.setType(RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT); eventBody.setEventOwnerKey(eventOwnerKey); eventBody.setMsg(gson.toJson(runner)); sendEvent(new RemoteInterpreterEvent( - RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_CONTROL, + RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT, gson.toJson(eventBody))); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index 191b39034fe..d983d84a549 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -29,7 +29,6 @@ import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; -import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent; import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; import org.apache.zeppelin.interpreter.thrift.ZeppelinServerResourceParagraphRunner; import org.apache.zeppelin.resource.Resource; @@ -199,10 +198,14 @@ public void run() { String status = appStatusUpdate.get("status"); appListener.onStatusChange(noteId, paragraphId, appId, status); - } else if (event.getType() == RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_CONTROL) { + } else if (event.getType() == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { + //clover RemoteZeppelinServerController remoteControlEvent = gson.fromJson( event.getData(), RemoteZeppelinServerController.class); - progressRemoteZeppelinControlEvent(remoteControlEvent); + progressRemoteZeppelinControlEvent(event.getType(), listener, remoteControlEvent); + + + } else if (event.getType() == RemoteInterpreterEventType.META_INFOS) { Map metaInfos = gson.fromJson(event.getData(), new TypeToken>() { @@ -222,49 +225,69 @@ public void run() { } } - private void progressRemoteZeppelinControlEvent(RemoteZeppelinServerController event) { - Gson gson = new Gson(); - String eventOwnerKey = event.getEventOwnerKey(); - Client interpreterServer = null; + private void progressRemoteZeppelinControlEvent( + RemoteInterpreterEventType event, + RemoteInterpreterProcessListener remoteWorksEventListener, + RemoteZeppelinServerController data) { boolean broken = false; + final Gson gson = new Gson(); + String eventOwnerKey = data.getEventOwnerKey(); + Client interpreterServerMain = null; try { - interpreterServer = interpreterProcess.getClient(); - List interpreterContextRunners = new LinkedList<>(); - List remoteRunners = new LinkedList<>(); - if (event.getType() == RemoteZeppelinServerControlEvent.REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT) { -// ZeppelinServerResourceParagraphRunner runner = gson.fromJson( -// event.getMsg(), ZeppelinServerResourceParagraphRunner.class); -// -// RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); -// resResource.setType(RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT); -// resResource.setEventOwnerKey(eventOwnerKey); -// if (runner.getParagraphId() != null) { -// -// interpreterContextRunners = remoteWorkController.getRemoteContextRunner( -// runner.getNoteId(), runner.getParagraphId()); -// } else { -// interpreterContextRunners = remoteWorkController.getRemoteContextRunner( -// runner.getNoteId()); -// } -// -// for (InterpreterContextRunner r : interpreterContextRunners) { -// remoteRunners.add( -// new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) -// ); -// } -// -// resResource.setMsg(gson.toJson(remoteRunners)); -// -// interpreterServer.remoteZeppelinServerControlFeedback(resResource); + interpreterServerMain = interpreterProcess.getClient(); + final Client eventClient = interpreterServerMain; + if (event == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { + final List remoteRunners = new LinkedList<>(); + + ZeppelinServerResourceParagraphRunner runner = gson.fromJson( + data.getMsg(), ZeppelinServerResourceParagraphRunner.class); + final RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); + resResource.setEventOwnerKey(eventOwnerKey); + + remoteWorksEventListener.onGetParagraphRunners(runner.getNoteId(), runner.getParagraphId(), + new RemoteInterpreterProcessListener.RemoteWorksEventListener() { + @Override + public void onFinished(Object resultObject) { + logger.info("clover on Finished!!! send event finished"); + boolean clientBroken = false; + if (resultObject != null && resultObject instanceof List) { + List runnerList = + (List) resultObject; + for (InterpreterContextRunner r : runnerList) { + remoteRunners.add( + new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) + ); + } + resResource.setMsg(gson.toJson(remoteRunners)); + RemoteInterpreterEvent response = new RemoteInterpreterEvent( + RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT, + gson.toJson(resResource)); + try { + logger.info("clover send event finished"); + eventClient.onReceivedResourceParagraphRunners(response); + } catch (Exception e) { + clientBroken = true; + logger.error("Can't get RemoteInterpreterEvent", e); + waitQuietly(); + } finally { + interpreterProcess.releaseClient(eventClient, clientBroken); + } + } + } + + @Override + public void onError() { + logger.info("clover onError"); + } + }); } - } catch (Exception e) { broken = true; logger.error("Can't get RemoteInterpreterEvent", e); waitQuietly(); } finally { - interpreterProcess.releaseClient(interpreterServer, broken); + interpreterProcess.releaseClient(interpreterServerMain, broken); } if (broken == true) { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java index d25683f0cf8..eef00aeac88 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java @@ -25,4 +25,14 @@ public interface RemoteInterpreterProcessListener { public void onOutputAppend(String noteId, String paragraphId, String output); public void onOutputUpdated(String noteId, String paragraphId, String output); public void onMetaInfosReceived(String settingId, Map metaInfos); + public void onGetParagraphRunners( + String noteId, String paragraphId, RemoteWorksEventListener callback); + + /** + * Remote works for Interpreter callback listener + */ + public interface RemoteWorksEventListener { + public void onFinished(Object resultObject); + public void onError(); + } } 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 index 025934334f7..f2823c76e54 100644 --- 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 @@ -83,6 +83,7 @@ public class RemoteInterpreterServer Collections.synchronizedMap(new HashMap()); private Map remoteWorksResponsePool; + private ZeppelinRemoteWorksController remoteWorksController; public RemoteInterpreterServer(int port) throws TTransportException { this.port = port; @@ -92,6 +93,7 @@ public RemoteInterpreterServer(int port) throws TTransportException { server = new TThreadPoolServer( new TThreadPoolServer.Args(serverTransport).processor(processor)); remoteWorksResponsePool = Collections.synchronizedMap(new HashMap()); + remoteWorksController = new ZeppelinRemoteWorksController(this, remoteWorksResponsePool); } @Override @@ -342,18 +344,30 @@ public RemoteInterpreterResult interpret(String noteId, String className, String } @Override - public void remoteZeppelinServerControlFeedback( - RemoteZeppelinServerController response) throws TException { + public void onReceivedResourceParagraphRunners( + RemoteInterpreterEvent response) throws TException { + //clover logger.info("remote zeppelin server controller feedback {}", response); - if (response.getType() == RemoteZeppelinServerControlEvent.RES_RESOURCE_PARAGRAPH_RUN_CONTEXT) { + if (response.getType() == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { List intpContextRunners = new LinkedList<>(); - List runners = gson.fromJson(response.getMsg(), - new TypeToken>() {}.getType()); + + RemoteZeppelinServerController remoteZeppelinServerController = gson.fromJson( + response.getData(), RemoteZeppelinServerController.class); + + if (remoteZeppelinServerController == null) { + throw new TException("can not found Resource paragraph runners"); + } + + List runners = gson.fromJson( + remoteZeppelinServerController.getMsg(), + new TypeToken>() {}.getType()); for (ZeppelinServerResourceParagraphRunner r : runners) { intpContextRunners.add(new ParagraphRunner(this, r.getNoteId(), r.getParagraphId())); } synchronized (this.remoteWorksResponsePool) { - this.remoteWorksResponsePool.put(response.getEventOwnerKey(), intpContextRunners); + this.remoteWorksResponsePool.put( + remoteZeppelinServerController.getEventOwnerKey(), + intpContextRunners); } } } @@ -573,7 +587,7 @@ private InterpreterContext convert(RemoteInterpreterContext ric, InterpreterOutp gson.fromJson(ric.getGui(), GUI.class), interpreterGroup.getAngularObjectRegistry(), interpreterGroup.getResourcePool(), - contextRunners, output, eventClient); + contextRunners, output, remoteWorksController, eventClient); } @@ -611,6 +625,7 @@ public void run() { } static class ZeppelinRemoteWorksController implements RemoteWorksController{ + //cloverhearts Logger logger = LoggerFactory.getLogger(ZeppelinRemoteWorksController.class); private final long DEFAULT_TIMEOUT_VALUE = 300000; diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java index cc7615e779a..614634e5ffc 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class InterpreterCompletion implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InterpreterCompletion"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java index 95c5cf6ac74..8ca738dfe1f 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class RemoteApplicationResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteApplicationResult"); 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 index 5ad8a03cad3..83899fb3d99 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class RemoteInterpreterContext implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java index 4bfbeeb8ec5..2e2ee2559ce 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class RemoteInterpreterEvent implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterEvent"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java index e6e1e9a7d2e..dcf1eb26541 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java @@ -41,7 +41,7 @@ public enum RemoteInterpreterEventType implements org.apache.thrift.TEnum { ANGULAR_REGISTRY_PUSH(10), APP_STATUS_UPDATE(11), META_INFOS(12), - REMOTE_ZEPPELIN_SERVER_CONTROL(13); + RESOURCE_PARAGRAPH_RUN_CONTEXT(13); private final int value; @@ -87,7 +87,7 @@ public static RemoteInterpreterEventType findByValue(int value) { case 12: return META_INFOS; case 13: - return REMOTE_ZEPPELIN_SERVER_CONTROL; + return RESOURCE_PARAGRAPH_RUN_CONTEXT; default: return null; } 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 index edb0b0b056c..f46fa7ed43a 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class RemoteInterpreterResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java index 81beb633b89..bdcb4846c31 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class RemoteInterpreterService { public interface Iface { @@ -102,7 +102,7 @@ public interface Iface { public RemoteApplicationResult runApplication(String applicationInstanceId) throws org.apache.thrift.TException; - public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response) throws org.apache.thrift.TException; + public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response) throws org.apache.thrift.TException; } @@ -154,7 +154,7 @@ public interface AsyncIface { public void runApplication(String applicationInstanceId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; } @@ -704,23 +704,23 @@ public RemoteApplicationResult recv_runApplication() throws org.apache.thrift.TE throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "runApplication failed: unknown result"); } - public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response) throws org.apache.thrift.TException + public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response) throws org.apache.thrift.TException { - send_remoteZeppelinServerControlFeedback(response); - recv_remoteZeppelinServerControlFeedback(); + send_onReceivedResourceParagraphRunners(response); + recv_onReceivedResourceParagraphRunners(); } - public void send_remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response) throws org.apache.thrift.TException + public void send_onReceivedResourceParagraphRunners(RemoteInterpreterEvent response) throws org.apache.thrift.TException { - remoteZeppelinServerControlFeedback_args args = new remoteZeppelinServerControlFeedback_args(); + onReceivedResourceParagraphRunners_args args = new onReceivedResourceParagraphRunners_args(); args.setResponse(response); - sendBase("remoteZeppelinServerControlFeedback", args); + sendBase("onReceivedResourceParagraphRunners", args); } - public void recv_remoteZeppelinServerControlFeedback() throws org.apache.thrift.TException + public void recv_onReceivedResourceParagraphRunners() throws org.apache.thrift.TException { - remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); - receiveBase(result, "remoteZeppelinServerControlFeedback"); + onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); + receiveBase(result, "onReceivedResourceParagraphRunners"); return; } @@ -1568,23 +1568,23 @@ public RemoteApplicationResult getResult() throws org.apache.thrift.TException { } } - public void remoteZeppelinServerControlFeedback(RemoteZeppelinServerController response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); - remoteZeppelinServerControlFeedback_call method_call = new remoteZeppelinServerControlFeedback_call(response, resultHandler, this, ___protocolFactory, ___transport); + onReceivedResourceParagraphRunners_call method_call = new onReceivedResourceParagraphRunners_call(response, resultHandler, this, ___protocolFactory, ___transport); this.___currentMethod = method_call; ___manager.call(method_call); } - public static class remoteZeppelinServerControlFeedback_call extends org.apache.thrift.async.TAsyncMethodCall { - private RemoteZeppelinServerController response; - public remoteZeppelinServerControlFeedback_call(RemoteZeppelinServerController response, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + public static class onReceivedResourceParagraphRunners_call extends org.apache.thrift.async.TAsyncMethodCall { + private RemoteInterpreterEvent response; + public onReceivedResourceParagraphRunners_call(RemoteInterpreterEvent response, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { super(client, protocolFactory, transport, resultHandler, false); this.response = response; } public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("remoteZeppelinServerControlFeedback", org.apache.thrift.protocol.TMessageType.CALL, 0)); - remoteZeppelinServerControlFeedback_args args = new remoteZeppelinServerControlFeedback_args(); + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("onReceivedResourceParagraphRunners", org.apache.thrift.protocol.TMessageType.CALL, 0)); + onReceivedResourceParagraphRunners_args args = new onReceivedResourceParagraphRunners_args(); args.setResponse(response); args.write(prot); prot.writeMessageEnd(); @@ -1596,7 +1596,7 @@ public void getResult() throws org.apache.thrift.TException { } org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_remoteZeppelinServerControlFeedback(); + (new Client(prot)).recv_onReceivedResourceParagraphRunners(); } } @@ -1636,7 +1636,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { - public remoteZeppelinServerControlFeedback() { - super("remoteZeppelinServerControlFeedback"); + public static class onReceivedResourceParagraphRunners extends org.apache.thrift.ProcessFunction { + public onReceivedResourceParagraphRunners() { + super("onReceivedResourceParagraphRunners"); } - public remoteZeppelinServerControlFeedback_args getEmptyArgsInstance() { - return new remoteZeppelinServerControlFeedback_args(); + public onReceivedResourceParagraphRunners_args getEmptyArgsInstance() { + return new onReceivedResourceParagraphRunners_args(); } protected boolean isOneway() { return false; } - public remoteZeppelinServerControlFeedback_result getResult(I iface, remoteZeppelinServerControlFeedback_args args) throws org.apache.thrift.TException { - remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); - iface.remoteZeppelinServerControlFeedback(args.response); + public onReceivedResourceParagraphRunners_result getResult(I iface, onReceivedResourceParagraphRunners_args args) throws org.apache.thrift.TException { + onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); + iface.onReceivedResourceParagraphRunners(args.response); return result; } } @@ -2158,7 +2158,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public remoteZeppelinServerControlFeedback() { - super("remoteZeppelinServerControlFeedback"); + public static class onReceivedResourceParagraphRunners extends org.apache.thrift.AsyncProcessFunction { + public onReceivedResourceParagraphRunners() { + super("onReceivedResourceParagraphRunners"); } - public remoteZeppelinServerControlFeedback_args getEmptyArgsInstance() { - return new remoteZeppelinServerControlFeedback_args(); + public onReceivedResourceParagraphRunners_args getEmptyArgsInstance() { + return new onReceivedResourceParagraphRunners_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Void o) { - remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); + onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -3351,7 +3351,7 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - remoteZeppelinServerControlFeedback_result result = new remoteZeppelinServerControlFeedback_result(); + onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); @@ -3371,8 +3371,8 @@ protected boolean isOneway() { return false; } - public void start(I iface, remoteZeppelinServerControlFeedback_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.remoteZeppelinServerControlFeedback(args.response,resultHandler); + public void start(I iface, onReceivedResourceParagraphRunners_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.onReceivedResourceParagraphRunners(args.response,resultHandler); } } @@ -22129,18 +22129,18 @@ public void read(org.apache.thrift.protocol.TProtocol prot, runApplication_resul } - public static class remoteZeppelinServerControlFeedback_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("remoteZeppelinServerControlFeedback_args"); + public static class onReceivedResourceParagraphRunners_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("onReceivedResourceParagraphRunners_args"); private static final org.apache.thrift.protocol.TField RESPONSE_FIELD_DESC = new org.apache.thrift.protocol.TField("response", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new remoteZeppelinServerControlFeedback_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new remoteZeppelinServerControlFeedback_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new onReceivedResourceParagraphRunners_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new onReceivedResourceParagraphRunners_argsTupleSchemeFactory()); } - public RemoteZeppelinServerController response; // required + public RemoteInterpreterEvent response; // 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 { @@ -22205,16 +22205,16 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.RESPONSE, new org.apache.thrift.meta_data.FieldMetaData("response", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RemoteZeppelinServerController.class))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RemoteInterpreterEvent.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(remoteZeppelinServerControlFeedback_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(onReceivedResourceParagraphRunners_args.class, metaDataMap); } - public remoteZeppelinServerControlFeedback_args() { + public onReceivedResourceParagraphRunners_args() { } - public remoteZeppelinServerControlFeedback_args( - RemoteZeppelinServerController response) + public onReceivedResourceParagraphRunners_args( + RemoteInterpreterEvent response) { this(); this.response = response; @@ -22223,14 +22223,14 @@ public remoteZeppelinServerControlFeedback_args( /** * Performs a deep copy on other. */ - public remoteZeppelinServerControlFeedback_args(remoteZeppelinServerControlFeedback_args other) { + public onReceivedResourceParagraphRunners_args(onReceivedResourceParagraphRunners_args other) { if (other.isSetResponse()) { - this.response = new RemoteZeppelinServerController(other.response); + this.response = new RemoteInterpreterEvent(other.response); } } - public remoteZeppelinServerControlFeedback_args deepCopy() { - return new remoteZeppelinServerControlFeedback_args(this); + public onReceivedResourceParagraphRunners_args deepCopy() { + return new onReceivedResourceParagraphRunners_args(this); } @Override @@ -22238,11 +22238,11 @@ public void clear() { this.response = null; } - public RemoteZeppelinServerController getResponse() { + public RemoteInterpreterEvent getResponse() { return this.response; } - public remoteZeppelinServerControlFeedback_args setResponse(RemoteZeppelinServerController response) { + public onReceivedResourceParagraphRunners_args setResponse(RemoteInterpreterEvent response) { this.response = response; return this; } @@ -22268,7 +22268,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetResponse(); } else { - setResponse((RemoteZeppelinServerController)value); + setResponse((RemoteInterpreterEvent)value); } break; @@ -22301,12 +22301,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof remoteZeppelinServerControlFeedback_args) - return this.equals((remoteZeppelinServerControlFeedback_args)that); + if (that instanceof onReceivedResourceParagraphRunners_args) + return this.equals((onReceivedResourceParagraphRunners_args)that); return false; } - public boolean equals(remoteZeppelinServerControlFeedback_args that) { + public boolean equals(onReceivedResourceParagraphRunners_args that) { if (that == null) return false; @@ -22335,7 +22335,7 @@ public int hashCode() { } @Override - public int compareTo(remoteZeppelinServerControlFeedback_args other) { + public int compareTo(onReceivedResourceParagraphRunners_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -22369,7 +22369,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("remoteZeppelinServerControlFeedback_args("); + StringBuilder sb = new StringBuilder("onReceivedResourceParagraphRunners_args("); boolean first = true; sb.append("response:"); @@ -22407,15 +22407,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class remoteZeppelinServerControlFeedback_argsStandardSchemeFactory implements SchemeFactory { - public remoteZeppelinServerControlFeedback_argsStandardScheme getScheme() { - return new remoteZeppelinServerControlFeedback_argsStandardScheme(); + private static class onReceivedResourceParagraphRunners_argsStandardSchemeFactory implements SchemeFactory { + public onReceivedResourceParagraphRunners_argsStandardScheme getScheme() { + return new onReceivedResourceParagraphRunners_argsStandardScheme(); } } - private static class remoteZeppelinServerControlFeedback_argsStandardScheme extends StandardScheme { + private static class onReceivedResourceParagraphRunners_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -22427,7 +22427,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServe switch (schemeField.id) { case 1: // RESPONSE if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.response = new RemoteZeppelinServerController(); + struct.response = new RemoteInterpreterEvent(); struct.response.read(iprot); struct.setResponseIsSet(true); } else { @@ -22445,7 +22445,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServe struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -22460,16 +22460,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, remoteZeppelinServ } - private static class remoteZeppelinServerControlFeedback_argsTupleSchemeFactory implements SchemeFactory { - public remoteZeppelinServerControlFeedback_argsTupleScheme getScheme() { - return new remoteZeppelinServerControlFeedback_argsTupleScheme(); + private static class onReceivedResourceParagraphRunners_argsTupleSchemeFactory implements SchemeFactory { + public onReceivedResourceParagraphRunners_argsTupleScheme getScheme() { + return new onReceivedResourceParagraphRunners_argsTupleScheme(); } } - private static class remoteZeppelinServerControlFeedback_argsTupleScheme extends TupleScheme { + private static class onReceivedResourceParagraphRunners_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetResponse()) { @@ -22482,11 +22482,11 @@ public void write(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServe } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.response = new RemoteZeppelinServerController(); + struct.response = new RemoteInterpreterEvent(); struct.response.read(iprot); struct.setResponseIsSet(true); } @@ -22495,14 +22495,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServer } - public static class remoteZeppelinServerControlFeedback_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("remoteZeppelinServerControlFeedback_result"); + public static class onReceivedResourceParagraphRunners_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("onReceivedResourceParagraphRunners_result"); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new remoteZeppelinServerControlFeedback_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new remoteZeppelinServerControlFeedback_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new onReceivedResourceParagraphRunners_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new onReceivedResourceParagraphRunners_resultTupleSchemeFactory()); } @@ -22565,20 +22565,20 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(remoteZeppelinServerControlFeedback_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(onReceivedResourceParagraphRunners_result.class, metaDataMap); } - public remoteZeppelinServerControlFeedback_result() { + public onReceivedResourceParagraphRunners_result() { } /** * Performs a deep copy on other. */ - public remoteZeppelinServerControlFeedback_result(remoteZeppelinServerControlFeedback_result other) { + public onReceivedResourceParagraphRunners_result(onReceivedResourceParagraphRunners_result other) { } - public remoteZeppelinServerControlFeedback_result deepCopy() { - return new remoteZeppelinServerControlFeedback_result(this); + public onReceivedResourceParagraphRunners_result deepCopy() { + return new onReceivedResourceParagraphRunners_result(this); } @Override @@ -22611,12 +22611,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof remoteZeppelinServerControlFeedback_result) - return this.equals((remoteZeppelinServerControlFeedback_result)that); + if (that instanceof onReceivedResourceParagraphRunners_result) + return this.equals((onReceivedResourceParagraphRunners_result)that); return false; } - public boolean equals(remoteZeppelinServerControlFeedback_result that) { + public boolean equals(onReceivedResourceParagraphRunners_result that) { if (that == null) return false; @@ -22631,7 +22631,7 @@ public int hashCode() { } @Override - public int compareTo(remoteZeppelinServerControlFeedback_result other) { + public int compareTo(onReceivedResourceParagraphRunners_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -22655,7 +22655,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("remoteZeppelinServerControlFeedback_result("); + StringBuilder sb = new StringBuilder("onReceivedResourceParagraphRunners_result("); boolean first = true; sb.append(")"); @@ -22683,15 +22683,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class remoteZeppelinServerControlFeedback_resultStandardSchemeFactory implements SchemeFactory { - public remoteZeppelinServerControlFeedback_resultStandardScheme getScheme() { - return new remoteZeppelinServerControlFeedback_resultStandardScheme(); + private static class onReceivedResourceParagraphRunners_resultStandardSchemeFactory implements SchemeFactory { + public onReceivedResourceParagraphRunners_resultStandardScheme getScheme() { + return new onReceivedResourceParagraphRunners_resultStandardScheme(); } } - private static class remoteZeppelinServerControlFeedback_resultStandardScheme extends StandardScheme { + private static class onReceivedResourceParagraphRunners_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -22712,7 +22712,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, remoteZeppelinServe struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -22722,21 +22722,21 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, remoteZeppelinServ } - private static class remoteZeppelinServerControlFeedback_resultTupleSchemeFactory implements SchemeFactory { - public remoteZeppelinServerControlFeedback_resultTupleScheme getScheme() { - return new remoteZeppelinServerControlFeedback_resultTupleScheme(); + private static class onReceivedResourceParagraphRunners_resultTupleSchemeFactory implements SchemeFactory { + public onReceivedResourceParagraphRunners_resultTupleScheme getScheme() { + return new onReceivedResourceParagraphRunners_resultTupleScheme(); } } - private static class remoteZeppelinServerControlFeedback_resultTupleScheme extends TupleScheme { + private static class onReceivedResourceParagraphRunners_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, remoteZeppelinServerControlFeedback_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; } } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java deleted file mode 100644 index 44d61abf720..00000000000 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerControlEvent.java +++ /dev/null @@ -1,62 +0,0 @@ -/** - * 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. - */ -/** - * Autogenerated by Thrift Compiler (0.9.2) - * - * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated - */ -package org.apache.zeppelin.interpreter.thrift; - - -import java.util.Map; -import java.util.HashMap; -import org.apache.thrift.TEnum; - -public enum RemoteZeppelinServerControlEvent implements org.apache.thrift.TEnum { - REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT(1), - RES_RESOURCE_PARAGRAPH_RUN_CONTEXT(2); - - private final int value; - - private RemoteZeppelinServerControlEvent(int value) { - this.value = value; - } - - /** - * Get the integer value of this enum value, as defined in the Thrift IDL. - */ - public int getValue() { - return value; - } - - /** - * Find a the enum type by its integer value, as defined in the Thrift IDL. - * @return null if the value is not found. - */ - public static RemoteZeppelinServerControlEvent findByValue(int value) { - switch (value) { - case 1: - return REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT; - case 2: - return RES_RESOURCE_PARAGRAPH_RUN_CONTEXT; - default: - return null; - } - } -} diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java index 2f300fe619d..e73e90a7aeb 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java @@ -51,11 +51,10 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class RemoteZeppelinServerController implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteZeppelinServerController"); - private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)1); private static final org.apache.thrift.protocol.TField EVENT_OWNER_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("eventOwnerKey", 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); @@ -65,21 +64,11 @@ public class RemoteZeppelinServerController implements org.apache.thrift.TBase 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.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, RemoteZeppelinServerControlEvent.class))); tmpMap.put(_Fields.EVENT_OWNER_KEY, new org.apache.thrift.meta_data.FieldMetaData("eventOwnerKey", 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, @@ -159,12 +144,10 @@ public RemoteZeppelinServerController() { } public RemoteZeppelinServerController( - RemoteZeppelinServerControlEvent type, String eventOwnerKey, String msg) { this(); - this.type = type; this.eventOwnerKey = eventOwnerKey; this.msg = msg; } @@ -173,9 +156,6 @@ public RemoteZeppelinServerController( * Performs a deep copy on other. */ public RemoteZeppelinServerController(RemoteZeppelinServerController other) { - if (other.isSetType()) { - this.type = other.type; - } if (other.isSetEventOwnerKey()) { this.eventOwnerKey = other.eventOwnerKey; } @@ -190,43 +170,10 @@ public RemoteZeppelinServerController deepCopy() { @Override public void clear() { - this.type = null; this.eventOwnerKey = null; this.msg = null; } - /** - * - * @see RemoteZeppelinServerControlEvent - */ - public RemoteZeppelinServerControlEvent getType() { - return this.type; - } - - /** - * - * @see RemoteZeppelinServerControlEvent - */ - public RemoteZeppelinServerController setType(RemoteZeppelinServerControlEvent 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 getEventOwnerKey() { return this.eventOwnerKey; } @@ -277,14 +224,6 @@ public void setMsgIsSet(boolean value) { public void setFieldValue(_Fields field, Object value) { switch (field) { - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((RemoteZeppelinServerControlEvent)value); - } - break; - case EVENT_OWNER_KEY: if (value == null) { unsetEventOwnerKey(); @@ -306,9 +245,6 @@ public void setFieldValue(_Fields field, Object value) { public Object getFieldValue(_Fields field) { switch (field) { - case TYPE: - return getType(); - case EVENT_OWNER_KEY: return getEventOwnerKey(); @@ -326,8 +262,6 @@ public boolean isSet(_Fields field) { } switch (field) { - case TYPE: - return isSetType(); case EVENT_OWNER_KEY: return isSetEventOwnerKey(); case MSG: @@ -349,15 +283,6 @@ public boolean equals(RemoteZeppelinServerController that) { if (that == null) 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_eventOwnerKey = true && this.isSetEventOwnerKey(); boolean that_present_eventOwnerKey = true && that.isSetEventOwnerKey(); if (this_present_eventOwnerKey || that_present_eventOwnerKey) { @@ -383,11 +308,6 @@ public boolean equals(RemoteZeppelinServerController that) { public int hashCode() { List list = new ArrayList(); - boolean present_type = true && (isSetType()); - list.add(present_type); - if (present_type) - list.add(type.getValue()); - boolean present_eventOwnerKey = true && (isSetEventOwnerKey()); list.add(present_eventOwnerKey); if (present_eventOwnerKey) @@ -409,16 +329,6 @@ public int compareTo(RemoteZeppelinServerController other) { int lastComparison = 0; - lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); - if (lastComparison != 0) { - return lastComparison; - } - } lastComparison = Boolean.valueOf(isSetEventOwnerKey()).compareTo(other.isSetEventOwnerKey()); if (lastComparison != 0) { return lastComparison; @@ -459,14 +369,6 @@ public String toString() { StringBuilder sb = new StringBuilder("RemoteZeppelinServerController("); boolean first = true; - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - if (!first) sb.append(", "); sb.append("eventOwnerKey:"); if (this.eventOwnerKey == null) { sb.append("null"); @@ -525,14 +427,6 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, RemoteZeppelinServe break; } switch (schemeField.id) { - case 1: // TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent.findByValue(iprot.readI32()); - struct.setTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; case 2: // EVENT_OWNER_KEY if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { struct.eventOwnerKey = iprot.readString(); @@ -564,11 +458,6 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, RemoteZeppelinServ struct.validate(); oprot.writeStructBegin(STRUCT_DESC); - if (struct.type != null) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeI32(struct.type.getValue()); - oprot.writeFieldEnd(); - } if (struct.eventOwnerKey != null) { oprot.writeFieldBegin(EVENT_OWNER_KEY_FIELD_DESC); oprot.writeString(struct.eventOwnerKey); @@ -597,19 +486,13 @@ private static class RemoteZeppelinServerControllerTupleScheme extends TupleSche public void write(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); - if (struct.isSetType()) { - optionals.set(0); - } if (struct.isSetEventOwnerKey()) { - optionals.set(1); + optionals.set(0); } if (struct.isSetMsg()) { - optionals.set(2); - } - oprot.writeBitSet(optionals, 3); - if (struct.isSetType()) { - oprot.writeI32(struct.type.getValue()); + optionals.set(1); } + oprot.writeBitSet(optionals, 2); if (struct.isSetEventOwnerKey()) { oprot.writeString(struct.eventOwnerKey); } @@ -621,16 +504,12 @@ public void write(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServe @Override public void read(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { - struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerControlEvent.findByValue(iprot.readI32()); - struct.setTypeIsSet(true); - } - if (incoming.get(1)) { struct.eventOwnerKey = iprot.readString(); struct.setEventOwnerKeyIsSet(true); } - if (incoming.get(2)) { + if (incoming.get(1)) { struct.msg = iprot.readString(); struct.setMsgIsSet(true); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java deleted file mode 100644 index 114b6864d17..00000000000 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerResourceType.java +++ /dev/null @@ -1,59 +0,0 @@ -/** - * 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. - */ -/** - * Autogenerated by Thrift Compiler (0.9.2) - * - * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated - */ -package org.apache.zeppelin.interpreter.thrift; - - -import java.util.Map; -import java.util.HashMap; -import org.apache.thrift.TEnum; - -public enum RemoteZeppelinServerResourceType implements org.apache.thrift.TEnum { - RESOURCE_PARAGRAPH_RUN_CONTEXT(1); - - private final int value; - - private RemoteZeppelinServerResourceType(int value) { - this.value = value; - } - - /** - * Get the integer value of this enum value, as defined in the Thrift IDL. - */ - public int getValue() { - return value; - } - - /** - * Find a the enum type by its integer value, as defined in the Thrift IDL. - * @return null if the value is not found. - */ - public static RemoteZeppelinServerResourceType findByValue(int value) { - switch (value) { - case 1: - return RESOURCE_PARAGRAPH_RUN_CONTEXT; - default: - return null; - } - } -} diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java deleted file mode 100644 index 9b00bd62572..00000000000 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResource.java +++ /dev/null @@ -1,641 +0,0 @@ -/** - * 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. - */ -/** - * Autogenerated by Thrift Compiler (0.9.2) - * - * 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 org.apache.thrift.async.AsyncMethodCallback; -import org.apache.thrift.server.AbstractNonblockingServer.*; -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 javax.annotation.Generated; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") -public class ZeppelinServerResource implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResource"); - - private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField EVENT_OWNER_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("eventOwnerKey", 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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ZeppelinServerResourceStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ZeppelinServerResourceTupleSchemeFactory()); - } - - /** - * - * @see RemoteZeppelinServerResourceType - */ - public RemoteZeppelinServerResourceType type; // required - public String eventOwnerKey; // required - public String msg; // 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 { - /** - * - * @see RemoteZeppelinServerResourceType - */ - TYPE((short)1, "type"), - EVENT_OWNER_KEY((short)2, "eventOwnerKey"), - MSG((short)3, "msg"); - - private static final Map byName = new HashMap(); - - 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: // TYPE - return TYPE; - case 2: // EVENT_OWNER_KEY - return EVENT_OWNER_KEY; - case 3: // MSG - return MSG; - 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.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, RemoteZeppelinServerResourceType.class))); - tmpMap.put(_Fields.EVENT_OWNER_KEY, new org.apache.thrift.meta_data.FieldMetaData("eventOwnerKey", 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))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ZeppelinServerResource.class, metaDataMap); - } - - public ZeppelinServerResource() { - } - - public ZeppelinServerResource( - RemoteZeppelinServerResourceType type, - String eventOwnerKey, - String msg) - { - this(); - this.type = type; - this.eventOwnerKey = eventOwnerKey; - this.msg = msg; - } - - /** - * Performs a deep copy on other. - */ - public ZeppelinServerResource(ZeppelinServerResource other) { - if (other.isSetType()) { - this.type = other.type; - } - if (other.isSetEventOwnerKey()) { - this.eventOwnerKey = other.eventOwnerKey; - } - if (other.isSetMsg()) { - this.msg = other.msg; - } - } - - public ZeppelinServerResource deepCopy() { - return new ZeppelinServerResource(this); - } - - @Override - public void clear() { - this.type = null; - this.eventOwnerKey = null; - this.msg = null; - } - - /** - * - * @see RemoteZeppelinServerResourceType - */ - public RemoteZeppelinServerResourceType getType() { - return this.type; - } - - /** - * - * @see RemoteZeppelinServerResourceType - */ - public ZeppelinServerResource setType(RemoteZeppelinServerResourceType 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 getEventOwnerKey() { - return this.eventOwnerKey; - } - - public ZeppelinServerResource setEventOwnerKey(String eventOwnerKey) { - this.eventOwnerKey = eventOwnerKey; - return this; - } - - public void unsetEventOwnerKey() { - this.eventOwnerKey = null; - } - - /** Returns true if field eventOwnerKey is set (has been assigned a value) and false otherwise */ - public boolean isSetEventOwnerKey() { - return this.eventOwnerKey != null; - } - - public void setEventOwnerKeyIsSet(boolean value) { - if (!value) { - this.eventOwnerKey = null; - } - } - - public String getMsg() { - return this.msg; - } - - public ZeppelinServerResource 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 void setFieldValue(_Fields field, Object value) { - switch (field) { - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((RemoteZeppelinServerResourceType)value); - } - break; - - case EVENT_OWNER_KEY: - if (value == null) { - unsetEventOwnerKey(); - } else { - setEventOwnerKey((String)value); - } - break; - - case MSG: - if (value == null) { - unsetMsg(); - } else { - setMsg((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case TYPE: - return getType(); - - case EVENT_OWNER_KEY: - return getEventOwnerKey(); - - case MSG: - return getMsg(); - - } - 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 TYPE: - return isSetType(); - case EVENT_OWNER_KEY: - return isSetEventOwnerKey(); - case MSG: - return isSetMsg(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ZeppelinServerResource) - return this.equals((ZeppelinServerResource)that); - return false; - } - - public boolean equals(ZeppelinServerResource that) { - if (that == null) - 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_eventOwnerKey = true && this.isSetEventOwnerKey(); - boolean that_present_eventOwnerKey = true && that.isSetEventOwnerKey(); - if (this_present_eventOwnerKey || that_present_eventOwnerKey) { - if (!(this_present_eventOwnerKey && that_present_eventOwnerKey)) - return false; - if (!this.eventOwnerKey.equals(that.eventOwnerKey)) - 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; - } - - return true; - } - - @Override - public int hashCode() { - List list = new ArrayList(); - - boolean present_type = true && (isSetType()); - list.add(present_type); - if (present_type) - list.add(type.getValue()); - - boolean present_eventOwnerKey = true && (isSetEventOwnerKey()); - list.add(present_eventOwnerKey); - if (present_eventOwnerKey) - list.add(eventOwnerKey); - - boolean present_msg = true && (isSetMsg()); - list.add(present_msg); - if (present_msg) - list.add(msg); - - return list.hashCode(); - } - - @Override - public int compareTo(ZeppelinServerResource other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - - lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetEventOwnerKey()).compareTo(other.isSetEventOwnerKey()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEventOwnerKey()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventOwnerKey, other.eventOwnerKey); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetMsg()).compareTo(other.isSetMsg()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetMsg()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, other.msg); - 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("ZeppelinServerResource("); - boolean first = true; - - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - if (!first) sb.append(", "); - sb.append("eventOwnerKey:"); - if (this.eventOwnerKey == null) { - sb.append("null"); - } else { - sb.append(this.eventOwnerKey); - } - first = false; - if (!first) sb.append(", "); - sb.append("msg:"); - if (this.msg == null) { - sb.append("null"); - } else { - sb.append(this.msg); - } - 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 ZeppelinServerResourceStandardSchemeFactory implements SchemeFactory { - public ZeppelinServerResourceStandardScheme getScheme() { - return new ZeppelinServerResourceStandardScheme(); - } - } - - private static class ZeppelinServerResourceStandardScheme extends StandardScheme { - - public void read(org.apache.thrift.protocol.TProtocol iprot, ZeppelinServerResource 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: // TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerResourceType.findByValue(iprot.readI32()); - struct.setTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // EVENT_OWNER_KEY - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.eventOwnerKey = iprot.readString(); - struct.setEventOwnerKeyIsSet(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; - 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, ZeppelinServerResource struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.type != null) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeI32(struct.type.getValue()); - oprot.writeFieldEnd(); - } - if (struct.eventOwnerKey != null) { - oprot.writeFieldBegin(EVENT_OWNER_KEY_FIELD_DESC); - oprot.writeString(struct.eventOwnerKey); - oprot.writeFieldEnd(); - } - if (struct.msg != null) { - oprot.writeFieldBegin(MSG_FIELD_DESC); - oprot.writeString(struct.msg); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class ZeppelinServerResourceTupleSchemeFactory implements SchemeFactory { - public ZeppelinServerResourceTupleScheme getScheme() { - return new ZeppelinServerResourceTupleScheme(); - } - } - - private static class ZeppelinServerResourceTupleScheme extends TupleScheme { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResource struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetType()) { - optionals.set(0); - } - if (struct.isSetEventOwnerKey()) { - optionals.set(1); - } - if (struct.isSetMsg()) { - optionals.set(2); - } - oprot.writeBitSet(optionals, 3); - if (struct.isSetType()) { - oprot.writeI32(struct.type.getValue()); - } - if (struct.isSetEventOwnerKey()) { - oprot.writeString(struct.eventOwnerKey); - } - if (struct.isSetMsg()) { - oprot.writeString(struct.msg); - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, ZeppelinServerResource struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); - if (incoming.get(0)) { - struct.type = org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerResourceType.findByValue(iprot.readI32()); - struct.setTypeIsSet(true); - } - if (incoming.get(1)) { - struct.eventOwnerKey = iprot.readString(); - struct.setEventOwnerKeyIsSet(true); - } - if (incoming.get(2)) { - struct.msg = iprot.readString(); - struct.setMsgIsSet(true); - } - } - } - -} - diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java index 490a29cbd3c..b2c4764b785 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-17") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResourceParagraphRunner"); diff --git a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift index 95e134593c6..59e5a251712 100644 --- a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift +++ b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift @@ -51,7 +51,7 @@ enum RemoteInterpreterEventType { ANGULAR_REGISTRY_PUSH = 10, APP_STATUS_UPDATE = 11, META_INFOS = 12, - REMOTE_ZEPPELIN_SERVER_CONTROL = 13 + RESOURCE_PARAGRAPH_RUN_CONTEXT = 13 } @@ -65,31 +65,12 @@ struct RemoteApplicationResult { 2: string msg } -/* - remote interpreter process --> request --> zeppelin server - */ -enum RemoteZeppelinServerControlEvent { - REQ_RESOURCE_PARAGRAPH_RUN_CONTEXT = 1, - RES_RESOURCE_PARAGRAPH_RUN_CONTEXT = 2 -} - -enum RemoteZeppelinServerResourceType { - RESOURCE_PARAGRAPH_RUN_CONTEXT = 1 -} - struct ZeppelinServerResourceParagraphRunner { 1: string noteId, 2: string paragraphId } -struct ZeppelinServerResource { - 1: RemoteZeppelinServerResourceType type, - 2: string eventOwnerKey, - 3: string msg -} - struct RemoteZeppelinServerController { - 1: RemoteZeppelinServerControlEvent type, 2: string eventOwnerKey 3: string msg } @@ -142,5 +123,5 @@ service RemoteInterpreterService { RemoteApplicationResult unloadApplication(1: string applicationInstanceId); RemoteApplicationResult runApplication(1: string applicationInstanceId); - void remoteZeppelinServerControlFeedback(1: RemoteZeppelinServerController response); + void onReceivedResourceParagraphRunners(1: RemoteInterpreterEvent response); } diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java index 95a34b9acf7..56e0d45463b 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java @@ -162,4 +162,9 @@ public void onOutputUpdated(String noteId, String paragraphId, String output) { public void onMetaInfosReceived(String settingId, Map metaInfos) { } + + @Override + public void onGetParagraphRunners(String noteId, String paragraphId, RemoteWorksEventListener callback) { + + } } diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java index c67211c5f8b..0d803f3d13e 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java @@ -308,4 +308,9 @@ public void onOutputUpdated(String noteId, String paragraphId, String output) { public void onMetaInfosReceived(String settingId, Map metaInfos) { } + + @Override + public void onGetParagraphRunners(String noteId, String paragraphId, RemoteWorksEventListener callback) { + + } } diff --git a/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java b/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java index b7a086c5031..eec99736073 100644 --- a/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java +++ b/zeppelin-server/src/main/java/org/apache/zeppelin/server/ZeppelinServer.java @@ -39,7 +39,6 @@ import org.apache.zeppelin.notebook.Notebook; import org.apache.zeppelin.notebook.NotebookAuthorization; import org.apache.zeppelin.notebook.repo.NotebookRepoSync; -import org.apache.zeppelin.remoteworks.RemoteWorksManager; import org.apache.zeppelin.rest.ConfigurationsRestApi; import org.apache.zeppelin.rest.CredentialRestApi; import org.apache.zeppelin.rest.HeliumRestApi; @@ -92,7 +91,6 @@ public class ZeppelinServer extends Application { private NotebookAuthorization notebookAuthorization; private Credentials credentials; private DependencyResolver depResolver; - private RemoteWorksManager remoteWorksManager; public ZeppelinServer() throws Exception { ZeppelinConfiguration conf = ZeppelinConfiguration.create(); @@ -120,9 +118,6 @@ public ZeppelinServer() throws Exception { notebook.addNotebookEventListener(heliumApplicationFactory); notebook.addNotebookEventListener(notebookWsServer.getNotebookInformationListener()); - - remoteWorksManager = new RemoteWorksManager(notebook); - replFactory.setRemoteController(remoteWorksManager.getInstance()); } public static void main(String[] args) throws InterruptedException { diff --git a/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java b/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java index c434ffef0fa..c60150d72f0 100644 --- a/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java +++ b/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java @@ -41,6 +41,7 @@ import org.apache.zeppelin.display.AngularObjectRegistryListener; import org.apache.zeppelin.helium.ApplicationEventListener; import org.apache.zeppelin.helium.HeliumPackage; +import org.apache.zeppelin.interpreter.InterpreterContextRunner; import org.apache.zeppelin.interpreter.InterpreterGroup; import org.apache.zeppelin.interpreter.InterpreterOutput; import org.apache.zeppelin.interpreter.InterpreterResult; @@ -1482,6 +1483,38 @@ public void onStatusChange(String noteId, String paragraphId, String appId, Stri broadcast(noteId, msg); } + @Override + public void onGetParagraphRunners( + String noteId, String paragraphId, RemoteWorksEventListener callback) { + LOG.info("clover onGetParagraphRunners {} {}", noteId, paragraphId); + Notebook notebookIns = notebook(); + List runner = new LinkedList<>(); + + if (notebookIns == null) { + callback.onFinished(notebookIns); + } + + try { + Note note = notebookIns.getNote(noteId); + if (note != null) { + if (paragraphId != null) { + Paragraph paragraph = note.getParagraph(paragraphId); + if (paragraph != null) { + runner.add(paragraph.getInterpreterContextRunner()); + } + } else { + for (Paragraph p : note.getParagraphs()) { + runner.add(p.getInterpreterContextRunner()); + } + } + } + callback.onFinished(runner); + } catch (NullPointerException e) { + LOG.warn(e.getMessage()); + callback.onError(); + } + } + /** * Notebook Information Change event */ diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java index 98326dfeaeb..4abc8b027ca 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java @@ -112,8 +112,6 @@ public class InterpreterFactory implements InterpreterGroupFactory { private Map> interpreterBindings = new HashMap<>(); private List interpreterRepositories; - private RemoteWorksController remoteWorksController; - private Gson gson; private InterpreterOption defaultOption; @@ -279,14 +277,6 @@ public boolean accept(Path entry) throws IOException { } } - public RemoteWorksController getRemoteWorksController() { - return remoteWorksController; - } - - public void setRemoteController(RemoteWorksController remoteController) { - this.remoteWorksController = remoteController; - } - private InterpreterSetting createFromInterpreterSettingRef(String name) { Preconditions.checkNotNull(name, "reference name should be not null"); InterpreterSetting settingRef = interpreterSettingsRef.get(name); diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java deleted file mode 100644 index b89e1025067..00000000000 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/remoteworks/RemoteWorksManager.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * 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.remoteworks; - -import org.apache.zeppelin.interpreter.InterpreterContextRunner; -import org.apache.zeppelin.interpreter.RemoteWorksController; -import org.apache.zeppelin.notebook.Note; -import org.apache.zeppelin.notebook.Notebook; -import org.apache.zeppelin.notebook.Paragraph; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.LinkedList; -import java.util.List; - -/** - * Zeppelin Server RemoteWorkController Singleton. - */ -public class RemoteWorksManager { - private static final Logger LOG = LoggerFactory.getLogger(RemoteWorksManager.class); - private static NotebookJobManager instance; - - public RemoteWorksManager(Notebook notebook) { - if (RemoteWorksManager.instance == null) { - RemoteWorksManager.instance = new NotebookJobManager(notebook); - } - } - - public static NotebookJobManager getInstance() { - return RemoteWorksManager.instance; - } - - private class NotebookJobManager implements RemoteWorksController { - private transient Notebook notebook; - - public NotebookJobManager(Notebook notebook) { - setNotebook(notebook); - } - - private void setNotebook(Notebook notebook) { - this.notebook = notebook; - } - - private Notebook getNotebook() throws NullPointerException { - if (notebook == null) { - throw new NullPointerException("Notebook instance is Null"); - } - return notebook; - } - - public List getRemoteContextRunner(String noteId) { - return getRemoteContextRunner(noteId, null); - } - - public List getRemoteContextRunner( - String noteId, String paragraphId) { - List runner = new LinkedList<>(); - try { - Note note = getNotebook().getNote(noteId); - if (note != null) { - if (paragraphId != null) { - Paragraph paragraph = note.getParagraph(paragraphId); - if (paragraph != null) { - runner.add(paragraph.getInterpreterContextRunner()); - } - } else { - for (Paragraph p : note.getParagraphs()) { - runner.add(p.getInterpreterContextRunner()); - } - } - } - } catch (NullPointerException e) { - LOG.warn(e.getMessage()); - } - return runner; - } - - } - -} From 10c2a47047f0fabe23f49418a85e90ac6b5fc0e8 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Mon, 21 Nov 2016 14:53:13 +0900 Subject: [PATCH 14/23] Implement runNote and re implement run method --- .../zeppelin/spark/ZeppelinContext.java | 29 ++++++++++---- .../remote/RemoteInterpreterEventPoller.java | 10 ++--- .../RemoteInterpreterProcessListener.java | 1 + .../remote/RemoteInterpreterServer.java | 3 -- .../RemoteInterpreterOutputTestStream.java | 7 ++++ .../scheduler/RemoteSchedulerTest.java | 7 ++++ .../zeppelin/socket/NotebookServer.java | 38 ++++++++++++++++++- .../apache/zeppelin/notebook/Paragraph.java | 1 + 8 files changed, 78 insertions(+), 18 deletions(-) diff --git a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java index 31b261892da..f4bb0685661 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java @@ -340,6 +340,27 @@ public void run(String noteId, String paragraphId, InterpreterContext context) { } + public void runNote(String noteId) { + runNote(noteId, interpreterContext); + } + + public void runNote(String noteId, InterpreterContext context) { + String runningNoteId = context.getNoteId(); + String runningParagraphId = context.getParagraphId(); + List runners = getInterpreterContextRunner(noteId, context); + + if (runners.size() <= 0) { + throw new InterpreterException("Note " + noteId + " not found " + runners.size()); + } + + for (InterpreterContextRunner r : runners) { + if (r.getNoteId().equals(runningNoteId) && r.getParagraphId().equals(runningParagraphId)) { + continue; + } + r.run(); + } + } + /** * get Zeppelin Paragraph Runner from zeppelin server @@ -440,13 +461,7 @@ public void runAll() { */ @ZeppelinApi public void runAll(InterpreterContext context) { - for (InterpreterContextRunner r : context.getRunners()) { - if (r.getParagraphId().equals(context.getParagraphId())) { - // skip itself - continue; - } - r.run(); - } + runNote(context.getNoteId()); } @ZeppelinApi diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index d983d84a549..d206021f0d2 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -148,8 +148,9 @@ public void run() { InterpreterContextRunner runnerFromRemote = gson.fromJson( event.getData(), RemoteInterpreterContextRunner.class); - interpreterProcess.getInterpreterContextRunnerPool().run( + listener.onRemoteRunParagraph( runnerFromRemote.getNoteId(), runnerFromRemote.getParagraphId()); + } else if (event.getType() == RemoteInterpreterEventType.RESOURCE_POOL_GET_ALL) { ResourceSet resourceSet = getAllResourcePoolExcept(); sendResourcePoolResponseGetAll(resourceSet); @@ -199,13 +200,10 @@ public void run() { appListener.onStatusChange(noteId, paragraphId, appId, status); } else if (event.getType() == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { - //clover RemoteZeppelinServerController remoteControlEvent = gson.fromJson( event.getData(), RemoteZeppelinServerController.class); progressRemoteZeppelinControlEvent(event.getType(), listener, remoteControlEvent); - - } else if (event.getType() == RemoteInterpreterEventType.META_INFOS) { Map metaInfos = gson.fromJson(event.getData(), new TypeToken>() { @@ -248,7 +246,6 @@ private void progressRemoteZeppelinControlEvent( new RemoteInterpreterProcessListener.RemoteWorksEventListener() { @Override public void onFinished(Object resultObject) { - logger.info("clover on Finished!!! send event finished"); boolean clientBroken = false; if (resultObject != null && resultObject instanceof List) { List runnerList = @@ -263,7 +260,6 @@ public void onFinished(Object resultObject) { RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT, gson.toJson(resResource)); try { - logger.info("clover send event finished"); eventClient.onReceivedResourceParagraphRunners(response); } catch (Exception e) { clientBroken = true; @@ -277,7 +273,7 @@ public void onFinished(Object resultObject) { @Override public void onError() { - logger.info("clover onError"); + logger.info("onGetParagraphRunners onError"); } }); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java index eef00aeac88..763e14cf809 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterProcessListener.java @@ -25,6 +25,7 @@ public interface RemoteInterpreterProcessListener { public void onOutputAppend(String noteId, String paragraphId, String output); public void onOutputUpdated(String noteId, String paragraphId, String output); public void onMetaInfosReceived(String settingId, Map metaInfos); + public void onRemoteRunParagraph(String noteId, String ParagraphID) throws Exception; public void onGetParagraphRunners( String noteId, String paragraphId, RemoteWorksEventListener callback); 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 index f2823c76e54..5c4a2dcaef1 100644 --- 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 @@ -346,8 +346,6 @@ public RemoteInterpreterResult interpret(String noteId, String className, String @Override public void onReceivedResourceParagraphRunners( RemoteInterpreterEvent response) throws TException { - //clover - logger.info("remote zeppelin server controller feedback {}", response); if (response.getType() == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { List intpContextRunners = new LinkedList<>(); @@ -625,7 +623,6 @@ public void run() { } static class ZeppelinRemoteWorksController implements RemoteWorksController{ - //cloverhearts Logger logger = LoggerFactory.getLogger(ZeppelinRemoteWorksController.class); private final long DEFAULT_TIMEOUT_VALUE = 300000; diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java index 56e0d45463b..fbd26f72b30 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterOutputTestStream.java @@ -165,6 +165,13 @@ public void onMetaInfosReceived(String settingId, Map metaInfos) @Override public void onGetParagraphRunners(String noteId, String paragraphId, RemoteWorksEventListener callback) { + if (callback != null) { + callback.onFinished(new LinkedList<>()); + } + } + + @Override + public void onRemoteRunParagraph(String noteId, String ParagraphID) throws Exception { } } diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java index 0d803f3d13e..b8e4f388f89 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/scheduler/RemoteSchedulerTest.java @@ -311,6 +311,13 @@ public void onMetaInfosReceived(String settingId, Map metaInfos) @Override public void onGetParagraphRunners(String noteId, String paragraphId, RemoteWorksEventListener callback) { + if (callback != null) { + callback.onFinished(new LinkedList<>()); + } + } + + @Override + public void onRemoteRunParagraph(String noteId, String PsaragraphID) throws Exception { } } diff --git a/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java b/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java index c60150d72f0..1d94a621504 100644 --- a/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java +++ b/zeppelin-server/src/main/java/org/apache/zeppelin/socket/NotebookServer.java @@ -32,6 +32,7 @@ import javax.servlet.http.HttpServletRequest; +import com.google.common.collect.Sets; import org.apache.commons.lang.StringUtils; import org.apache.commons.vfs2.FileSystemException; import org.apache.zeppelin.conf.ZeppelinConfiguration; @@ -60,6 +61,7 @@ import org.apache.zeppelin.notebook.socket.Message; import org.apache.zeppelin.notebook.socket.Message.OP; import org.apache.zeppelin.notebook.socket.WatcherMessage; +import org.apache.zeppelin.rest.exception.ForbiddenException; import org.apache.zeppelin.scheduler.Job; import org.apache.zeppelin.scheduler.Job.Status; import org.apache.zeppelin.server.ZeppelinServer; @@ -1486,11 +1488,11 @@ public void onStatusChange(String noteId, String paragraphId, String appId, Stri @Override public void onGetParagraphRunners( String noteId, String paragraphId, RemoteWorksEventListener callback) { - LOG.info("clover onGetParagraphRunners {} {}", noteId, paragraphId); Notebook notebookIns = notebook(); List runner = new LinkedList<>(); if (notebookIns == null) { + LOG.info("intepreter request notebook instance is null"); callback.onFinished(notebookIns); } @@ -1515,6 +1517,40 @@ public void onGetParagraphRunners( } } + @Override + public void onRemoteRunParagraph(String noteId, String paragraphId) throws Exception { + Notebook notebookIns = notebook(); + try { + if (notebookIns == null) { + throw new Exception("onRemoteRunParagraph notebook instance is null"); + } + Note noteIns = notebookIns.getNote(noteId); + if (noteIns == null) { + throw new Exception(String.format("Can't found note id %s", noteId)); + } + + Paragraph paragraph = noteIns.getParagraph(paragraphId); + if (paragraph == null) { + throw new Exception(String.format("Can't found paragraph %s %s", noteId, paragraphId)); + } + + Set userAndRoles = Sets.newHashSet(); + userAndRoles.add(SecurityUtils.getPrincipal()); + userAndRoles.addAll(SecurityUtils.getRoles()); + if (!notebookIns.getNotebookAuthorization().hasWriteAuthorization(userAndRoles, noteId)) { + throw new ForbiddenException(String.format("can't execute note %s", noteId)); + } + + AuthenticationInfo subject = new AuthenticationInfo(SecurityUtils.getPrincipal()); + paragraph.setAuthenticationInfo(subject); + + noteIns.run(paragraphId); + + } catch (Exception e) { + throw e; + } + } + /** * Notebook Information Change event */ diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java index a6f334eca1a..265c1dcf527 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Paragraph.java @@ -483,6 +483,7 @@ private InterpreterContext getInterpreterContext(InterpreterOutput output) { } public InterpreterContextRunner getInterpreterContextRunner() { + return new ParagraphRunner(note, note.getId(), getId()); } From 292319a8eb59090d31c88b10a23fae54da63970f Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 22 Nov 2016 17:19:09 +0900 Subject: [PATCH 15/23] add test case for extends z.run and z.runNote --- .../rest/ZeppelinSparkClusterTest.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java b/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java index 740ef4066c4..00159770b8b 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java @@ -17,6 +17,7 @@ package org.apache.zeppelin.rest; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertTrue; import java.io.File; @@ -346,6 +347,33 @@ public void zRunTest() throws IOException { assertEquals(Status.FINISHED, p2.getStatus()); assertEquals("10", p2.getResult().message()); + Paragraph p3 = note.addParagraph(); + Map config3 = p3.getConfig(); + config3.put("enabled", true); + p3.setConfig(config3); + p3.setText("%spark println(new java.util.Date())"); + p3.setAuthenticationInfo(anonymous); + + p0.setText(String.format("%%spark z.runNote(\"%s\")", note.getId())); + note.run(p0.getId()); + waitForFinish(p0); + waitForFinish(p1); + waitForFinish(p2); + waitForFinish(p3); + + assertEquals(Status.FINISHED, p3.getStatus()); + String p3result = p3.getResult().message(); + assertNotEquals(null, p3result); + assertNotEquals("", p3result); + + p0.setText(String.format("%%spark z.run(\"%s\", \"%s\")", note.getId(), p3.getId())); + + note.run(p0.getId()); + waitForFinish(p0); + waitForFinish(p3); + + assertNotEquals(p3result, p3.getResult().message()); + ZeppelinServer.notebook.removeNote(note.getId(), anonymous); } From 342752d61fb9cdd4936a42898d06fb920a1a4b9d Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 22 Nov 2016 17:25:05 +0900 Subject: [PATCH 16/23] add document for extends z.run and z.runNote --- docs/displaysystem/front-end-angular.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/docs/displaysystem/front-end-angular.md b/docs/displaysystem/front-end-angular.md index 0e64aae7cb6..973ed88371e 100644 --- a/docs/displaysystem/front-end-angular.md +++ b/docs/displaysystem/front-end-angular.md @@ -150,7 +150,17 @@ How does the front-end AngularJS API compares to the [back-end API](./back-end-a Executing Paragraph z.runParagraph(paragraphId) z.run(paragraphId) - + + + Executing Paragraph (Specific paragraphs in other notes) ( + + z.run(noteid, paragraphId) + + + Executing note + + z.runNote(noteId) + From 7562535a1697d9e40020d650d4f39ac071b39798 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Wed, 23 Nov 2016 22:47:31 +0900 Subject: [PATCH 17/23] remove unused import and asterisk import --- .../java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java | 5 ++++- .../main/java/org/apache/zeppelin/pig/PigInterpreter.java | 1 - .../java/org/apache/zeppelin/spark/SparkInterpreter.java | 2 -- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java b/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java index 3f504918250..79e10b6f95d 100644 --- a/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java +++ b/alluxio/src/main/java/org/apache/zeppelin/alluxio/AlluxioInterpreter.java @@ -23,7 +23,10 @@ import java.io.ByteArrayOutputStream; import java.util.*; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.slf4j.Logger; diff --git a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java index 21649b718d4..706697157e1 100644 --- a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java +++ b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java @@ -25,7 +25,6 @@ import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java index 48f3e3d09af..05c7d53e53b 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java @@ -110,8 +110,6 @@ public class SparkInterpreter extends Interpreter { private SparkDependencyResolver dep; private String sparkUrl; - private RemoteWorksController remoteWorksController; - /** * completer - org.apache.spark.repl.SparkJLineCompletion (scala 2.10) */ From 5ec4640af0e9759172cbae55ec0b9ff8c3bbf61d Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Thu, 24 Nov 2016 02:34:03 +0900 Subject: [PATCH 18/23] change defined protocol for thrift --- .../scalding/ScaldingInterpreter.java | 1 - .../zeppelin/shell/ShellInterpreter.java | 1 - .../zeppelin/spark/SparkInterpreter.java | 1 - .../RemoteZeppelinServerResource.java | 58 ++ .../remote/RemoteInterpreterEventClient.java | 11 +- .../remote/RemoteInterpreterEventPoller.java | 109 ++-- .../RemoteInterpreterManagedProcess.java | 1 - .../RemoteInterpreterRunningProcess.java | 1 - .../remote/RemoteInterpreterServer.java | 50 +- .../thrift/InterpreterCompletion.java | 2 +- .../thrift/RemoteApplicationResult.java | 2 +- .../thrift/RemoteInterpreterContext.java | 2 +- .../thrift/RemoteInterpreterEvent.java | 2 +- .../thrift/RemoteInterpreterEventType.java | 4 +- .../thrift/RemoteInterpreterResult.java | 2 +- .../thrift/RemoteInterpreterService.java | 309 +++++------ .../RemoteZeppelinServerController.java | 520 ------------------ ...ZeppelinServerResourceParagraphRunner.java | 2 +- .../thrift/RemoteInterpreterService.thrift | 9 +- .../interpreter/mock/MockInterpreter1.java | 1 - .../interpreter/mock/MockInterpreter1.java | 1 - .../interpreter/mock/MockInterpreter11.java | 1 - .../interpreter/mock/MockInterpreter2.java | 1 - 23 files changed, 314 insertions(+), 777 deletions(-) create mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteZeppelinServerResource.java delete mode 100644 zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java diff --git a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java index 1b76b0662f4..8f20bc89788 100644 --- a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java +++ b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java @@ -24,7 +24,6 @@ import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java index 1ae64b63d78..3b8aa2b3b4d 100644 --- a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java +++ b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java @@ -36,7 +36,6 @@ import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java index 05c7d53e53b..56cc124fb03 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java @@ -47,7 +47,6 @@ import org.apache.spark.ui.jobs.JobProgressListener; import org.apache.zeppelin.interpreter.*; import org.apache.zeppelin.interpreter.InterpreterResult.Code; -import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; import org.apache.zeppelin.interpreter.InterpreterUtils; import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.util.InterpreterOutputStream; diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteZeppelinServerResource.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteZeppelinServerResource.java new file mode 100644 index 00000000000..b2a87aa8bd5 --- /dev/null +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/RemoteZeppelinServerResource.java @@ -0,0 +1,58 @@ +/* + * 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 Zeppelin Server Resource + */ +public class RemoteZeppelinServerResource { + /** + * Resource Type for Zeppelin Server + */ + public enum Type{ + PARAGRAPH_RUNNERS + } + + private String ownerKey; + private Type resourceType; + private Object data; + + public Type getResourceType() { + return resourceType; + } + + public String getOwnerKey() { + return ownerKey; + } + + public void setOwnerKey(String ownerKey) { + this.ownerKey = ownerKey; + } + + public void setResourceType(Type resourceType) { + this.resourceType = resourceType; + } + + public Object getData() { + return data; + } + + public void setData(Object data) { + this.data = data; + } +} diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java index 576dada3657..867b726e21d 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventClient.java @@ -19,9 +19,9 @@ import com.google.gson.Gson; import org.apache.zeppelin.display.AngularObject; import org.apache.zeppelin.interpreter.InterpreterContextRunner; +import org.apache.zeppelin.interpreter.RemoteZeppelinServerResource; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; -import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; import org.apache.zeppelin.interpreter.thrift.ZeppelinServerResourceParagraphRunner; import org.apache.zeppelin.resource.*; import org.slf4j.Logger; @@ -56,12 +56,13 @@ public class RemoteInterpreterEventClient implements ResourcePoolConnector { */ public void getZeppelinServerNoteRunner( String eventOwnerKey, ZeppelinServerResourceParagraphRunner runner) { - RemoteZeppelinServerController eventBody = new RemoteZeppelinServerController(); - eventBody.setEventOwnerKey(eventOwnerKey); - eventBody.setMsg(gson.toJson(runner)); + RemoteZeppelinServerResource eventBody = new RemoteZeppelinServerResource(); + eventBody.setResourceType(RemoteZeppelinServerResource.Type.PARAGRAPH_RUNNERS); + eventBody.setOwnerKey(eventOwnerKey); + eventBody.setData(runner); sendEvent(new RemoteInterpreterEvent( - RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT, + RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_RESOURCE, gson.toJson(eventBody))); } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java index d206021f0d2..33cc8e4a548 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterEventPoller.java @@ -25,11 +25,10 @@ import org.apache.zeppelin.helium.ApplicationEventListener; import org.apache.zeppelin.interpreter.InterpreterContextRunner; import org.apache.zeppelin.interpreter.InterpreterGroup; -import org.apache.zeppelin.interpreter.RemoteWorksController; +import org.apache.zeppelin.interpreter.RemoteZeppelinServerResource; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEvent; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterEventType; import org.apache.zeppelin.interpreter.thrift.RemoteInterpreterService.Client; -import org.apache.zeppelin.interpreter.thrift.RemoteZeppelinServerController; import org.apache.zeppelin.interpreter.thrift.ZeppelinServerResourceParagraphRunner; import org.apache.zeppelin.resource.Resource; import org.apache.zeppelin.resource.ResourceId; @@ -199,10 +198,11 @@ public void run() { String status = appStatusUpdate.get("status"); appListener.onStatusChange(noteId, paragraphId, appId, status); - } else if (event.getType() == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { - RemoteZeppelinServerController remoteControlEvent = gson.fromJson( - event.getData(), RemoteZeppelinServerController.class); - progressRemoteZeppelinControlEvent(event.getType(), listener, remoteControlEvent); + } else if (event.getType() == RemoteInterpreterEventType.REMOTE_ZEPPELIN_SERVER_RESOURCE) { + RemoteZeppelinServerResource reqResourceBody = gson.fromJson( + event.getData(), RemoteZeppelinServerResource.class); + progressRemoteZeppelinControlEvent( + reqResourceBody.getResourceType(), listener, reqResourceBody); } else if (event.getType() == RemoteInterpreterEventType.META_INFOS) { Map metaInfos = gson.fromJson(event.getData(), @@ -224,58 +224,70 @@ public void run() { } private void progressRemoteZeppelinControlEvent( - RemoteInterpreterEventType event, + RemoteZeppelinServerResource.Type resourceType, RemoteInterpreterProcessListener remoteWorksEventListener, - RemoteZeppelinServerController data) { + RemoteZeppelinServerResource reqResourceBody) throws Exception { boolean broken = false; final Gson gson = new Gson(); - String eventOwnerKey = data.getEventOwnerKey(); + final String eventOwnerKey = reqResourceBody.getOwnerKey(); Client interpreterServerMain = null; try { interpreterServerMain = interpreterProcess.getClient(); final Client eventClient = interpreterServerMain; - if (event == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { + if (resourceType == RemoteZeppelinServerResource.Type.PARAGRAPH_RUNNERS) { final List remoteRunners = new LinkedList<>(); - ZeppelinServerResourceParagraphRunner runner = gson.fromJson( - data.getMsg(), ZeppelinServerResourceParagraphRunner.class); - final RemoteZeppelinServerController resResource = new RemoteZeppelinServerController(); - resResource.setEventOwnerKey(eventOwnerKey); - - remoteWorksEventListener.onGetParagraphRunners(runner.getNoteId(), runner.getParagraphId(), - new RemoteInterpreterProcessListener.RemoteWorksEventListener() { - @Override - public void onFinished(Object resultObject) { - boolean clientBroken = false; - if (resultObject != null && resultObject instanceof List) { - List runnerList = - (List) resultObject; - for (InterpreterContextRunner r : runnerList) { - remoteRunners.add( - new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) - ); - } - resResource.setMsg(gson.toJson(remoteRunners)); - RemoteInterpreterEvent response = new RemoteInterpreterEvent( - RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT, - gson.toJson(resResource)); - try { - eventClient.onReceivedResourceParagraphRunners(response); - } catch (Exception e) { - clientBroken = true; - logger.error("Can't get RemoteInterpreterEvent", e); - waitQuietly(); - } finally { - interpreterProcess.releaseClient(eventClient, clientBroken); + ZeppelinServerResourceParagraphRunner reqRunnerContext = + new ZeppelinServerResourceParagraphRunner(); + + Map reqResourceMap = (Map) reqResourceBody.getData(); + String noteId = (String) reqResourceMap.get("noteId"); + String paragraphId = (String) reqResourceMap.get("paragraphId"); + + reqRunnerContext.setNoteId(noteId); + reqRunnerContext.setParagraphId(paragraphId); + + RemoteInterpreterProcessListener.RemoteWorksEventListener callBackEvent = + new RemoteInterpreterProcessListener.RemoteWorksEventListener() { + + @Override + public void onFinished(Object resultObject) { + boolean clientBroken = false; + if (resultObject != null && resultObject instanceof List) { + List runnerList = + (List) resultObject; + for (InterpreterContextRunner r : runnerList) { + remoteRunners.add( + new ZeppelinServerResourceParagraphRunner(r.getNoteId(), r.getParagraphId()) + ); + } + + final RemoteZeppelinServerResource resResource = + new RemoteZeppelinServerResource(); + resResource.setOwnerKey(eventOwnerKey); + resResource.setResourceType(RemoteZeppelinServerResource.Type.PARAGRAPH_RUNNERS); + resResource.setData(remoteRunners); + + try { + eventClient.onReceivedZeppelinResource(gson.toJson(resResource)); + } catch (Exception e) { + clientBroken = true; + logger.error("Can't get RemoteInterpreterEvent", e); + waitQuietly(); + } finally { + interpreterProcess.releaseClient(eventClient, clientBroken); + } } } - } - @Override - public void onError() { - logger.info("onGetParagraphRunners onError"); - } - }); + @Override + public void onError() { + logger.info("onGetParagraphRunners onError"); + } + }; + + remoteWorksEventListener.onGetParagraphRunners( + reqRunnerContext.getNoteId(), reqRunnerContext.getParagraphId(), callBackEvent); } } catch (Exception e) { broken = true; @@ -285,11 +297,6 @@ public void onError() { } finally { interpreterProcess.releaseClient(interpreterServerMain, broken); } - - if (broken == true) { - return; - } - } private void sendResourcePoolResponseGetAll(ResourceSet resourceSet) { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java index 6ba0c281652..f3d5f914852 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterManagedProcess.java @@ -21,7 +21,6 @@ import org.apache.commons.exec.environment.EnvironmentUtils; import org.apache.zeppelin.helium.ApplicationEventListener; import org.apache.zeppelin.interpreter.InterpreterException; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java index 086aef727d0..bb176bea590 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/remote/RemoteInterpreterRunningProcess.java @@ -17,7 +17,6 @@ package org.apache.zeppelin.interpreter.remote; import org.apache.zeppelin.helium.ApplicationEventListener; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.slf4j.Logger; import org.slf4j.LoggerFactory; 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 index 5c4a2dcaef1..ea0b6612df3 100644 --- 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 @@ -344,29 +344,39 @@ public RemoteInterpreterResult interpret(String noteId, String className, String } @Override - public void onReceivedResourceParagraphRunners( - RemoteInterpreterEvent response) throws TException { - if (response.getType() == RemoteInterpreterEventType.RESOURCE_PARAGRAPH_RUN_CONTEXT) { - List intpContextRunners = new LinkedList<>(); + public void onReceivedZeppelinResource(String responseJson) throws TException { + RemoteZeppelinServerResource response = gson.fromJson( + responseJson, RemoteZeppelinServerResource.class); - RemoteZeppelinServerController remoteZeppelinServerController = gson.fromJson( - response.getData(), RemoteZeppelinServerController.class); + if (response == null) { + throw new TException("Bad response for remote resource"); + } - if (remoteZeppelinServerController == null) { - throw new TException("can not found Resource paragraph runners"); - } + try { + if (response.getResourceType() == RemoteZeppelinServerResource.Type.PARAGRAPH_RUNNERS) { + List intpContextRunners = new LinkedList<>(); + List> remoteRunnersMap = + (List>) response.getData(); + + String noteId = null; + String paragraphId = null; + + for (Map runnerItem : remoteRunnersMap) { + noteId = (String) runnerItem.get("noteId"); + paragraphId = (String) runnerItem.get("paragraphId"); + intpContextRunners.add( + new ParagraphRunner(this, noteId, paragraphId) + ); + } - List runners = gson.fromJson( - remoteZeppelinServerController.getMsg(), - new TypeToken>() {}.getType()); - for (ZeppelinServerResourceParagraphRunner r : runners) { - intpContextRunners.add(new ParagraphRunner(this, r.getNoteId(), r.getParagraphId())); - } - synchronized (this.remoteWorksResponsePool) { - this.remoteWorksResponsePool.put( - remoteZeppelinServerController.getEventOwnerKey(), - intpContextRunners); + synchronized (this.remoteWorksResponsePool) { + this.remoteWorksResponsePool.put( + response.getOwnerKey(), + intpContextRunners); + } } + } catch (Exception e) { + throw e; } } @@ -626,7 +636,7 @@ static class ZeppelinRemoteWorksController implements RemoteWorksController{ Logger logger = LoggerFactory.getLogger(ZeppelinRemoteWorksController.class); private final long DEFAULT_TIMEOUT_VALUE = 300000; - private Map remoteWorksResponsePool; + private final Map remoteWorksResponsePool; private RemoteInterpreterServer server; public ZeppelinRemoteWorksController( RemoteInterpreterServer server, Map remoteWorksResponsePool) { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java index 614634e5ffc..db3ad50c5ae 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class InterpreterCompletion implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InterpreterCompletion"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java index 8ca738dfe1f..b0d669243a3 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class RemoteApplicationResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteApplicationResult"); 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 index 83899fb3d99..ad76263cab5 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class RemoteInterpreterContext implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java index 2e2ee2559ce..712db2a0e16 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class RemoteInterpreterEvent implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterEvent"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java index dcf1eb26541..13f1236c7b4 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEventType.java @@ -41,7 +41,7 @@ public enum RemoteInterpreterEventType implements org.apache.thrift.TEnum { ANGULAR_REGISTRY_PUSH(10), APP_STATUS_UPDATE(11), META_INFOS(12), - RESOURCE_PARAGRAPH_RUN_CONTEXT(13); + REMOTE_ZEPPELIN_SERVER_RESOURCE(13); private final int value; @@ -87,7 +87,7 @@ public static RemoteInterpreterEventType findByValue(int value) { case 12: return META_INFOS; case 13: - return RESOURCE_PARAGRAPH_RUN_CONTEXT; + return REMOTE_ZEPPELIN_SERVER_RESOURCE; default: return null; } 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 index f46fa7ed43a..870fc3c5baf 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class RemoteInterpreterResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java index bdcb4846c31..321ef43e0ec 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class RemoteInterpreterService { public interface Iface { @@ -102,7 +102,7 @@ public interface Iface { public RemoteApplicationResult runApplication(String applicationInstanceId) throws org.apache.thrift.TException; - public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response) throws org.apache.thrift.TException; + public void onReceivedZeppelinResource(String object) throws org.apache.thrift.TException; } @@ -154,7 +154,7 @@ public interface AsyncIface { public void runApplication(String applicationInstanceId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void onReceivedZeppelinResource(String object, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; } @@ -704,23 +704,23 @@ public RemoteApplicationResult recv_runApplication() throws org.apache.thrift.TE throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "runApplication failed: unknown result"); } - public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response) throws org.apache.thrift.TException + public void onReceivedZeppelinResource(String object) throws org.apache.thrift.TException { - send_onReceivedResourceParagraphRunners(response); - recv_onReceivedResourceParagraphRunners(); + send_onReceivedZeppelinResource(object); + recv_onReceivedZeppelinResource(); } - public void send_onReceivedResourceParagraphRunners(RemoteInterpreterEvent response) throws org.apache.thrift.TException + public void send_onReceivedZeppelinResource(String object) throws org.apache.thrift.TException { - onReceivedResourceParagraphRunners_args args = new onReceivedResourceParagraphRunners_args(); - args.setResponse(response); - sendBase("onReceivedResourceParagraphRunners", args); + onReceivedZeppelinResource_args args = new onReceivedZeppelinResource_args(); + args.setObject(object); + sendBase("onReceivedZeppelinResource", args); } - public void recv_onReceivedResourceParagraphRunners() throws org.apache.thrift.TException + public void recv_onReceivedZeppelinResource() throws org.apache.thrift.TException { - onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); - receiveBase(result, "onReceivedResourceParagraphRunners"); + onReceivedZeppelinResource_result result = new onReceivedZeppelinResource_result(); + receiveBase(result, "onReceivedZeppelinResource"); return; } @@ -1568,24 +1568,24 @@ public RemoteApplicationResult getResult() throws org.apache.thrift.TException { } } - public void onReceivedResourceParagraphRunners(RemoteInterpreterEvent response, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + public void onReceivedZeppelinResource(String object, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); - onReceivedResourceParagraphRunners_call method_call = new onReceivedResourceParagraphRunners_call(response, resultHandler, this, ___protocolFactory, ___transport); + onReceivedZeppelinResource_call method_call = new onReceivedZeppelinResource_call(object, resultHandler, this, ___protocolFactory, ___transport); this.___currentMethod = method_call; ___manager.call(method_call); } - public static class onReceivedResourceParagraphRunners_call extends org.apache.thrift.async.TAsyncMethodCall { - private RemoteInterpreterEvent response; - public onReceivedResourceParagraphRunners_call(RemoteInterpreterEvent response, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + public static class onReceivedZeppelinResource_call extends org.apache.thrift.async.TAsyncMethodCall { + private String object; + public onReceivedZeppelinResource_call(String object, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { super(client, protocolFactory, transport, resultHandler, false); - this.response = response; + this.object = object; } public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("onReceivedResourceParagraphRunners", org.apache.thrift.protocol.TMessageType.CALL, 0)); - onReceivedResourceParagraphRunners_args args = new onReceivedResourceParagraphRunners_args(); - args.setResponse(response); + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("onReceivedZeppelinResource", org.apache.thrift.protocol.TMessageType.CALL, 0)); + onReceivedZeppelinResource_args args = new onReceivedZeppelinResource_args(); + args.setObject(object); args.write(prot); prot.writeMessageEnd(); } @@ -1596,7 +1596,7 @@ public void getResult() throws org.apache.thrift.TException { } org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_onReceivedResourceParagraphRunners(); + (new Client(prot)).recv_onReceivedZeppelinResource(); } } @@ -1636,7 +1636,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { - public onReceivedResourceParagraphRunners() { - super("onReceivedResourceParagraphRunners"); + public static class onReceivedZeppelinResource extends org.apache.thrift.ProcessFunction { + public onReceivedZeppelinResource() { + super("onReceivedZeppelinResource"); } - public onReceivedResourceParagraphRunners_args getEmptyArgsInstance() { - return new onReceivedResourceParagraphRunners_args(); + public onReceivedZeppelinResource_args getEmptyArgsInstance() { + return new onReceivedZeppelinResource_args(); } protected boolean isOneway() { return false; } - public onReceivedResourceParagraphRunners_result getResult(I iface, onReceivedResourceParagraphRunners_args args) throws org.apache.thrift.TException { - onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); - iface.onReceivedResourceParagraphRunners(args.response); + public onReceivedZeppelinResource_result getResult(I iface, onReceivedZeppelinResource_args args) throws org.apache.thrift.TException { + onReceivedZeppelinResource_result result = new onReceivedZeppelinResource_result(); + iface.onReceivedZeppelinResource(args.object); return result; } } @@ -2158,7 +2158,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public onReceivedResourceParagraphRunners() { - super("onReceivedResourceParagraphRunners"); + public static class onReceivedZeppelinResource extends org.apache.thrift.AsyncProcessFunction { + public onReceivedZeppelinResource() { + super("onReceivedZeppelinResource"); } - public onReceivedResourceParagraphRunners_args getEmptyArgsInstance() { - return new onReceivedResourceParagraphRunners_args(); + public onReceivedZeppelinResource_args getEmptyArgsInstance() { + return new onReceivedZeppelinResource_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Void o) { - onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); + onReceivedZeppelinResource_result result = new onReceivedZeppelinResource_result(); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -3351,7 +3351,7 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - onReceivedResourceParagraphRunners_result result = new onReceivedResourceParagraphRunners_result(); + onReceivedZeppelinResource_result result = new onReceivedZeppelinResource_result(); { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); @@ -3371,8 +3371,8 @@ protected boolean isOneway() { return false; } - public void start(I iface, onReceivedResourceParagraphRunners_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.onReceivedResourceParagraphRunners(args.response,resultHandler); + public void start(I iface, onReceivedZeppelinResource_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.onReceivedZeppelinResource(args.object,resultHandler); } } @@ -22129,22 +22129,22 @@ public void read(org.apache.thrift.protocol.TProtocol prot, runApplication_resul } - public static class onReceivedResourceParagraphRunners_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("onReceivedResourceParagraphRunners_args"); + public static class onReceivedZeppelinResource_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("onReceivedZeppelinResource_args"); - private static final org.apache.thrift.protocol.TField RESPONSE_FIELD_DESC = new org.apache.thrift.protocol.TField("response", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField OBJECT_FIELD_DESC = new org.apache.thrift.protocol.TField("object", org.apache.thrift.protocol.TType.STRING, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new onReceivedResourceParagraphRunners_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new onReceivedResourceParagraphRunners_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new onReceivedZeppelinResource_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new onReceivedZeppelinResource_argsTupleSchemeFactory()); } - public RemoteInterpreterEvent response; // required + public String object; // 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 { - RESPONSE((short)1, "response"); + OBJECT((short)1, "object"); private static final Map byName = new HashMap(); @@ -22159,8 +22159,8 @@ public enum _Fields implements org.apache.thrift.TFieldIdEnum { */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 1: // RESPONSE - return RESPONSE; + case 1: // OBJECT + return OBJECT; default: return null; } @@ -22204,71 +22204,71 @@ public String getFieldName() { 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.RESPONSE, new org.apache.thrift.meta_data.FieldMetaData("response", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RemoteInterpreterEvent.class))); + tmpMap.put(_Fields.OBJECT, new org.apache.thrift.meta_data.FieldMetaData("object", 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(onReceivedResourceParagraphRunners_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(onReceivedZeppelinResource_args.class, metaDataMap); } - public onReceivedResourceParagraphRunners_args() { + public onReceivedZeppelinResource_args() { } - public onReceivedResourceParagraphRunners_args( - RemoteInterpreterEvent response) + public onReceivedZeppelinResource_args( + String object) { this(); - this.response = response; + this.object = object; } /** * Performs a deep copy on other. */ - public onReceivedResourceParagraphRunners_args(onReceivedResourceParagraphRunners_args other) { - if (other.isSetResponse()) { - this.response = new RemoteInterpreterEvent(other.response); + public onReceivedZeppelinResource_args(onReceivedZeppelinResource_args other) { + if (other.isSetObject()) { + this.object = other.object; } } - public onReceivedResourceParagraphRunners_args deepCopy() { - return new onReceivedResourceParagraphRunners_args(this); + public onReceivedZeppelinResource_args deepCopy() { + return new onReceivedZeppelinResource_args(this); } @Override public void clear() { - this.response = null; + this.object = null; } - public RemoteInterpreterEvent getResponse() { - return this.response; + public String getObject() { + return this.object; } - public onReceivedResourceParagraphRunners_args setResponse(RemoteInterpreterEvent response) { - this.response = response; + public onReceivedZeppelinResource_args setObject(String object) { + this.object = object; return this; } - public void unsetResponse() { - this.response = null; + public void unsetObject() { + this.object = null; } - /** Returns true if field response is set (has been assigned a value) and false otherwise */ - public boolean isSetResponse() { - return this.response != null; + /** Returns true if field object is set (has been assigned a value) and false otherwise */ + public boolean isSetObject() { + return this.object != null; } - public void setResponseIsSet(boolean value) { + public void setObjectIsSet(boolean value) { if (!value) { - this.response = null; + this.object = null; } } public void setFieldValue(_Fields field, Object value) { switch (field) { - case RESPONSE: + case OBJECT: if (value == null) { - unsetResponse(); + unsetObject(); } else { - setResponse((RemoteInterpreterEvent)value); + setObject((String)value); } break; @@ -22277,8 +22277,8 @@ public void setFieldValue(_Fields field, Object value) { public Object getFieldValue(_Fields field) { switch (field) { - case RESPONSE: - return getResponse(); + case OBJECT: + return getObject(); } throw new IllegalStateException(); @@ -22291,8 +22291,8 @@ public boolean isSet(_Fields field) { } switch (field) { - case RESPONSE: - return isSetResponse(); + case OBJECT: + return isSetObject(); } throw new IllegalStateException(); } @@ -22301,21 +22301,21 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof onReceivedResourceParagraphRunners_args) - return this.equals((onReceivedResourceParagraphRunners_args)that); + if (that instanceof onReceivedZeppelinResource_args) + return this.equals((onReceivedZeppelinResource_args)that); return false; } - public boolean equals(onReceivedResourceParagraphRunners_args that) { + public boolean equals(onReceivedZeppelinResource_args that) { if (that == null) return false; - boolean this_present_response = true && this.isSetResponse(); - boolean that_present_response = true && that.isSetResponse(); - if (this_present_response || that_present_response) { - if (!(this_present_response && that_present_response)) + boolean this_present_object = true && this.isSetObject(); + boolean that_present_object = true && that.isSetObject(); + if (this_present_object || that_present_object) { + if (!(this_present_object && that_present_object)) return false; - if (!this.response.equals(that.response)) + if (!this.object.equals(that.object)) return false; } @@ -22326,28 +22326,28 @@ public boolean equals(onReceivedResourceParagraphRunners_args that) { public int hashCode() { List list = new ArrayList(); - boolean present_response = true && (isSetResponse()); - list.add(present_response); - if (present_response) - list.add(response); + boolean present_object = true && (isSetObject()); + list.add(present_object); + if (present_object) + list.add(object); return list.hashCode(); } @Override - public int compareTo(onReceivedResourceParagraphRunners_args other) { + public int compareTo(onReceivedZeppelinResource_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - lastComparison = Boolean.valueOf(isSetResponse()).compareTo(other.isSetResponse()); + lastComparison = Boolean.valueOf(isSetObject()).compareTo(other.isSetObject()); if (lastComparison != 0) { return lastComparison; } - if (isSetResponse()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.response, other.response); + if (isSetObject()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.object, other.object); if (lastComparison != 0) { return lastComparison; } @@ -22369,14 +22369,14 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("onReceivedResourceParagraphRunners_args("); + StringBuilder sb = new StringBuilder("onReceivedZeppelinResource_args("); boolean first = true; - sb.append("response:"); - if (this.response == null) { + sb.append("object:"); + if (this.object == null) { sb.append("null"); } else { - sb.append(this.response); + sb.append(this.object); } first = false; sb.append(")"); @@ -22386,9 +22386,6 @@ public String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (response != null) { - response.validate(); - } } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { @@ -22407,15 +22404,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class onReceivedResourceParagraphRunners_argsStandardSchemeFactory implements SchemeFactory { - public onReceivedResourceParagraphRunners_argsStandardScheme getScheme() { - return new onReceivedResourceParagraphRunners_argsStandardScheme(); + private static class onReceivedZeppelinResource_argsStandardSchemeFactory implements SchemeFactory { + public onReceivedZeppelinResource_argsStandardScheme getScheme() { + return new onReceivedZeppelinResource_argsStandardScheme(); } } - private static class onReceivedResourceParagraphRunners_argsStandardScheme extends StandardScheme { + private static class onReceivedZeppelinResource_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedZeppelinResource_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -22425,11 +22422,10 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceP break; } switch (schemeField.id) { - case 1: // RESPONSE - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.response = new RemoteInterpreterEvent(); - struct.response.read(iprot); - struct.setResponseIsSet(true); + case 1: // OBJECT + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.object = iprot.readString(); + struct.setObjectIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -22445,13 +22441,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceP struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedZeppelinResource_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); - if (struct.response != null) { - oprot.writeFieldBegin(RESPONSE_FIELD_DESC); - struct.response.write(oprot); + if (struct.object != null) { + oprot.writeFieldBegin(OBJECT_FIELD_DESC); + oprot.writeString(struct.object); oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -22460,49 +22456,48 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedResource } - private static class onReceivedResourceParagraphRunners_argsTupleSchemeFactory implements SchemeFactory { - public onReceivedResourceParagraphRunners_argsTupleScheme getScheme() { - return new onReceivedResourceParagraphRunners_argsTupleScheme(); + private static class onReceivedZeppelinResource_argsTupleSchemeFactory implements SchemeFactory { + public onReceivedZeppelinResource_argsTupleScheme getScheme() { + return new onReceivedZeppelinResource_argsTupleScheme(); } } - private static class onReceivedResourceParagraphRunners_argsTupleScheme extends TupleScheme { + private static class onReceivedZeppelinResource_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, onReceivedZeppelinResource_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); - if (struct.isSetResponse()) { + if (struct.isSetObject()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); - if (struct.isSetResponse()) { - struct.response.write(oprot); + if (struct.isSetObject()) { + oprot.writeString(struct.object); } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, onReceivedZeppelinResource_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.response = new RemoteInterpreterEvent(); - struct.response.read(iprot); - struct.setResponseIsSet(true); + struct.object = iprot.readString(); + struct.setObjectIsSet(true); } } } } - public static class onReceivedResourceParagraphRunners_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("onReceivedResourceParagraphRunners_result"); + public static class onReceivedZeppelinResource_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("onReceivedZeppelinResource_result"); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new onReceivedResourceParagraphRunners_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new onReceivedResourceParagraphRunners_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new onReceivedZeppelinResource_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new onReceivedZeppelinResource_resultTupleSchemeFactory()); } @@ -22565,20 +22560,20 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(onReceivedResourceParagraphRunners_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(onReceivedZeppelinResource_result.class, metaDataMap); } - public onReceivedResourceParagraphRunners_result() { + public onReceivedZeppelinResource_result() { } /** * Performs a deep copy on other. */ - public onReceivedResourceParagraphRunners_result(onReceivedResourceParagraphRunners_result other) { + public onReceivedZeppelinResource_result(onReceivedZeppelinResource_result other) { } - public onReceivedResourceParagraphRunners_result deepCopy() { - return new onReceivedResourceParagraphRunners_result(this); + public onReceivedZeppelinResource_result deepCopy() { + return new onReceivedZeppelinResource_result(this); } @Override @@ -22611,12 +22606,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof onReceivedResourceParagraphRunners_result) - return this.equals((onReceivedResourceParagraphRunners_result)that); + if (that instanceof onReceivedZeppelinResource_result) + return this.equals((onReceivedZeppelinResource_result)that); return false; } - public boolean equals(onReceivedResourceParagraphRunners_result that) { + public boolean equals(onReceivedZeppelinResource_result that) { if (that == null) return false; @@ -22631,7 +22626,7 @@ public int hashCode() { } @Override - public int compareTo(onReceivedResourceParagraphRunners_result other) { + public int compareTo(onReceivedZeppelinResource_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -22655,7 +22650,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("onReceivedResourceParagraphRunners_result("); + StringBuilder sb = new StringBuilder("onReceivedZeppelinResource_result("); boolean first = true; sb.append(")"); @@ -22683,15 +22678,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class onReceivedResourceParagraphRunners_resultStandardSchemeFactory implements SchemeFactory { - public onReceivedResourceParagraphRunners_resultStandardScheme getScheme() { - return new onReceivedResourceParagraphRunners_resultStandardScheme(); + private static class onReceivedZeppelinResource_resultStandardSchemeFactory implements SchemeFactory { + public onReceivedZeppelinResource_resultStandardScheme getScheme() { + return new onReceivedZeppelinResource_resultStandardScheme(); } } - private static class onReceivedResourceParagraphRunners_resultStandardScheme extends StandardScheme { + private static class onReceivedZeppelinResource_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedZeppelinResource_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -22712,7 +22707,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, onReceivedResourceP struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedZeppelinResource_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -22722,21 +22717,21 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, onReceivedResource } - private static class onReceivedResourceParagraphRunners_resultTupleSchemeFactory implements SchemeFactory { - public onReceivedResourceParagraphRunners_resultTupleScheme getScheme() { - return new onReceivedResourceParagraphRunners_resultTupleScheme(); + private static class onReceivedZeppelinResource_resultTupleSchemeFactory implements SchemeFactory { + public onReceivedZeppelinResource_resultTupleScheme getScheme() { + return new onReceivedZeppelinResource_resultTupleScheme(); } } - private static class onReceivedResourceParagraphRunners_resultTupleScheme extends TupleScheme { + private static class onReceivedZeppelinResource_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, onReceivedZeppelinResource_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, onReceivedResourceParagraphRunners_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, onReceivedZeppelinResource_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; } } diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java deleted file mode 100644 index e73e90a7aeb..00000000000 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteZeppelinServerController.java +++ /dev/null @@ -1,520 +0,0 @@ -/** - * 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. - */ -/** - * Autogenerated by Thrift Compiler (0.9.2) - * - * 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 org.apache.thrift.async.AsyncMethodCallback; -import org.apache.thrift.server.AbstractNonblockingServer.*; -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 javax.annotation.Generated; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") -public class RemoteZeppelinServerController implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteZeppelinServerController"); - - private static final org.apache.thrift.protocol.TField EVENT_OWNER_KEY_FIELD_DESC = new org.apache.thrift.protocol.TField("eventOwnerKey", 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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new RemoteZeppelinServerControllerStandardSchemeFactory()); - schemes.put(TupleScheme.class, new RemoteZeppelinServerControllerTupleSchemeFactory()); - } - - public String eventOwnerKey; // required - public String msg; // 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 { - EVENT_OWNER_KEY((short)2, "eventOwnerKey"), - MSG((short)3, "msg"); - - private static final Map byName = new HashMap(); - - 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 2: // EVENT_OWNER_KEY - return EVENT_OWNER_KEY; - case 3: // MSG - return MSG; - 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.EVENT_OWNER_KEY, new org.apache.thrift.meta_data.FieldMetaData("eventOwnerKey", 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))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RemoteZeppelinServerController.class, metaDataMap); - } - - public RemoteZeppelinServerController() { - } - - public RemoteZeppelinServerController( - String eventOwnerKey, - String msg) - { - this(); - this.eventOwnerKey = eventOwnerKey; - this.msg = msg; - } - - /** - * Performs a deep copy on other. - */ - public RemoteZeppelinServerController(RemoteZeppelinServerController other) { - if (other.isSetEventOwnerKey()) { - this.eventOwnerKey = other.eventOwnerKey; - } - if (other.isSetMsg()) { - this.msg = other.msg; - } - } - - public RemoteZeppelinServerController deepCopy() { - return new RemoteZeppelinServerController(this); - } - - @Override - public void clear() { - this.eventOwnerKey = null; - this.msg = null; - } - - public String getEventOwnerKey() { - return this.eventOwnerKey; - } - - public RemoteZeppelinServerController setEventOwnerKey(String eventOwnerKey) { - this.eventOwnerKey = eventOwnerKey; - return this; - } - - public void unsetEventOwnerKey() { - this.eventOwnerKey = null; - } - - /** Returns true if field eventOwnerKey is set (has been assigned a value) and false otherwise */ - public boolean isSetEventOwnerKey() { - return this.eventOwnerKey != null; - } - - public void setEventOwnerKeyIsSet(boolean value) { - if (!value) { - this.eventOwnerKey = null; - } - } - - public String getMsg() { - return this.msg; - } - - public RemoteZeppelinServerController 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 void setFieldValue(_Fields field, Object value) { - switch (field) { - case EVENT_OWNER_KEY: - if (value == null) { - unsetEventOwnerKey(); - } else { - setEventOwnerKey((String)value); - } - break; - - case MSG: - if (value == null) { - unsetMsg(); - } else { - setMsg((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case EVENT_OWNER_KEY: - return getEventOwnerKey(); - - case MSG: - return getMsg(); - - } - 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 EVENT_OWNER_KEY: - return isSetEventOwnerKey(); - case MSG: - return isSetMsg(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof RemoteZeppelinServerController) - return this.equals((RemoteZeppelinServerController)that); - return false; - } - - public boolean equals(RemoteZeppelinServerController that) { - if (that == null) - return false; - - boolean this_present_eventOwnerKey = true && this.isSetEventOwnerKey(); - boolean that_present_eventOwnerKey = true && that.isSetEventOwnerKey(); - if (this_present_eventOwnerKey || that_present_eventOwnerKey) { - if (!(this_present_eventOwnerKey && that_present_eventOwnerKey)) - return false; - if (!this.eventOwnerKey.equals(that.eventOwnerKey)) - 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; - } - - return true; - } - - @Override - public int hashCode() { - List list = new ArrayList(); - - boolean present_eventOwnerKey = true && (isSetEventOwnerKey()); - list.add(present_eventOwnerKey); - if (present_eventOwnerKey) - list.add(eventOwnerKey); - - boolean present_msg = true && (isSetMsg()); - list.add(present_msg); - if (present_msg) - list.add(msg); - - return list.hashCode(); - } - - @Override - public int compareTo(RemoteZeppelinServerController other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - - lastComparison = Boolean.valueOf(isSetEventOwnerKey()).compareTo(other.isSetEventOwnerKey()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEventOwnerKey()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventOwnerKey, other.eventOwnerKey); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetMsg()).compareTo(other.isSetMsg()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetMsg()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, other.msg); - 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("RemoteZeppelinServerController("); - boolean first = true; - - sb.append("eventOwnerKey:"); - if (this.eventOwnerKey == null) { - sb.append("null"); - } else { - sb.append(this.eventOwnerKey); - } - first = false; - if (!first) sb.append(", "); - sb.append("msg:"); - if (this.msg == null) { - sb.append("null"); - } else { - sb.append(this.msg); - } - 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 RemoteZeppelinServerControllerStandardSchemeFactory implements SchemeFactory { - public RemoteZeppelinServerControllerStandardScheme getScheme() { - return new RemoteZeppelinServerControllerStandardScheme(); - } - } - - private static class RemoteZeppelinServerControllerStandardScheme extends StandardScheme { - - public void read(org.apache.thrift.protocol.TProtocol iprot, RemoteZeppelinServerController 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 2: // EVENT_OWNER_KEY - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.eventOwnerKey = iprot.readString(); - struct.setEventOwnerKeyIsSet(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; - 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, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.eventOwnerKey != null) { - oprot.writeFieldBegin(EVENT_OWNER_KEY_FIELD_DESC); - oprot.writeString(struct.eventOwnerKey); - oprot.writeFieldEnd(); - } - if (struct.msg != null) { - oprot.writeFieldBegin(MSG_FIELD_DESC); - oprot.writeString(struct.msg); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class RemoteZeppelinServerControllerTupleSchemeFactory implements SchemeFactory { - public RemoteZeppelinServerControllerTupleScheme getScheme() { - return new RemoteZeppelinServerControllerTupleScheme(); - } - } - - private static class RemoteZeppelinServerControllerTupleScheme extends TupleScheme { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetEventOwnerKey()) { - optionals.set(0); - } - if (struct.isSetMsg()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetEventOwnerKey()) { - oprot.writeString(struct.eventOwnerKey); - } - if (struct.isSetMsg()) { - oprot.writeString(struct.msg); - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, RemoteZeppelinServerController struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.eventOwnerKey = iprot.readString(); - struct.setEventOwnerKeyIsSet(true); - } - if (incoming.get(1)) { - struct.msg = iprot.readString(); - struct.setMsgIsSet(true); - } - } - } - -} - diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java index b2c4764b785..5ec66419325 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-18") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResourceParagraphRunner"); diff --git a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift index 59e5a251712..4d8df96593c 100644 --- a/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift +++ b/zeppelin-interpreter/src/main/thrift/RemoteInterpreterService.thrift @@ -51,7 +51,7 @@ enum RemoteInterpreterEventType { ANGULAR_REGISTRY_PUSH = 10, APP_STATUS_UPDATE = 11, META_INFOS = 12, - RESOURCE_PARAGRAPH_RUN_CONTEXT = 13 + REMOTE_ZEPPELIN_SERVER_RESOURCE = 13 } @@ -70,11 +70,6 @@ struct ZeppelinServerResourceParagraphRunner { 2: string paragraphId } -struct RemoteZeppelinServerController { - 2: string eventOwnerKey - 3: string msg -} - /* * The below variables(name, value) will be connected to getCompletions in paragraph.controller.js * @@ -123,5 +118,5 @@ service RemoteInterpreterService { RemoteApplicationResult unloadApplication(1: string applicationInstanceId); RemoteApplicationResult runApplication(1: string applicationInstanceId); - void onReceivedResourceParagraphRunners(1: RemoteInterpreterEvent response); + void onReceivedZeppelinResource(1: string object); } diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java b/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java index f4574131da4..b8343c0633a 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java @@ -24,7 +24,6 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java index b2340b1f198..e462f7289f1 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter1.java @@ -25,7 +25,6 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java index 2abb2da3093..fc307265cd2 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter11.java @@ -25,7 +25,6 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java index d52bfbeaf7d..7fb615be906 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java @@ -25,7 +25,6 @@ import org.apache.zeppelin.interpreter.Interpreter; import org.apache.zeppelin.interpreter.InterpreterContext; import org.apache.zeppelin.interpreter.InterpreterResult; -import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; From 38621663091ae17bbead06e364392239d75677d5 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Fri, 25 Nov 2016 22:41:03 +0900 Subject: [PATCH 19/23] regenerate thrfit class --- .../zeppelin/interpreter/thrift/InterpreterCompletion.java | 2 +- .../zeppelin/interpreter/thrift/RemoteApplicationResult.java | 2 +- .../zeppelin/interpreter/thrift/RemoteInterpreterContext.java | 2 +- .../zeppelin/interpreter/thrift/RemoteInterpreterEvent.java | 2 +- .../zeppelin/interpreter/thrift/RemoteInterpreterResult.java | 2 +- .../zeppelin/interpreter/thrift/RemoteInterpreterService.java | 2 +- .../thrift/ZeppelinServerResourceParagraphRunner.java | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java index db3ad50c5ae..2514cb00c2b 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/InterpreterCompletion.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class InterpreterCompletion implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InterpreterCompletion"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java index b0d669243a3..3d9aae59cb7 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteApplicationResult.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class RemoteApplicationResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteApplicationResult"); 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 index ad76263cab5..764ac37e23f 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class RemoteInterpreterContext implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterContext"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java index 712db2a0e16..9ff5a34524e 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterEvent.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class RemoteInterpreterEvent implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterEvent"); 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 index 870fc3c5baf..1a20f3939a6 100644 --- 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 @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class RemoteInterpreterResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("RemoteInterpreterResult"); diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java index 321ef43e0ec..0b7930de3c5 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/RemoteInterpreterService.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class RemoteInterpreterService { public interface Iface { diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java index 5ec66419325..da2f70339a4 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/thrift/ZeppelinServerResourceParagraphRunner.java @@ -51,7 +51,7 @@ import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-24") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-11-25") public class ZeppelinServerResourceParagraphRunner implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ZeppelinServerResourceParagraphRunner"); From 5a80a5a8ace3bd9331b9e0baa4b401d8c6e496fd Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Sat, 26 Nov 2016 12:11:17 +0900 Subject: [PATCH 20/23] last test case time check to print string --- .../java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java b/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java index 00159770b8b..fa03f618e05 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java @@ -355,6 +355,7 @@ public void zRunTest() throws IOException { p3.setAuthenticationInfo(anonymous); p0.setText(String.format("%%spark z.runNote(\"%s\")", note.getId())); + p3.setText("%%spark println(\"END\")"); note.run(p0.getId()); waitForFinish(p0); waitForFinish(p1); From f2e3bcf29961a37fa83810a7732efc10d76bfe15 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Sat, 26 Nov 2016 12:51:15 +0900 Subject: [PATCH 21/23] fix TestCase --- .../java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java b/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java index fa03f618e05..cb1625ad578 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/rest/ZeppelinSparkClusterTest.java @@ -355,7 +355,6 @@ public void zRunTest() throws IOException { p3.setAuthenticationInfo(anonymous); p0.setText(String.format("%%spark z.runNote(\"%s\")", note.getId())); - p3.setText("%%spark println(\"END\")"); note.run(p0.getId()); waitForFinish(p0); waitForFinish(p1); @@ -368,6 +367,7 @@ public void zRunTest() throws IOException { assertNotEquals("", p3result); p0.setText(String.format("%%spark z.run(\"%s\", \"%s\")", note.getId(), p3.getId())); + p3.setText("%%spark println(\"END\")"); note.run(p0.getId()); waitForFinish(p0); From 03a3a2b00c852daffa38994f10376ee879266f59 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Mon, 28 Nov 2016 11:29:56 +0900 Subject: [PATCH 22/23] testcase change z.run(2, context) to z.run(2) --- .../test/java/org/apache/zeppelin/integration/ZeppelinIT.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zeppelin-server/src/test/java/org/apache/zeppelin/integration/ZeppelinIT.java b/zeppelin-server/src/test/java/org/apache/zeppelin/integration/ZeppelinIT.java index 1d60fce5e4b..49e1a9f96c5 100644 --- a/zeppelin-server/src/test/java/org/apache/zeppelin/integration/ZeppelinIT.java +++ b/zeppelin-server/src/test/java/org/apache/zeppelin/integration/ZeppelinIT.java @@ -137,7 +137,7 @@ public void testAngularDisplay() throws Exception { * z.run(2, context) * } */ - setTextOfParagraph(4, "z.angularWatch(\"myVar\", (before:Object, after:Object, context:org.apache.zeppelin.interpreter.InterpreterContext)=>{ z.run(2, context)})"); + setTextOfParagraph(4, "z.angularWatch(\"myVar\", (before:Object, after:Object, context:org.apache.zeppelin.interpreter.InterpreterContext)=>{ z.run(2)})"); runParagraph(4); waitForParagraph(4, "FINISHED"); From 41fa9d725a2604035ba36cd3c4425742b17cf3c3 Mon Sep 17 00:00:00 2001 From: CloverHearts Date: Tue, 29 Nov 2016 00:09:33 +0900 Subject: [PATCH 23/23] restore unless changed and import --- .../zeppelin/bigquery/BigQueryInterpreter.java | 5 ++++- .../zeppelin/cassandra/CassandraInterpreter.java | 5 ++++- .../org/apache/zeppelin/flink/FlinkInterpreter.java | 6 +++++- .../zeppelin/ignite/IgniteSqlInterpreter.java | 6 +++++- .../org/apache/zeppelin/jdbc/JDBCInterpreter.java | 5 ++++- .../org/apache/zeppelin/kylin/KylinInterpreter.java | 5 ++++- .../org/apache/zeppelin/lens/LensInterpreter.java | 5 ++++- .../java/org/apache/zeppelin/markdown/Markdown.java | 6 +++++- .../org/apache/zeppelin/pig/PigInterpreter.java | 1 + .../zeppelin/postgresql/PostgreSqlInterpreter.java | 5 ++++- .../zeppelin/python/PythonInterpreterPandasSql.java | 6 +++++- .../zeppelin/scalding/ScaldingInterpreter.java | 1 + .../org/apache/zeppelin/shell/ShellInterpreter.java | 1 + .../org/apache/zeppelin/spark/DepInterpreter.java | 6 +++++- .../apache/zeppelin/spark/PySparkInterpreter.java | 8 +++++++- .../org/apache/zeppelin/spark/SparkInterpreter.java | 13 +++++++++---- .../apache/zeppelin/spark/SparkSqlInterpreter.java | 7 ++++++- .../org/apache/zeppelin/spark/ZeppelinContext.java | 7 +++++-- .../zeppelin/interpreter/dev/DevInterpreter.java | 7 ++++++- .../interpreter/remote/mock/MockInterpreterA.java | 6 +++++- .../remote/mock/MockInterpreterAngular.java | 5 ++++- .../interpreter/remote/mock/MockInterpreterB.java | 8 +++++++- .../remote/mock/MockInterpreterResourcePool.java | 5 ++++- .../zeppelin/interpreter/InterpreterFactory.java | 1 + .../zeppelin/interpreter/mock/MockInterpreter2.java | 1 + 25 files changed, 107 insertions(+), 24 deletions(-) diff --git a/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java b/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java index 8d15638d311..33e196003b0 100644 --- a/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java +++ b/bigquery/src/main/java/org/apache/zeppelin/bigquery/BigQueryInterpreter.java @@ -51,7 +51,10 @@ import java.util.Properties; import java.util.Set; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; diff --git a/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java b/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java index 7b492bb00aa..47d8e3a53cb 100644 --- a/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java +++ b/cassandra/src/main/java/org/apache/zeppelin/cassandra/CassandraInterpreter.java @@ -19,7 +19,10 @@ import com.datastax.driver.core.Cluster; import com.datastax.driver.core.ProtocolOptions.Compression; import com.datastax.driver.core.Session; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java b/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java index 3af09cd68bb..8b9b4ec14ca 100644 --- a/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java +++ b/flink/src/main/java/org/apache/zeppelin/flink/FlinkInterpreter.java @@ -35,8 +35,12 @@ import org.apache.flink.runtime.messages.JobManagerMessages; import org.apache.flink.runtime.minicluster.LocalFlinkMiniCluster; import org.apache.flink.runtime.util.EnvironmentInformation; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.InterpreterUtils; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java index 08e426782fb..9a651f8816f 100644 --- a/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java +++ b/ignite/src/main/java/org/apache/zeppelin/ignite/IgniteSqlInterpreter.java @@ -16,7 +16,11 @@ */ package org.apache.zeppelin.ignite; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; diff --git a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java index ac14a1cec1a..7871f01903d 100644 --- a/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java +++ b/jdbc/src/main/java/org/apache/zeppelin/jdbc/JDBCInterpreter.java @@ -30,7 +30,10 @@ import org.apache.commons.pool2.ObjectPool; import org.apache.commons.pool2.impl.GenericObjectPool; import org.apache.hadoop.security.UserGroupInformation; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.jdbc.security.JDBCSecurityImpl; diff --git a/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java b/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java index 7960cfdf297..8523e49fbdf 100755 --- a/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java +++ b/kylin/src/main/java/org/apache/zeppelin/kylin/KylinInterpreter.java @@ -24,7 +24,10 @@ import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.HttpClientBuilder; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java b/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java index 5f2d4f61043..17e3a46c68f 100644 --- a/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java +++ b/lens/src/main/java/org/apache/zeppelin/lens/LensInterpreter.java @@ -31,7 +31,10 @@ import org.apache.lens.client.LensClientConfig; import org.apache.lens.client.LensClientSingletonWrapper; import org.apache.lens.cli.commands.BaseLensCommand; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; diff --git a/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java b/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java index c711083a602..c908a5449de 100644 --- a/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java +++ b/markdown/src/main/java/org/apache/zeppelin/markdown/Markdown.java @@ -21,8 +21,12 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.InterpreterUtils; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java index 706697157e1..8cd1efc929e 100644 --- a/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java +++ b/pig/src/main/java/org/apache/zeppelin/pig/PigInterpreter.java @@ -69,6 +69,7 @@ public void close() { pigServer = null; } + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { // remember the origial stdout, because we will redirect stdout to capture diff --git a/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java b/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java index 149854ba7ec..88c22d4e2ad 100644 --- a/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java +++ b/postgresql/src/main/java/org/apache/zeppelin/postgresql/PostgreSqlInterpreter.java @@ -28,7 +28,10 @@ import java.util.Properties; import java.util.Set; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; diff --git a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java index 8c72fa1b7ea..381066fe270 100644 --- a/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java +++ b/python/src/main/java/org/apache/zeppelin/python/PythonInterpreterPandasSql.java @@ -20,7 +20,11 @@ import java.io.IOException; import java.util.Properties; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterResult; +import org.apache.zeppelin.interpreter.LazyOpenInterpreter; +import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java index 8f20bc89788..282cd2e734f 100644 --- a/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java +++ b/scalding/src/main/java/org/apache/zeppelin/scalding/ScaldingInterpreter.java @@ -115,6 +115,7 @@ public void close() { interpreter.intp().close(); } + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { String user = contextInterpreter.getAuthenticationInfo().getUser(); diff --git a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java index 3b8aa2b3b4d..838c6f15358 100644 --- a/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java +++ b/shell/src/main/java/org/apache/zeppelin/shell/ShellInterpreter.java @@ -69,6 +69,7 @@ public void open() { @Override public void close() {} + @Override public InterpreterResult interpret(String cmd, InterpreterContext contextInterpreter) { LOGGER.debug("Run shell command '" + cmd + "'"); diff --git a/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java index ebd2c415a15..478d0bc794c 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/DepInterpreter.java @@ -34,8 +34,12 @@ import com.google.common.reflect.TypeToken; import com.google.gson.Gson; import org.apache.spark.repl.SparkILoop; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterGroup; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.spark.dep.SparkDependencyContext; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java index 2f57ffcb663..b682a03d472 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/PySparkInterpreter.java @@ -45,8 +45,14 @@ import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaSparkContext; import org.apache.spark.sql.SQLContext; -import org.apache.zeppelin.interpreter.*; +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.InterpreterHookRegistry.HookType; +import org.apache.zeppelin.interpreter.LazyOpenInterpreter; +import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.interpreter.util.InterpreterOutputStream; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java index 233980c5b23..e8c76bcccd4 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkInterpreter.java @@ -45,7 +45,12 @@ import org.apache.spark.sql.SQLContext; import org.apache.spark.ui.SparkUI; import org.apache.spark.ui.jobs.JobProgressListener; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterHookRegistry; +import org.apache.zeppelin.interpreter.InterpreterProperty; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.InterpreterUtils; import org.apache.zeppelin.interpreter.WrappedInterpreter; @@ -1071,9 +1076,9 @@ private String getCompletionTargetString(String text, int cursor) { } /* - * this method doesn't work in scala 2.11 - * Somehow intp.valueOfTerm returns scala.None always with -Yrepl-class-based option - */ + * this method doesn't work in scala 2.11 + * Somehow intp.valueOfTerm returns scala.None always with -Yrepl-class-based option + */ public Object getValue(String name) { Object ret = Utils.invokeMethod( intp, "valueOfTerm", new Class[]{String.class}, new Object[]{name}); diff --git a/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java b/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java index ab7e8aac32e..e6fe137273a 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/SparkSqlInterpreter.java @@ -25,8 +25,13 @@ import org.apache.spark.SparkContext; import org.apache.spark.sql.SQLContext; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.LazyOpenInterpreter; +import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; import org.apache.zeppelin.scheduler.SchedulerFactory; diff --git a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java index f4bb0685661..281a8f83cad 100644 --- a/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java +++ b/spark/src/main/java/org/apache/zeppelin/spark/ZeppelinContext.java @@ -41,7 +41,11 @@ import org.apache.zeppelin.display.AngularObjectWatcher; import org.apache.zeppelin.display.GUI; import org.apache.zeppelin.display.Input.ParamOption; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterContextRunner; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterHookRegistry; +import org.apache.zeppelin.interpreter.RemoteWorksController; import org.apache.zeppelin.spark.dep.SparkDependencyResolver; import org.apache.zeppelin.resource.Resource; import org.apache.zeppelin.resource.ResourcePool; @@ -295,7 +299,6 @@ public static String showDF(SparkContext sc, return msg.toString(); } - /** * Run paragraph by id * @param noteId diff --git a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java index 8728d534b8b..eb21d5870f9 100644 --- a/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java +++ b/zeppelin-interpreter/src/main/java/org/apache/zeppelin/interpreter/dev/DevInterpreter.java @@ -20,7 +20,12 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterContextRunner; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; /** diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java index 7e2c5bef894..cb367cabc36 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterA.java @@ -20,7 +20,11 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterException; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java index 7d21f5c6f6c..76b29259d95 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterAngular.java @@ -23,7 +23,10 @@ import org.apache.zeppelin.display.AngularObjectRegistry; import org.apache.zeppelin.display.AngularObjectWatcher; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java index df957568862..d31a5492d75 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterB.java @@ -20,8 +20,14 @@ import java.util.List; import java.util.Properties; -import org.apache.zeppelin.interpreter.*; +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.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; +import org.apache.zeppelin.interpreter.WrappedInterpreter; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.scheduler.Scheduler; diff --git a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java index 02f628578dc..e49306d22a7 100644 --- a/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java +++ b/zeppelin-interpreter/src/test/java/org/apache/zeppelin/interpreter/remote/mock/MockInterpreterResourcePool.java @@ -24,7 +24,10 @@ import com.google.gson.Gson; import org.apache.zeppelin.display.AngularObjectRegistry; import org.apache.zeppelin.display.AngularObjectWatcher; -import org.apache.zeppelin.interpreter.*; +import org.apache.zeppelin.interpreter.Interpreter; +import org.apache.zeppelin.interpreter.InterpreterContext; +import org.apache.zeppelin.interpreter.InterpreterPropertyBuilder; +import org.apache.zeppelin.interpreter.InterpreterResult; import org.apache.zeppelin.interpreter.InterpreterResult.Code; import org.apache.zeppelin.interpreter.thrift.InterpreterCompletion; import org.apache.zeppelin.resource.Resource; diff --git a/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java b/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java index 97d50b5ff8f..11c9f685f26 100644 --- a/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java +++ b/zeppelin-zengine/src/main/java/org/apache/zeppelin/interpreter/InterpreterFactory.java @@ -140,6 +140,7 @@ public InterpreterFactory(ZeppelinConfiguration conf, remoteInterpreterProcessListener, appEventListener, depResolver, shiroEnabled); } + public InterpreterFactory(ZeppelinConfiguration conf, InterpreterOption defaultOption, AngularObjectRegistryListener angularObjectRegistryListener, RemoteInterpreterProcessListener remoteInterpreterProcessListener, diff --git a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java index 7fb615be906..93f99ae942b 100644 --- a/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java +++ b/zeppelin-zengine/src/test/java/org/apache/zeppelin/interpreter/mock/MockInterpreter2.java @@ -52,6 +52,7 @@ public boolean isOpen() { return open; } + @Override public InterpreterResult interpret(String st, InterpreterContext context) { InterpreterResult result;