Esempio n. 1
0
  /* (non-Javadoc)
   * @see org.eclipse.tcf.te.runtime.stepper.interfaces.IStep#execute(org.eclipse.tcf.te.runtime.stepper.interfaces.IStepContext, org.eclipse.tcf.te.runtime.interfaces.properties.IPropertiesContainer, org.eclipse.tcf.te.runtime.stepper.interfaces.IFullQualifiedId, org.eclipse.core.runtime.IProgressMonitor, org.eclipse.tcf.te.runtime.interfaces.callback.ICallback)
   */
  @Override
  public void execute(
      IStepContext context,
      IPropertiesContainer data,
      IFullQualifiedId fullQualifiedId,
      IProgressMonitor monitor,
      final ICallback callback) {
    IPeerNode peerNode = getActivePeerModelContext(context, data, fullQualifiedId);
    if (peerNode != null) {
      IRuntimeModel model = ModelManager.getRuntimeModel(peerNode);
      final IModelChannelService service =
          model != null ? model.getService(IModelChannelService.class) : null;
      if (service != null) {
        Runnable runnable =
            new Runnable() {
              @Override
              public void run() {
                service.openChannel(
                    new IModelChannelService.DoneOpenChannel() {
                      @Override
                      public void doneOpenChannel(Throwable error, IChannel channel) {
                        callback.done(InitializeModelStep.this, StatusHelper.getStatus(error));
                      }
                    });
              }
            };

        Protocol.invokeLater(runnable);
      } else {
        callback.done(InitializeModelStep.this, Status.OK_STATUS);
      }
    } else {
      callback.done(InitializeModelStep.this, Status.OK_STATUS);
    }
  }
Esempio n. 2
0
  public void testGetWithManyClients() throws InterruptedException, ExecutionException {
    // Check initial state
    Assert.assertFalse(fTestCache.isValid());

    // Request data from cache
    List<Query<Integer>> qList = new ArrayList<Query<Integer>>();
    for (int i = 0; i < 10; i++) {
      Query<Integer> q = new TestQuery();
      q.invoke();
      qList.add(q);
    }
    // Wait until the cache starts data retrieval.
    waitForRetrieveRm();

    // Check state while waiting for data
    Assert.assertFalse(fTestCache.isValid());

    // Set the data to the callback
    Protocol.invokeLater(
        new Runnable() {
          public void run() {
            fRetrieveRm.setData(1);
            fRetrieveRm.done();
          }
        });

    for (Query<Integer> q : qList) {
      Assert.assertEquals(1, (int) q.get());
    }

    // Check final state
    assertCacheValidWithData(1);
  }
Esempio n. 3
0
  public void testGetWithTwoClients() throws InterruptedException, ExecutionException {
    // Check initial state
    Assert.assertFalse(fTestCache.isValid());

    // Request data from cache
    Query<Integer> q1 = new TestQuery();
    q1.invoke();

    // Request data from cache again
    Query<Integer> q2 = new TestQuery();
    q2.invoke();

    // Wait until the cache starts data retrieval.
    waitForRetrieveRm();

    // Check state while waiting for data
    Assert.assertFalse(fTestCache.isValid());

    // Set the data to the callback
    Protocol.invokeLater(
        new Runnable() {
          public void run() {
            fRetrieveRm.setData(1);
            fRetrieveRm.done();
          }
        });

    Assert.assertEquals(1, (int) q1.get());
    Assert.assertEquals(1, (int) q2.get());

    // Check final state
    assertCacheValidWithData(1);
  }
Esempio n. 4
0
 @Override
 public void selectionChanged(IWorkbenchPart part, ISelection selection) {
   updateAnnotations(part.getSite().getWorkbenchWindow(), (TCFLaunch) null);
   if (selection instanceof IStructuredSelection) {
     final Object obj = ((IStructuredSelection) selection).getFirstElement();
     if (obj instanceof TCFNodeStackFrame && ((TCFNodeStackFrame) obj).isTraceLimit()) {
       Protocol.invokeLater(
           new Runnable() {
             public void run() {
               ((TCFNodeStackFrame) obj).riseTraceLimit();
             }
           });
     }
   }
 }
Esempio n. 5
0
  /* (non-Javadoc)
   * @see org.eclipse.jface.viewers.ITreeViewerListener#treeExpanded(org.eclipse.jface.viewers.TreeExpansionEvent)
   */
  @Override
  public void treeExpanded(TreeExpansionEvent event) {
    // Get the expanded element
    Object element = event.getElement();
    if (element instanceof IProcessContextNode) {
      final IProcessContextNode node = (IProcessContextNode) element;

      // Flag that tells if the node shall be refreshed
      boolean needsRefresh = false;

      // Get the asynchronous refresh context adapter
      final IAsyncRefreshableCtx refreshable =
          (IAsyncRefreshableCtx) node.getAdapter(IAsyncRefreshableCtx.class);
      Assert.isNotNull(refreshable);
      // The node needs to be refreshed if the child list query is not done
      if (refreshable.getQueryState(QueryType.CHILD_LIST).equals(QueryState.PENDING)) {
        needsRefresh = true;
      } else if (refreshable.getQueryState(QueryType.CHILD_LIST).equals(QueryState.DONE)) {
        // Our policy is that the current node and it's level 1 children are always
        // fully refreshed. The child list query for the current node is not pending,
        // so check the children nodes if they need a refresh
        for (final IProcessContextNode candidate : node.getChildren(IProcessContextNode.class)) {
          // Get the asynchronous refresh context adapter
          final IAsyncRefreshableCtx r =
              (IAsyncRefreshableCtx) candidate.getAdapter(IAsyncRefreshableCtx.class);
          Assert.isNotNull(r);
          // If the child list query state is still pending, set the flag and break out of the loop
          if (r.getQueryState(QueryType.CHILD_LIST).equals(QueryState.PENDING)) {
            needsRefresh = true;
            break;
          }
        }
      }

      // If the node needs to be refreshed, refresh it now.
      if (needsRefresh) {
        // Mark the refresh as in progress
        refreshable.setQueryState(QueryType.CHILD_LIST, QueryState.IN_PROGRESS);
        // Create a new pending operation node and associate it with the refreshable
        PendingOperationModelNode pendingNode = new PendingOperationNode();
        pendingNode.setParent(node);
        refreshable.setPendingOperationNode(pendingNode);

        Runnable runnable =
            new Runnable() {
              @Override
              public void run() {
                // Trigger a refresh of the view content.
                ChangeEvent ev =
                    new ChangeEvent(node, IContainerModelNode.NOTIFY_CHANGED, null, null);
                EventManager.getInstance().fireEvent(ev);

                // Get the parent model of the node
                IModel model = node.getParent(IModel.class);
                Assert.isNotNull(model);

                // Don't send change events while refreshing
                final boolean changed = node.setChangeEventsEnabled(false);
                // Initiate the refresh
                model
                    .getService(IModelRefreshService.class)
                    .refresh(
                        node,
                        new Callback() {
                          @Override
                          protected void internalDone(Object caller, IStatus status) {
                            // Mark the refresh as done
                            refreshable.setQueryState(QueryType.CHILD_LIST, QueryState.DONE);
                            // Reset the pending operation node
                            refreshable.setPendingOperationNode(null);
                            // Re-enable the change events if they had been enabled before
                            if (changed) node.setChangeEventsEnabled(true);
                            // Trigger a refresh of the view content
                            ChangeEvent event =
                                new ChangeEvent(
                                    node, IContainerModelNode.NOTIFY_CHANGED, null, null);
                            EventManager.getInstance().fireEvent(event);
                          }
                        });
              }
            };

        Protocol.invokeLater(runnable);
      }
    }
  }
Esempio n. 6
0
  private void updateAnnotations(final IWorkbenchWindow window, final TCFNode node) {
    if (disposed) return;
    assert Thread.currentThread() == display.getThread();
    final WorkbenchWindowInfo win_info = windows.get(window);
    if (win_info == null) return;
    ITCFAnnotationProvider provider = TCFAnnotationProvider.getAnnotationProvider(node);
    if (win_info.provider != provider) {
      if (win_info.provider != null) win_info.provider.updateAnnotations(window, null);
      win_info.provider = provider;
    }
    if (win_info.provider != null) {
      if (win_info.annotations.size() > 0) {
        for (TCFAnnotation a : win_info.annotations) a.dispose();
        win_info.annotations.clear();
      }
      win_info.update_node = node;
      win_info.update_task = null;
      win_info.provider.updateAnnotations(window, node);
      return;
    }
    if (win_info.update_node == node && win_info.update_task != null && !win_info.update_task.done)
      return;
    win_info.update_node = node;
    win_info.update_task =
        new UpdateTask() {
          public void run() {
            if (win_info.update_task != this) {
              /* Selection has changed and another update has started - abort this */
              return;
            }
            if (node == null) {
              /* No selection - no annotations */
              done(null);
              return;
            }
            if (node.isDisposed()) {
              /* Selected node disposed - no annotations */
              done(null);
              return;
            }
            TCFNodeExecContext thread = null;
            TCFNodeExecContext memory = null;
            TCFNodeStackFrame frame = null;
            TCFNodeStackFrame last_top_frame = null;
            String bp_group = null;
            boolean suspended = false;
            if (node instanceof TCFNodeStackFrame) {
              thread = (TCFNodeExecContext) node.parent;
              frame = (TCFNodeStackFrame) node;
              // Make sure frame.getFrameNo() is valid
              TCFChildrenStackTrace trace = thread.getStackTrace();
              if (!trace.validate(this)) return;
            } else if (node instanceof TCFNodeExecContext) {
              thread = (TCFNodeExecContext) node;
              // Make sure frame.getTopFrame() is valid
              TCFChildrenStackTrace trace = thread.getStackTrace();
              if (!trace.validate(this)) return;
              frame = trace.getTopFrame();
            }
            if (thread != null) {
              TCFDataCache<IRunControl.RunControlContext> rc_ctx_cache = thread.getRunContext();
              if (!rc_ctx_cache.validate(this)) return;
              IRunControl.RunControlContext rc_ctx_data = rc_ctx_cache.getData();
              if (rc_ctx_data != null) bp_group = rc_ctx_data.getBPGroup();
              TCFDataCache<TCFNodeExecContext> mem_cache = thread.getMemoryNode();
              if (!mem_cache.validate(this)) return;
              memory = mem_cache.getData();
              if (bp_group == null
                  && memory != null
                  && rc_ctx_data != null
                  && rc_ctx_data.hasState()) bp_group = memory.id;
              last_top_frame = thread.getLastTopFrame();
              TCFDataCache<TCFContextState> state_cache = thread.getState();
              if (!state_cache.validate(this)) return;
              suspended = state_cache.getData() != null && state_cache.getData().is_suspended;
            }
            Set<TCFAnnotation> set = new LinkedHashSet<TCFAnnotation>();
            if (memory != null) {
              TCFLaunch launch = node.launch;
              TCFBreakpointsStatus bs = launch.getBreakpointsStatus();
              if (bs != null) {
                for (String id : bs.getStatusIDs()) {
                  Map<String, Object> map = bs.getStatus(id);
                  if (map == null) continue;
                  String error = (String) map.get(IBreakpoints.STATUS_ERROR);
                  if (error != null)
                    addBreakpointErrorAnnotation(set, launch, memory.id, id, error);
                  Object[] arr = toObjectArray(map.get(IBreakpoints.STATUS_INSTANCES));
                  if (arr == null) continue;
                  for (Object o : arr) {
                    Map<String, Object> m = toObjectMap(o);
                    String ctx_id = (String) m.get(IBreakpoints.INSTANCE_CONTEXT);
                    if (ctx_id == null) continue;
                    if (!ctx_id.equals(node.id) && !ctx_id.equals(bp_group)) continue;
                    error = (String) m.get(IBreakpoints.INSTANCE_ERROR);
                    BigInteger addr =
                        JSON.toBigInteger((Number) m.get(IBreakpoints.INSTANCE_ADDRESS));
                    ILineNumbers.CodeArea area = null;
                    ILineNumbers.CodeArea org_area = getBreakpointCodeArea(launch, id);
                    if (addr != null) {
                      TCFDataCache<TCFSourceRef> line_cache = memory.getLineInfo(addr);
                      if (line_cache != null) {
                        if (!line_cache.validate(this)) return;
                        TCFSourceRef line_data = line_cache.getData();
                        if (line_data != null) area = line_data.area;
                      }
                    }
                    if (area == null) area = org_area;
                    String bp_name = "Breakpoint";
                    IBreakpoint bp = TCFBreakpointsModel.getBreakpointsModel().getBreakpoint(id);
                    if (bp != null)
                      bp_name =
                          bp.getMarker().getAttribute(TCFBreakpointsModel.ATTR_MESSAGE, bp_name);
                    if (error != null) {
                      String location = "";
                      if (addr != null) location = " at 0x" + addr.toString(16);
                      if (org_area == null) org_area = area;
                      TCFAnnotation a =
                          new TCFAnnotation(
                              memory.id,
                              id,
                              addr,
                              org_area,
                              ImageCache.IMG_BREAKPOINT_ERROR,
                              bp_name + " failed to plant" + location + ": " + error,
                              TYPE_BP_INSTANCE);
                      set.add(a);
                    } else if (area != null && addr != null) {
                      String location =
                          " planted at 0x" + addr.toString(16) + ", line " + area.start_line;
                      TCFAnnotation a =
                          new TCFAnnotation(
                              memory.id,
                              id,
                              addr,
                              area,
                              ImageCache.IMG_BREAKPOINT_INSTALLED,
                              bp_name + location,
                              TYPE_BP_INSTANCE);
                      a.breakpoint = bp;
                      set.add(a);
                      if (isLineAdjusted(area, org_area)) {
                        TCFAnnotation b =
                            new TCFAnnotation(
                                memory.id,
                                id,
                                null,
                                org_area,
                                ImageCache.IMG_BREAKPOINT_WARNING,
                                "Breakpoint location is adjusted: " + location,
                                TYPE_BP_INSTANCE);
                        set.add(b);
                      }
                    }
                    error = (String) m.get(IBreakpoints.INSTANCE_CONDITION_ERROR);
                    if (error != null) {
                      TCFAnnotation a =
                          new TCFAnnotation(
                              memory.id,
                              id,
                              addr,
                              org_area,
                              ImageCache.IMG_BREAKPOINT_ERROR,
                              bp_name + " failed to evaluate condition: " + error,
                              TYPE_BP_INSTANCE);
                      set.add(a);
                    }
                  }
                }
              }
            }
            if (suspended && frame != null && frame.getFrameNo() >= 0) {
              TCFDataCache<TCFSourceRef> line_cache = frame.getLineInfo();
              if (!line_cache.validate(this)) return;
              TCFSourceRef line_data = line_cache.getData();
              if (line_data != null && line_data.area != null) {
                TCFAnnotation a = null;
                String addr_str = "";
                TCFDataCache<BigInteger> addr_cache = frame.getAddress();
                if (!addr_cache.validate(this)) return;
                BigInteger addr_data = addr_cache.getData();
                if (addr_data != null) addr_str += ", IP: 0x" + addr_data.toString(16);
                TCFDataCache<IStackTrace.StackTraceContext> frame_cache =
                    frame.getStackTraceContext();
                if (!frame_cache.validate(this)) return;
                IStackTrace.StackTraceContext frame_data = frame_cache.getData();
                if (frame_data != null) {
                  BigInteger i = JSON.toBigInteger(frame_data.getFrameAddress());
                  if (i != null) addr_str += ", FP: 0x" + i.toString(16);
                }
                addr_str += ", line: " + line_data.area.start_line;
                if (frame.getFrameNo() == 0) {
                  a =
                      new TCFAnnotation(
                          line_data.context_id,
                          null,
                          null,
                          line_data.area,
                          ImageCache.IMG_INSTRUCTION_POINTER_TOP,
                          "Current Instruction Pointer" + addr_str,
                          TYPE_TOP_FRAME);
                } else {
                  a =
                      new TCFAnnotation(
                          line_data.context_id,
                          null,
                          null,
                          line_data.area,
                          ImageCache.IMG_INSTRUCTION_POINTER,
                          "Call Stack Frame" + addr_str,
                          TYPE_STACK_FRAME);
                }
                set.add(a);
              }
            }
            if (!suspended && last_top_frame != null) {
              TCFDataCache<TCFSourceRef> line_cache = last_top_frame.getLineInfo();
              if (!line_cache.validate(this)) return;
              TCFSourceRef line_data = line_cache.getData();
              if (line_data != null && line_data.area != null) {
                TCFAnnotation a =
                    new TCFAnnotation(
                        line_data.context_id,
                        null,
                        null,
                        line_data.area,
                        ImageCache.IMG_INSTRUCTION_POINTER,
                        "Last Instruction Pointer position",
                        TYPE_STACK_FRAME);
                set.add(a);
              }
            }
            done(set);
          }

          private void done(final Set<TCFAnnotation> res) {
            done = true;
            final Runnable update_task = this;
            displayExec(
                new Runnable() {
                  public void run() {
                    if (update_task != win_info.update_task) return;
                    assert win_info.update_node == node;
                    win_info.update_task = null;
                    try {
                      ResourcesPlugin.getWorkspace()
                          .run(
                              new IWorkspaceRunnable() {
                                public void run(IProgressMonitor monitor) throws CoreException {
                                  updateAnnotations(window, node, res);
                                }
                              },
                              null);
                    } catch (Exception e) {
                      Activator.log(e);
                    }
                  }
                });
          }
        };
    Protocol.invokeLater(win_info.update_task);
  }