private StepStateChange createStepStateChange(ExecutionState executionState, Map metadata) {
    INodeEntry currentNode = stepContext.getCurrentNode();

    return StateUtils.stepStateChange(
        StateUtils.stepState(executionState, metadata),
        null != currentNode ? currentNode.getNodename() : null);
  }
Exemple #2
0
 /**
  * @return the default file extension for a temp file based on the type of node
  * @param node node
  */
 public static String defaultRemoteFileExtensionForNode(final INodeEntry node) {
   if (null != node.getOsFamily() && "windows".equalsIgnoreCase(node.getOsFamily().trim())) {
     return DEFAULT_WINDOWS_FILE_EXT;
   } else {
     return DEFAULT_UNIX_FILE_EXT;
   }
 }
 private List<String> getNodeNames(StepExecutionContext executionContext) {
   List<INodeEntry> orderedNodes =
       INodeEntryComparator.rankOrderedNodes(
           executionContext.getNodes(),
           executionContext.getNodeRankAttribute(),
           executionContext.isNodeRankOrderAscending());
   List<String> names = new ArrayList<String>();
   for (INodeEntry orderedNode : orderedNodes) {
     names.add(orderedNode.getNodename());
   }
   return names;
 }
  /**
   * Convert map of step execution results keyed by step number, to a collection of step execution
   * results keyed by node name
   */
  protected Map<String, Collection<StepExecutionResult>> convertFailures(
      final Map<Integer, StepExecutionResult> failedMap) {

    final Map<String, Collection<StepExecutionResult>> failures =
        new HashMap<String, Collection<StepExecutionResult>>();
    for (final Map.Entry<Integer, StepExecutionResult> entry : failedMap.entrySet()) {
      final StepExecutionResult o = entry.getValue();

      if (NodeDispatchStepExecutor.isWrappedDispatcherResult(o)) {
        // indicates dispatcher returned node results
        final DispatcherResult dispatcherResult =
            NodeDispatchStepExecutor.extractDispatcherResult(o);

        for (final String s : dispatcherResult.getResults().keySet()) {
          final NodeStepResult interpreterResult = dispatcherResult.getResults().get(s);
          if (!failures.containsKey(s)) {
            failures.put(s, new ArrayList<StepExecutionResult>());
          }
          failures.get(s).add(interpreterResult);
        }
      } else if (NodeDispatchStepExecutor.isWrappedDispatcherException(o)) {
        DispatcherException e = NodeDispatchStepExecutor.extractDispatcherException(o);
        final INodeEntry node = e.getNode();
        if (null != node) {
          // dispatch failed for a specific node
          final String key = node.getNodename();
          if (!failures.containsKey(key)) {
            failures.put(key, new ArrayList<StepExecutionResult>());
          }
          failures.get(key).add(e.getResultMap().get(node.getNodename()));
        } else {
          // dispatch failed for a set of nodes
          for (final String s : e.getResultMap().keySet()) {
            final NodeStepResult interpreterResult = e.getResultMap().get(s);
            if (!failures.containsKey(s)) {
              failures.put(s, new ArrayList<StepExecutionResult>());
            }
            failures.get(s).add(interpreterResult);
          }
        }
      }
    }
    return failures;
  }
  @Test
  public void testConvert() throws Exception {

    Node puppetNode = new Node();
    puppetNode.setName(NODE_NAME);

    List<Node> puppetNodes = new ArrayList<>();
    puppetNodes.add(puppetNode);

    PuppetNodesToRundeckConverter sut = new PuppetNodesToRundeckConverter(USERNAME);

    INodeSet rundeckNodes = sut.convert(puppetNodes);

    INodeEntry rundeckNode = rundeckNodes.getNode(NODE_NAME);

    assertThat(rundeckNode.getNodename(), is(NODE_NAME));
    assertThat(rundeckNode.getHostname(), is(NODE_NAME));
    assertThat(rundeckNode.getUsername(), is(USERNAME));
  }
 public void beginWorkflowExecution(
     StepExecutionContext executionContext, WorkflowExecutionItem item) {
   StepContextId currentStep = stepContext.getCurrentStep();
   INodeEntry currentNode = stepContext.getCurrentNode();
   if (null != currentNode && null != currentStep) {
     // if already node context, begin a parameterized sub workflow
     // change step context to include node name parameter for the step id
     HashMap<String, String> params = new HashMap<String, String>();
     params.put("node", currentNode.getNodename());
     stepContext.beginStepContext(
         StateUtils.stepContextId(
             currentStep.getStep(), !currentStep.getAspect().isMain(), params));
   }
   stepContext.beginContext();
   List<Pair<StepContextId, INodeEntry>> currentContext = stepContext.getCurrentContextPairs();
   List<String> names = getNodeNames(executionContext);
   if (null == currentContext) {
     notifyAllWorkflowState(ExecutionState.RUNNING, new Date(), names);
   } else {
     notifyAllSubWorkflowState(createIdentifier(), ExecutionState.RUNNING, new Date(), names);
   }
 }
  public DispatcherResult dispatch(
      final ExecutionContext context, final ExecutionItem item, final Dispatchable toDispatch)
      throws DispatcherException {
    final NodesSelector nodesSelector = context.getNodeSelector();
    INodeSet nodes = null;
    try {
      nodes =
          framework.filterAuthorizedNodes(
              context.getFrameworkProject(),
              new HashSet<String>(Arrays.asList("read", "run")),
              framework.filterNodeSet(
                  nodesSelector, context.getFrameworkProject(), context.getNodesFile()));
    } catch (NodeFileParserException e) {
      throw new DispatcherException(e);
    }
    if (nodes.getNodes().size() < 1) {
      throw new DispatcherException("No nodes matched");
    }
    boolean keepgoing = context.isKeepgoing();

    context
        .getExecutionListener()
        .log(4, "preparing for sequential execution on " + nodes.getNodes().size() + " nodes");
    final HashSet<String> nodeNames = new HashSet<String>(nodes.getNodeNames());
    final HashMap<String, Object> failures = new HashMap<String, Object>();
    FailedNodesListener failedListener = context.getExecutionListener().getFailedNodesListener();
    if (null != failedListener) {
      failedListener.matchedNodes(nodeNames);
    }
    boolean interrupted = false;
    final Thread thread = Thread.currentThread();
    boolean success = true;
    final HashMap<String, StatusResult> resultMap = new HashMap<String, StatusResult>();
    final Collection<INodeEntry> nodes1 = nodes.getNodes();
    // reorder based on configured rank property and order
    final String rankProperty =
        null != context.getNodeRankAttribute() ? context.getNodeRankAttribute() : "nodename";
    final boolean rankAscending = context.isNodeRankOrderAscending();
    final INodeEntryComparator comparator = new INodeEntryComparator(rankProperty);
    final TreeSet<INodeEntry> orderedNodes =
        new TreeSet<INodeEntry>(rankAscending ? comparator : Collections.reverseOrder(comparator));
    orderedNodes.addAll(nodes1);
    for (final Object node1 : orderedNodes) {
      if (thread.isInterrupted()
          || thread instanceof ExecutionServiceThread
              && ((ExecutionServiceThread) thread).isAborted()) {
        interrupted = true;
        break;
      }
      final INodeEntry node = (INodeEntry) node1;
      context
          .getExecutionListener()
          .log(
              Constants.DEBUG_LEVEL,
              "Executing command on node: " + node.getNodename() + ", " + node.toString());
      try {

        if (thread.isInterrupted()
            || thread instanceof ExecutionServiceThread
                && ((ExecutionServiceThread) thread).isAborted()) {
          interrupted = true;
          break;
        }
        final StatusResult result;
        final ExecutionContext interimcontext =
            new ExecutionContextImpl.Builder(context)
                .nodeSelector(SelectorUtils.singleNode(node.getNodename()))
                .build();
        if (null != item) {
          result = framework.getExecutionService().interpretCommand(interimcontext, item, node);
        } else {
          result = toDispatch.dispatch(interimcontext, node);
        }
        if (null != result) {
          resultMap.put(node.getNodename(), result);
        }
        if (null == result || !result.isSuccess()) {
          success = false;
          //                    context.getExecutionListener().log(Constants.ERR_LEVEL,
          //                        "Failed execution for node " + node.getNodename() + ": " +
          // result);
          if (null != result) {
            failures.put(node.getNodename(), result);
          } else {
            failures.put(node.getNodename(), "Failed execution, result was null");
          }
          if (!keepgoing) {
            break;
          }
        } else {
          nodeNames.remove(node.getNodename());
        }
      } catch (Throwable e) {
        success = false;
        failures.put(
            node.getNodename(), "Error dispatching command to the node: " + e.getMessage());
        context
            .getExecutionListener()
            .log(
                Constants.ERR_LEVEL,
                "Failed dispatching to node " + node.getNodename() + ": " + e.getMessage());

        final StringWriter stringWriter = new StringWriter();
        e.printStackTrace(new PrintWriter(stringWriter));
        context
            .getExecutionListener()
            .log(
                Constants.DEBUG_LEVEL,
                "Failed dispatching to node "
                    + node.getNodename()
                    + ": "
                    + stringWriter.toString());

        if (!keepgoing) {
          if (failures.size() > 0 && null != failedListener) {
            // tell listener of failed node list
            failedListener.nodesFailed(failures);
          }
          throw new DispatcherException(
              "Failed dispatching to node " + node.getNodename() + ": " + e.getMessage(), e, node);
        }
      }
    }
    if (keepgoing && nodeNames.size() > 0) {
      if (null != failedListener) {
        // tell listener of failed node list
        failedListener.nodesFailed(failures);
      }
      // now fail
      // XXX: needs to change from exception
      throw new NodesetFailureException(failures);
    } else if (null != failedListener && failures.isEmpty() && !interrupted) {
      failedListener.nodesSucceeded();
    }
    if (interrupted) {
      throw new DispatcherException("Node dispatch interrupted");
    }

    final boolean status = success;
    return new DispatcherResult() {
      public Map<String, ? extends StatusResult> getResults() {
        return resultMap;
      }

      public boolean isSuccess() {
        return status;
      }

      @Override
      public String toString() {
        return "DispatcherResult{"
            + "status="
            + isSuccess()
            + ", "
            + "results="
            + getResults()
            + "}";
      }
    };
  }
 private StepStateChange createStepStateChange(
     StepExecutionResult result, INodeEntry currentNode) {
   return StateUtils.stepStateChange(
       StateUtils.stepState(resultState(result), resultMetadata(result), resultMessage(result)),
       null != currentNode ? currentNode.getNodename() : null);
 }