Send Result of sub-task to another sub-task

[davama]

Hello,

Im playing around with nornir subtasks. It's pretty awesome!

I got this going:

def transform_data(task: Task, interfaces_data, vlan_data) -> Result:
    interface_to_vlan_data = napalm_reverse_vlan_to_interface_data(interfaces_data,vlan_data)
    return Result(host=task.host, result=interface_to_vlan_data)

def dummy_task(task: Task) -> Result:
    sleep(randint(1,10))
    return Result(host=task.host, result=f'{task.host.name} finished {task.name}')

def main_task(task: Task, nb_obj) -> Result:
    nb = nb_obj

    # dummy task for illustration
    sub_results = task.run(name='illustration_task', task=dummy_task)

    # get interface data
    interface_results = task.run(name='get_interfaces', task=napalm_get, getters=["get_interfaces"])
    #get_interfaces_output = interface_results.result

    # get vlan data
    vlan_results = task.run(name='get_vlans', task=napalm_get, getters=["get_vlans_custom"])
    #get_vlans_custom_output = vlan_results.result

    # transform my data
    transform_results = task.run(task=transform_data, interfaces_data=interface_results.result, vlan_data=vlan_results.result)
    #interface_to_vlan_data = transform_results.result

    return Result(host=task.host, result=f'{task.host.name} finished {task.name}')


main_results = devices.run(task=main_task, nb_obj=nb)

Works fine until i get to transform_data task.
I want to pass the per-device.result data to it the transform_data task.

Anything off with the above?

I can paste more code if necessary.

Any input is much appreciated!

-Dave

[dbarrosop]

You have two options:

1. store the data in the host itself (something like task.host["interface_to_vlan_data"] = interface_to_vlan_data
2. group tasks together, something like:

def my_super_task(task: Task, ...) -> Result:
    result1 = task.run(some_task)
    result2 = task.run(some_other_task, some_arg1=result1)
    result3 = task.run(yet_another_task, some_arg2=result2)
   ...

[davama]

Thank you @dbarrosop for the reply!

I went ahead with option 2 and was able to get something working, but as i explored the results output i noticed something interesting:

All three results from my subtasks return as MultiResult objects which is good

MultiResult: [Result: "get_interfaces"]
MultiResult: [Result: "get_vlans"]
MultiResult: [Result: "transform_task"]

When i send interface_results and vlan_results to transform_task i have to access the data i need with bla_results[0].result['get_vlans_custom']. (see below)

def transform_task(task: Task, interface_results, vlan_results) -> Result:
    interface_data = interface_results[0].result['get_interfaces'] # get actual napalm output of host
    vlan_data = vlan_results[0].result['get_vlans_custom'] # get actual napalm output of host
    interface_to_vlan_data = napalm_reverse_vlan_to_interface_data(interface_data,vlan_data)
    return Result(host=task.host, result=interface_to_vlan_data)

Now when i send the transform_results to my last sub_task import_to_netbox i dont see a key of transform_results[0].result['transform_task'] (see data = transform_result... line below)

def import_to_netbox(task: Task, nb_obj, transform_results) -> Result:
    nb = nb_obj
    site = task.host.dict()['data']['site']['slug']
    device_id = task.host.dict()['data']['id']


    data = transform_results[0].result #### THIS GIVES ME THE DATA IM LOOKING FOR
    data = transform_results[0].result['transform_task'] #### THIS DOES NOT


    #netbox_tag_vlans_to_interfaces(nb,site,device_id,data)

    result=f'{task.host.name} - {site} - {device_id} vlans imported to netbox'

    return Result(host=task.host, result=result)

def main_task(task: Task, nb_obj) -> Result:
    nb = nb_obj

    interface_results = task.run(name='get_interfaces', task=napalm_get, getters=["get_interfaces"])
    print(interface_results)

    vlan_results = task.run(name='get_vlans', task=napalm_get, getters=["get_vlans_custom"])
    print(vlan_results)

    transform_results = task.run(task=transform_task, interface_results=interface_results, vlan_results=vlan_results)
    print(transform_results)

    import_results = task.run(task=import_to_netbox, nb_obj=nb, transform_results=transform_results)

    return Result(host=task.host, result=f'{task.host.name} finished {task.name}')

Why does vlan_results[0].result['get_vlans_custom'] work when transform_results[0].result['transform_task'] does not?

My guess is that i am not returning the data properly in my previous transform_task task.
Probably this is where task.host["interface_to_vlan_data"] = interface_to_vlan_data comes into play within transform_task?

Thoughts?

Thank you again for the kind assistance!!

[dbarrosop]

https://nornir.tech/nornir_napalm/html/api/tasks.html#nornir_napalm.plugins.tasks.napalm_get

Returns
result (dict): dictionary with the result of the getter

That key is being set by the napalm task, if you want it in your transform_task you will have to add it as well, i.e., return Result(host=task.host, result={"transform_task": interface_to_vlan_data})

The only reason why napalm_get does it is because you can request multiple getters in one call so each key would be the response for each getter. What that basically means is you can do this:

    napalm_data = task.run(task=napalm_get, getters=["get_interfaces", "get_vlans"])
    interfaces = napalm_data[0].result['get_interfaces"]
    vlans = napalm_data[0].result['get_vlans"]

If you don't need the key like in this cae there is no good reason to add it.

[davama]

@dbarrosop
thank you for the explanation.

I saw you post before you edited it, and did exactly as you said of placing all my getters in one task.

Regarding the result from transform_task, it makes sense. And looking at napalm_get, i see the dict results return
I went ahead and added the dict to my transform_task simply for the sake of consistency.

Thank you again @dbarrosop

Best,
Dave

PS:

For any future googlers here is my script:

def import_to_netbox(task: Task, nb_obj, transform_results) -> Result:
    nb = nb_obj
    site = task.host.dict()['data']['site']['slug']
    device_id = task.host.dict()['data']['id']
    data = transform_results[0].result['transform_task'] # get actual napalm output of host
    netbox_tag_vlans_to_interfaces(nb,site,device_id,data)
    result=f'{task.host.name} - {site} - {device_id} vlans imported to netbox'
    return Result(host=task.host, result=result)

def transform_task(task: Task, napalm_get_results) -> Result:
    result = {}
    interface_data = napalm_get_results[0].result['get_interfaces'] # get actual napalm output of host
    vlan_data = napalm_get_results[0].result['get_vlans_custom'] # get actual napalm output of host
    interface_to_vlan_data = napalm_reverse_vlan_to_interface_data(interface_data,vlan_data)
    result[task.name] = interface_to_vlan_data
    return Result(host=task.host, result=result)

def main_task(task: Task, nb_obj) -> Result:
    nb = nb_obj
    napalm_get_results = task.run(name='napalm_get_data', task=napalm_get, getters=["get_interfaces", "get_vlans_custom"])
    transform_results = task.run(task=transform_task, napalm_get_results=napalm_get_results)
    import_results = task.run(task=import_to_netbox, nb_obj=nb, transform_results=transform_results)
    return Result(host=task.host, result=f'{task.host.name} finished {task.name}')