---
name: "Message::Passing::DSL"
section: "3pm"
platform: "linux"
package: "libmessage-passing-perl"
version: "0.117-1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Message::Passing::DSL"
---

# Message::Passing::DSL(3pm)

An easy way to make chains of Message::Passing components.

## NAME

Message::Passing::DSL - An easy way to make chains of Message::Passing components.

## SYNOPSIS

```
    package mylogcollectorscript;
    use Moo;
    use MooX::Options;
    use Message::Passing::DSL;
    use MooX::Types::MooseLike::Base qw/ Str /;
    use namespace::clean -except => [qw( meta _options_data _options_config )];
    with 'Message::Passing::Role::Script';
    option socket_bind => (
        is => 'ro',
        isa => Str,
        default => sub { 'tcp://*:5558' },
    );
    sub build_chain {
        my $self = shift;
        message_chain {
            output console => (
                class => 'STDOUT',
            );
            input zmq => (
                class => 'ZeroMQ',
                output_to => 'console',
                socket_bind => $self->socket_bind,
            );
        };
    }
    __PACKAGE__->start unless caller;
    1;
```

## DESCRIPTION

This module provides a simple to use helper system for writing scripts which implement a Message::Passing server, like the built in message-pass script.

Rather than having to pass instances of an output to each input in the `"output_to"` attribute, and full class names, you can use short names for component classes, and strings for the `"output_to"` attribute, the DSL resolves these and deals with instance construction for you.

See example in the SYNOPSIS, and details for the exported sugar functions below.

### FUNCTIONS

*message\_chain*

Constructs a message chain (i.e. a series of Message::Passing objects feeding into each other), warns about any unused parts of the chain, and returns an array ref to the heads of the chain (i.e. the input class(es)).

Maintains a registry / factory for the log classes, which is used to allow the resolving of symbolic names in the output\_to key to function.

*output*

Constructs a named output within a chain.

```
    message_chain {
        output foo => ( class => 'STDOUT' );
        ....
    };
```

Class names will be assumed to prefixed with 'Message::Passing::Output::', unless you prefix the class with + e.g. `"+My::Own::Output::Class"`

*encoder*

Constructs a named encoder within a chain.

```
    message_chain {
        encoder fooenc => ( output_to => 'out', class => 'JSON' );
        ....
    };
```

Class names will be assumed to prefixed with 'Message::Passing::Filter::Encoder::', unless you prefix the class with + e.g. `"+My::Own::Encoder::Class"`

*filter*

Constructs a named filter (which can act as both an output and an input) within a chain.

```
    message_chain {
        ...
        filter bar => ( output_to => 'fooenc', class => 'Null' );
        ...
    };
```

Class names will be assumed to prefixed with 'Message::Passing::Filter::', unless you prefix the class with + e.g. `"+My::Own::Filter::Class"`

*decoder*

Constructs a named decoder within a chain.

```
    message_chain {
        decoder zmq_decode => ( output_to => 'filter', class => 'JSON' );
        ....
    };
```

Class names will be assumed to prefixed with 'Message::Passing::Filter::Decoder::', unless you prefix the class with + e.g. `"+My::Own::Encoder::Class"`

*input*

The last thing in a chain - produces data which gets consumed.

```
    message_chain {
        ...
        input zmq => ( output_to => 'zmq_decode', class => 'ZeroMQ', bind => '...' );
        ....
    }
```

Class names will be assumed to prefixed with 'Message::Passing::Output::', unless you prefix the class with + e.g. `"+My::Own::Output::Class"`

*error\_log*

Setup the error logging output. Takes the same arguments as an `"input xxx => ()"` block, except without a name.

*run\_message\_server*

This enters the event loop and causes log events to be consumed and processed.

Can be passed a message\_chain to run, although this is entirely optional (as all chains which are still in scope will run when the event loop is entered).

## SPONSORSHIP

This module exists due to the wonderful people at Suretec Systems Ltd. \<http://www.suretecsystems.com/\> who sponsored its development for its VoIP division called SureVoIP \<http://www.surevoip.co.uk/\> for use with the SureVoIP API - \<http://www.surevoip.co.uk/support/wiki/api\_documentation\>

## AUTHOR, COPYRIGHT AND LICENSE

See Message::Passing.