Is jinja template syntax still supported?

[fjpalacios-ust]

Hello everyone,

I'm having trouble looping elements and iterating over them. Having in context the items variable defined, something like this works:

  iterate_items:
    with:
      items: <% ctx(items) %>
    action: core.echo message=<% item() %>

But at the moment when there is a next: to be able to publish the items of that item, item() is None and there is no way to pass that data obtained to another action.

In case jinja templates are still supported, and in particular loops, how could I do something like this?

{%- for item in items %}
   iterate_items:
    action: core.echo message={{ item }}
{% endfor %}

Of course, this I've already tried but I get an error.

[nzlosh]

You should review how with-items functions because it does not operate like a typical programming loop. https://docs.stackstorm.com/orquesta/languages/orquesta.html#with-items-model

Specifically:

The task result is a list of the action execution results in the same order as the items.

In your example, core.echo would be executed n times, where n is the number of elements in the items list. item() is populated only during the action call, which is why it is None when dereferencing it in the next section.

[fjpalacios-ust]

I understand.

And what would be the most correct way to do what I want to do? To be more specific: iterate the items, be able to have a next step, have the item there and be able to work with it to later make a publish and be able to send that data to another subsequent action. Something similar to the way you would work with the jinja template.

Thank you very much!

[nzlosh]

With items only allows for a result list to be produced by the action/workflow. The jinja block you showed as an example is not supported by stackstorm and is not how a workflow is parsed and evaluated so it won't work. Jinja blocks {% %} aren't supported either, only jinja statements {{ }}.

A workaround would be to write your own loop logic into multiple actions. The pseudo code:

var_list=[1,2,3]
var_iter = 0

step1_iter:
  action: core.noop
  next:
    - do: step1
      when: <% var_iter < len(var_list) %>
    - do: step2
      when: <% var_iter >= len(var_list) %>

step1:
   action: core.local
   input:
     cmd: echo <% var_list[var_iter] %>
   next:
    - do: step1_iter
      publish:
        - var_iter = var_iter + 1

step2:
  .....

The above is just an example of the concept and untested, but the idea is there. This solution also suffers from being non-parallel which is not the case for with-items.

Personally, I'd avoid writing workflows with the above workaround as it's error prone and harder read/understand when multiple actions are involved.

[fjpalacios-ust]

Great, thanks so much for the help!