Examples with Message org.apache.zeppelin.notebook.socket.Message used on opensource projects

Example 26 with Message

use of org.apache.zeppelin.notebook.socket.Message in project zeppelin by apache.

the class NotebookServer method broadcastNewParagraph.

private void broadcastNewParagraph(Note note, Paragraph para) {
    LOG.info("Broadcasting paragraph on run call instead of note.");
    int paraIndex = note.getParagraphs().indexOf(para);
    broadcast(note.getId(), new Message(OP.PARAGRAPH_ADDED).put("paragraph", para).put("index", paraIndex));
}

Example 27 with Message

use of org.apache.zeppelin.notebook.socket.Message in project zeppelin by apache.

the class NotebookServer method onMessage.

@Override
public void onMessage(NotebookSocket conn, String msg) {
    Notebook notebook = notebook();
    try {
        Message messagereceived = deserializeMessage(msg);
        LOG.debug("RECEIVE << " + messagereceived.op);
        LOG.debug("RECEIVE PRINCIPAL << " + messagereceived.principal);
        LOG.debug("RECEIVE TICKET << " + messagereceived.ticket);
        LOG.debug("RECEIVE ROLES << " + messagereceived.roles);
        if (LOG.isTraceEnabled()) {
            LOG.trace("RECEIVE MSG = " + messagereceived);
        }
        String ticket = TicketContainer.instance.getTicket(messagereceived.principal);
        if (ticket != null && (messagereceived.ticket == null || !ticket.equals(messagereceived.ticket))) {
            /* not to pollute logs, log instead of exception */
            if (StringUtils.isEmpty(messagereceived.ticket)) {
                LOG.debug("{} message: invalid ticket {} != {}", messagereceived.op, messagereceived.ticket, ticket);
            } else {
                if (!messagereceived.op.equals(OP.PING)) {
                    conn.send(serializeMessage(new Message(OP.SESSION_LOGOUT).put("info", "Your ticket is invalid possibly due to server restart. " + "Please login again.")));
                }
            }
            return;
        }
        ZeppelinConfiguration conf = ZeppelinConfiguration.create();
        boolean allowAnonymous = conf.isAnonymousAllowed();
        if (!allowAnonymous && messagereceived.principal.equals("anonymous")) {
            throw new Exception("Anonymous access not allowed ");
        }
        HashSet<String> userAndRoles = new HashSet<>();
        userAndRoles.add(messagereceived.principal);
        if (!messagereceived.roles.equals("")) {
            HashSet<String> roles = gson.fromJson(messagereceived.roles, new TypeToken<HashSet<String>>() {
            }.getType());
            if (roles != null) {
                userAndRoles.addAll(roles);
            }
        }
        if (StringUtils.isEmpty(conn.getUser())) {
            addUserConnection(messagereceived.principal, conn);
        }
        AuthenticationInfo subject = new AuthenticationInfo(messagereceived.principal, messagereceived.ticket);
        /** Lets be elegant here */
        switch(messagereceived.op) {
            case LIST_NOTES:
                unicastNoteList(conn, subject, userAndRoles);
                break;
            case RELOAD_NOTES_FROM_REPO:
                broadcastReloadedNoteList(subject, userAndRoles);
                break;
            case GET_HOME_NOTE:
                sendHomeNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case GET_NOTE:
                sendNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case NEW_NOTE:
                createNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case DEL_NOTE:
                removeNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case REMOVE_FOLDER:
                removeFolder(conn, userAndRoles, notebook, messagereceived);
                break;
            case MOVE_NOTE_TO_TRASH:
                moveNoteToTrash(conn, userAndRoles, notebook, messagereceived);
                break;
            case MOVE_FOLDER_TO_TRASH:
                moveFolderToTrash(conn, userAndRoles, notebook, messagereceived);
                break;
            case EMPTY_TRASH:
                emptyTrash(conn, userAndRoles, notebook, messagereceived);
                break;
            case RESTORE_FOLDER:
                restoreFolder(conn, userAndRoles, notebook, messagereceived);
                break;
            case RESTORE_NOTE:
                restoreNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case RESTORE_ALL:
                restoreAll(conn, userAndRoles, notebook, messagereceived);
                break;
            case CLONE_NOTE:
                cloneNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case IMPORT_NOTE:
                importNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case COMMIT_PARAGRAPH:
                updateParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case RUN_PARAGRAPH:
                runParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case PARAGRAPH_EXECUTED_BY_SPELL:
                broadcastSpellExecution(conn, userAndRoles, notebook, messagereceived);
                break;
            case RUN_ALL_PARAGRAPHS:
                runAllParagraphs(conn, userAndRoles, notebook, messagereceived);
                break;
            case CANCEL_PARAGRAPH:
                cancelParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case MOVE_PARAGRAPH:
                moveParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case INSERT_PARAGRAPH:
                insertParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case COPY_PARAGRAPH:
                copyParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case PARAGRAPH_REMOVE:
                removeParagraph(conn, userAndRoles, notebook, messagereceived);
                break;
            case PARAGRAPH_CLEAR_OUTPUT:
                clearParagraphOutput(conn, userAndRoles, notebook, messagereceived);
                break;
            case PARAGRAPH_CLEAR_ALL_OUTPUT:
                clearAllParagraphOutput(conn, userAndRoles, notebook, messagereceived);
                break;
            case NOTE_UPDATE:
                updateNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case NOTE_RENAME:
                renameNote(conn, userAndRoles, notebook, messagereceived);
                break;
            case FOLDER_RENAME:
                renameFolder(conn, userAndRoles, notebook, messagereceived);
                break;
            case UPDATE_PERSONALIZED_MODE:
                updatePersonalizedMode(conn, userAndRoles, notebook, messagereceived);
                break;
            case COMPLETION:
                completion(conn, userAndRoles, notebook, messagereceived);
                break;
            case PING:
                //do nothing
                break;
            case ANGULAR_OBJECT_UPDATED:
                angularObjectUpdated(conn, userAndRoles, notebook, messagereceived);
                break;
            case ANGULAR_OBJECT_CLIENT_BIND:
                angularObjectClientBind(conn, userAndRoles, notebook, messagereceived);
                break;
            case ANGULAR_OBJECT_CLIENT_UNBIND:
                angularObjectClientUnbind(conn, userAndRoles, notebook, messagereceived);
                break;
            case LIST_CONFIGURATIONS:
                sendAllConfigurations(conn, userAndRoles, notebook);
                break;
            case CHECKPOINT_NOTE:
                checkpointNote(conn, notebook, messagereceived);
                break;
            case LIST_REVISION_HISTORY:
                listRevisionHistory(conn, notebook, messagereceived);
                break;
            case SET_NOTE_REVISION:
                setNoteRevision(conn, userAndRoles, notebook, messagereceived);
                break;
            case NOTE_REVISION:
                getNoteByRevision(conn, notebook, messagereceived);
                break;
            case LIST_NOTE_JOBS:
                unicastNoteJobInfo(conn, messagereceived);
                break;
            case UNSUBSCRIBE_UPDATE_NOTE_JOBS:
                unsubscribeNoteJobInfo(conn);
                break;
            case GET_INTERPRETER_BINDINGS:
                getInterpreterBindings(conn, messagereceived);
                break;
            case SAVE_INTERPRETER_BINDINGS:
                saveInterpreterBindings(conn, messagereceived);
                break;
            case EDITOR_SETTING:
                getEditorSetting(conn, messagereceived);
                break;
            case GET_INTERPRETER_SETTINGS:
                getInterpreterSettings(conn, subject);
                break;
            case WATCHER:
                switchConnectionToWatcher(conn, messagereceived);
                break;
            default:
                break;
        }
    } catch (Exception e) {
        LOG.error("Can't handle message", e);
    }
}

Example 28 with Message

use of org.apache.zeppelin.notebook.socket.Message in project zeppelin by apache.

the class NotebookServerTest method testImportNotebook.

@Test
public void testImportNotebook() throws IOException {
    String msg = "{\"op\":\"IMPORT_NOTE\",\"data\":" + "{\"note\":{\"paragraphs\": [{\"text\": \"Test " + "paragraphs import\",\"config\":{},\"settings\":{}}]," + "\"name\": \"Test Zeppelin notebook import\",\"config\": " + "{}}}}";
    Message messageReceived = notebookServer.deserializeMessage(msg);
    Note note = null;
    try {
        note = notebookServer.importNote(null, null, notebook, messageReceived);
    } catch (NullPointerException e) {
        //broadcastNoteList(); failed nothing to worry.
        LOG.error("Exception in NotebookServerTest while testImportNotebook, failed nothing to " + "worry ", e);
    }
    assertNotEquals(null, notebook.getNote(note.getId()));
    assertEquals("Test Zeppelin notebook import", notebook.getNote(note.getId()).getName());
    assertEquals("Test paragraphs import", notebook.getNote(note.getId()).getParagraphs().get(0).getText());
    notebook.removeNote(note.getId(), anonymous);
}

Example 29 with Message

use of org.apache.zeppelin.notebook.socket.Message in project zeppelin by apache.

the class NotebookServerTest method unbindAngularObjectFromLocalForParagraphs.

@Test
public void unbindAngularObjectFromLocalForParagraphs() throws Exception {
    //Given
    final String varName = "name";
    final String value = "val";
    final Message messageReceived = new Message(OP.ANGULAR_OBJECT_CLIENT_UNBIND).put("noteId", "noteId").put("name", varName).put("paragraphId", "paragraphId");
    final NotebookServer server = new NotebookServer();
    final Notebook notebook = mock(Notebook.class);
    final Note note = mock(Note.class, RETURNS_DEEP_STUBS);
    when(notebook.getNote("noteId")).thenReturn(note);
    final Paragraph paragraph = mock(Paragraph.class, RETURNS_DEEP_STUBS);
    when(note.getParagraph("paragraphId")).thenReturn(paragraph);
    final AngularObjectRegistry mdRegistry = mock(AngularObjectRegistry.class);
    final InterpreterGroup mdGroup = new InterpreterGroup("mdGroup");
    mdGroup.setAngularObjectRegistry(mdRegistry);
    when(paragraph.getCurrentRepl().getInterpreterGroup()).thenReturn(mdGroup);
    final AngularObject<String> ao1 = AngularObjectBuilder.build(varName, value, "noteId", "paragraphId");
    when(mdRegistry.remove(varName, "noteId", "paragraphId")).thenReturn(ao1);
    NotebookSocket conn = mock(NotebookSocket.class);
    NotebookSocket otherConn = mock(NotebookSocket.class);
    final String mdMsg1 = server.serializeMessage(new Message(OP.ANGULAR_OBJECT_REMOVE).put("angularObject", ao1).put("interpreterGroupId", "mdGroup").put("noteId", "noteId").put("paragraphId", "paragraphId"));
    server.noteSocketMap.put("noteId", asList(conn, otherConn));
    // When
    server.angularObjectClientUnbind(conn, new HashSet<String>(), notebook, messageReceived);
    // Then
    verify(otherConn).send(mdMsg1);
}

Example 30 with Message

use of org.apache.zeppelin.notebook.socket.Message in project zeppelin by apache.

the class NotebookServerTest method testMakeSureNoAngularObjectBroadcastToWebsocketWhoFireTheEvent.

@Test
public void testMakeSureNoAngularObjectBroadcastToWebsocketWhoFireTheEvent() throws IOException {
    // create a notebook
    Note note1 = notebook.createNote(anonymous);
    // get reference to interpreterGroup
    InterpreterGroup interpreterGroup = null;
    List<InterpreterSetting> settings = notebook.getInterpreterSettingManager().getInterpreterSettings(note1.getId());
    for (InterpreterSetting setting : settings) {
        if (setting.getName().equals("md")) {
            interpreterGroup = setting.getInterpreterGroup("anonymous", "sharedProcess");
            break;
        }
    }
    // start interpreter process
    Paragraph p1 = note1.addParagraph(AuthenticationInfo.ANONYMOUS);
    p1.setText("%md start remote interpreter process");
    p1.setAuthenticationInfo(anonymous);
    note1.run(p1.getId());
    // add angularObject
    interpreterGroup.getAngularObjectRegistry().add("object1", "value1", note1.getId(), null);
    // create two sockets and open it
    NotebookSocket sock1 = createWebSocket();
    NotebookSocket sock2 = createWebSocket();
    assertEquals(sock1, sock1);
    assertNotEquals(sock1, sock2);
    notebookServer.onOpen(sock1);
    notebookServer.onOpen(sock2);
    // getNote, getAngularObject
    verify(sock1, times(0)).send(anyString());
    // open the same notebook from sockets
    notebookServer.onMessage(sock1, gson.toJson(new Message(OP.GET_NOTE).put("id", note1.getId())));
    notebookServer.onMessage(sock2, gson.toJson(new Message(OP.GET_NOTE).put("id", note1.getId())));
    reset(sock1);
    reset(sock2);
    // update object from sock1
    notebookServer.onMessage(sock1, gson.toJson(new Message(OP.ANGULAR_OBJECT_UPDATED).put("noteId", note1.getId()).put("name", "object1").put("value", "value1").put("interpreterGroupId", interpreterGroup.getId())));
    // expect object is broadcasted except for where the update is created
    verify(sock1, times(0)).send(anyString());
    verify(sock2, times(1)).send(anyString());
    notebook.removeNote(note1.getId(), anonymous);
}