Grains (Grains v1.6.0)

Grains describes data flow as a graph with interchangeable parts.

To accomplish that grains divides the graph (Recipe) from the implementation of the nodes (Grains). Together these parts can be used to make a Bread which describes how the graph translates to processes. Each process has a symbolic short name, which is resolved to the registered name of the process via a map (%Bread{}.process_map).

Link to this section Summary

Functions

Combine two sets of recipes and grains.

Debug multiple asynchronous pull paths.

Debug an asynchronous data chain.

Debug multiple asynchronous data paths.

Retrieve a grain's substate.

Merges two grain maps into one.

Convenient version of routes/2. Takes a list of tuples of the form [{pattern, grains}].

Define a pattern which messages must match in order to be pushed to the successor grains. Every message gets tested against the pattern before it is pushed to the successors.

Link to this section Functions

Link to this function

combine(arg1, arg2)

Combine two sets of recipes and grains.

Link to this function

concat_name(bread, grain)

Specs

concat_name(Grains.Bread.t(), atom()) :: atom()
Link to this function

debug_pull_chain(first_grain, last_grain, message)

Debug multiple asynchronous pull paths.

This function floods pulls upwards from first_grain towards last_grain.

The function returns {:ok, number_of_paths} to indicate how often message should be received by the caller of this function.

Link to this function

debug_reply_chain(reply_chain, message)

Debug an asynchronous data chain.

The function expects a list of grains. The grain currently handling the message checks if its name matches the first element of the list. If so, it pops that element and attempts to send the message to the next grain in the list. If only one element in the list remains, and that element matches the name of the current grain handling the list, this grain replies to the sender with message.

Link to this function

debug_reply_chain(first_grain, last_grain, message)

Debug multiple asynchronous data paths.

This function floods message along all paths between first_grain and last_grain. It is a generalization of debug_reply_chain/2, which does not require specifying the paths explicitly.

The function returns {:ok, number_of_paths} to indicate how often message should be received by the caller of this function.

Link to this function

get_name(supervisor, short_name)

Specs

get_name(Grains.Supervisor.t(), atom()) :: atom()
Link to this function

get_original_recipe!(supervisor)

See Grains.Supervisor.get_original_recipe!/1.

Link to this function

get_substate(bread_id)

Specs

get_substate(atom()) :: term()

Retrieve a grain's substate.

This is similar to :sys.get_state/1. Note that this function should usually not be used, but it can be useful for debugging or testing.

Errors

The function exits the caller on error. For example, if no bread with the supplied id can be found, this results in a no_proc exit.

Link to this function

ghost(grain, description \\ nil)

A ghost edge.

A ghost edge is an edge from one grain through another which is not usable by Grains itself, but which may indicate communication between the two nodes using standard tools such as GenServer.call/2.

Link to this function

make_bread_name(recipe, bread_id)

Specs

make_bread_name(Grains.Recipe.t(), atom()) :: atom()
Link to this function

make_name(recipe, bread_id, short_name)

Specs

make_name(Grains.Recipe.t(), atom(), atom()) :: atom()
Link to this function

merge(grains1, grains2)

Merges two grain maps into one.

The function works the same as Map.merge/2: all grains in the second argument are added to the first, overriding any existing one.

Link to this function

merge_recipes(name, a, b)

See Grains.Recipe.merge/3.

Link to this function

new_recipe(name, new)

See Grains.Recipe.new/2.

Link to this function

periodic(grain, period, args \\ %{with_timestamps: false})

Description of a periodic grain.

Link to this macro

route(routes)

(macro)

Convenient version of routes/2. Takes a list of tuples of the form [{pattern, grains}].

Link to this macro

route(pattern, grains)

(macro)

Define a pattern which messages must match in order to be pushed to the successor grains. Every message gets tested against the pattern before it is pushed to the successors.

Link to this function

start_supervised(recipe, grains, args \\ [])

See Grains.Supervisor.start_link/3.