added bad state of notebook case, to recover

Author: Achal1607

nbcode/notebooks/nbproject/project.xml

@@ -56,23 +56,6 @@
                         <specification-version>1.28</specification-version>
                     </run-dependency>
                 </dependency>
-                <dependency>
-                    <code-name-base>org.netbeans.libs.javacapi</code-name-base>
-                    <build-prerequisite/>
-                    <compile-dependency/>
-                    <run-dependency>
-                        <implementation-version/>
-                    </run-dependency>
-                </dependency>
-                <dependency>
-                    <code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>
-                    <build-prerequisite/>
-                    <compile-dependency/>
-                    <run-dependency>
-                        <release-version>1</release-version>
-                        <specification-version>1.65</specification-version>
-                    </run-dependency>
-                </dependency>
                 <dependency>
                     <code-name-base>org.netbeans.modules.java.lsp.server</code-name-base>
                     <build-prerequisite/>

nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/CellState.java

@@ -15,11 +15,17 @@
  */
 package org.netbeans.modules.nbcode.java.notebook;
 
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Logger;
 import org.eclipse.lsp4j.ExecutionSummary;
 import org.eclipse.lsp4j.NotebookCell;
 import org.eclipse.lsp4j.NotebookCellKind;
 import org.eclipse.lsp4j.TextDocumentItem;
+import org.netbeans.modules.java.lsp.server.notebook.CellStateResponse;
+import org.netbeans.modules.java.lsp.server.notebook.NotebookCellStateParams;
+import org.netbeans.modules.java.lsp.server.protocol.NbCodeLanguageClient;
 
 /**
  *
@@ -29,13 +35,18 @@ public class CellState {
 
     private final NotebookCellKind type;
     private final String language;
+    private final String cellUri;
+    private final String notebookUri;
     private final AtomicReference<Object> metadata;
-    private final AtomicReference<VersionAwareCotent> content;
+    private final AtomicReference<VersionAwareContent> content;
     private final AtomicReference<ExecutionSummary> executionSummary;
+    private static final Logger LOG = Logger.getLogger(CellState.class.getName());
 
-    CellState(NotebookCell notebookCell, TextDocumentItem details) {
+    CellState(NotebookCell notebookCell, TextDocumentItem details, String notebookUri) {
         String normalizedText = NotebookUtils.normalizeLineEndings(details.getText());
-        this.content = new AtomicReference<>(new VersionAwareCotent(normalizedText, details.getVersion()));
+        this.cellUri = details.getUri();
+        this.notebookUri = notebookUri;
+        this.content = new AtomicReference<>(new VersionAwareContent(normalizedText, details.getVersion()));
         this.language = details.getLanguageId();
         this.type = notebookCell.getKind();
         this.metadata = new AtomicReference<>(notebookCell.getMetadata());
@@ -62,19 +73,57 @@ public ExecutionSummary getExecutionSummary() {
         return executionSummary.get();
     }
 
-    public void setContent(String newContent, int newVersion) {
+    public String getCellUri() {
+        return cellUri;
+    }
+
+    public String getNotebookUri() {
+        return notebookUri;
+    }
+
+    public void setContent(String newContent, int newVersion) throws InterruptedException, ExecutionException {
         String normalizedContent = NotebookUtils.normalizeLineEndings(newContent);
-        VersionAwareCotent currentContent = content.get();
+        VersionAwareContent currentContent = content.get();
 
         if (currentContent.getVersion() != newVersion - 1) {
-            throw new IllegalStateException("Version mismatch: expected " + (newVersion - 1) + ", got " + currentContent.getVersion());
+            if (currentContent.getVersion() >= newVersion) {
+                LOG.warning("Current version is higher or equal than the new version request received, so ignoring it.");
+                return;
+            }
+            CompletableFuture<CellStateResponse> response = requestLatestCellState();
+            if (response == null) {
+                throw new IllegalStateException("Unable to send notebook cell state request to the client");
+            }
+
+            CellStateResponse newCellState = response.get();
+            int receivedVersion = newCellState.getVersion();
+
+            if (receivedVersion > currentContent.getVersion()) {
+                VersionAwareContent newVersionContent = new VersionAwareContent(newCellState.getText(), receivedVersion);
+                content.set(newVersionContent);
+            } else {
+                throw new IllegalStateException("Version mismatch: Received version to be greater than current version, received version:  " + (receivedVersion) + ", current version: " + currentContent.getVersion());
+            }
+        } else {
+            VersionAwareContent newVersionContent = new VersionAwareContent(normalizedContent, newVersion);
+
+            if (!content.compareAndSet(currentContent, newVersionContent)) {
+                throw new IllegalStateException("Concurrent modification detected. Version expected: " + (newVersion - 1) + ", current: " + content.get().getVersion());
+            }
         }
+    }
 
-        VersionAwareCotent newVersionContent = new VersionAwareCotent(normalizedContent, newVersion);
-
-        if (!content.compareAndSet(currentContent, newVersionContent)) {
-            throw new IllegalStateException("Concurrent modification detected. Version expected: " + (newVersion - 1) + ", current: " + content.get().getVersion());
+    public void requestContentAndSet() throws InterruptedException, ExecutionException {
+        CompletableFuture<CellStateResponse> response = requestLatestCellState();
+        if (response == null) {
+            throw new IllegalStateException("Unable to send notebook cell state request to the client");
         }
+        CellStateResponse newCellState = response.get();
+        if (newCellState.getVersion() <= 0) {
+            throw new IllegalStateException("Received incorrect version number: " + newCellState.getVersion());
+        }
+        VersionAwareContent newVersionContent = new VersionAwareContent(newCellState.getText(), newCellState.getVersion());
+        content.set(newVersionContent);
     }
 
     public void setExecutionSummary(ExecutionSummary executionSummary) {
@@ -85,12 +134,27 @@ public void setMetadata(Object metadata) {
         this.metadata.set(metadata);
     }
 
-    private class VersionAwareCotent {
+    // protected methods for ease of unit testing 
+    protected CompletableFuture<CellStateResponse> requestLatestCellState() {
+        NbCodeLanguageClient client = LanguageClientInstance.getInstance().getClient();
+
+        if (client == null) {
+            LOG.warning("Client is null");
+            return null;
+        }
+        return client.getNotebookCellState(new NotebookCellStateParams(notebookUri, cellUri));
+    }
+    
+    protected VersionAwareContent getVersionAwareContent(){
+        return this.content.get();
+    }
+
+    protected class VersionAwareContent {
 
         private String content;
         private int version;
 
-        public VersionAwareCotent(String content, int version) {
+        public VersionAwareContent(String content, int version) {
             this.content = content;
             this.version = version;
         }

nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/NotebookDocumentStateManager.java

@@ -150,14 +150,17 @@ private void updateNotebookCellContent(NotebookDocumentChangeEventCellTextConten
         }
         int newVersion = contentChange.getDocument().getVersion();
         String currentContent = cellState.getContent();
-        if (!contentChange.getChanges().isEmpty()) {
+        
+        try {
+            String updatedContent = applyContentChanges(currentContent, contentChange.getChanges());
+            cellState.setContent(updatedContent, newVersion);
+            LOG.log(Level.FINE, "Updated content for cell: {0}, version: {1}", new Object[]{uri, newVersion});
+        } catch (Exception e) {
+            LOG.log(Level.WARNING, "applyContentChanges failed, requesting full content: " + uri, e);
             try {
-                String updatedContent = applyContentChanges(currentContent, contentChange.getChanges());
-                cellState.setContent(updatedContent, newVersion);
-                LOG.log(Level.FINE, "Updated content for cell: {0}, version: {1}", new Object[]{uri, newVersion});
-            } catch (Exception e) {
-                LOG.log(Level.SEVERE, "Failed to apply content changes to cell: " + uri, e);
-                throw new RuntimeException("Failed to apply content changes", e);
+                cellState.requestContentAndSet();
+            } catch (Exception ex) {
+                LOG.log(Level.SEVERE, "Failed to refresh content for cell: " + uri, ex);
             }
         }
     }
@@ -217,20 +220,24 @@ private String applyRangeChange(String content, TextDocumentContentChangeEvent c
 
         return result.toString();
     }
-
-    private void addNewCellState(NotebookCell cell, TextDocumentItem item) {
+    // protected methods for ease of unit testing
+    protected void addNewCellState(NotebookCell cell, TextDocumentItem item) {
         if (cell == null || item == null) {
             LOG.log(Level.WARNING, "Attempted to add null cell or item");
             return;
         }
 
         try {
-            CellState cellState = new CellState(cell, item);
+            CellState cellState = new CellState(cell, item, notebookDoc.getUri());
             cellsMap.put(item.getUri(), cellState);
             LOG.log(Level.FINE, "Added new cell state: {0}", item.getUri());
         } catch (Exception e) {
             LOG.log(Level.SEVERE, "Failed to create cell state for: " + item.getUri(), e);
             throw new RuntimeException("Failed to create cell state", e);
         }
     }
+    
+    protected Map<String, CellState> getCellsMap(){
+        return cellsMap;
+    }
 }