1. “Hello world!” Service

In this paragraph we’re going to create a service “helloworld”, which when called returns a simple message containing a hello.

Create and run service locally

First step is to create a service called valuea.samples.helloworld which will return a simple dictionary when called.

services/valuea/samples/helloworld.py

import valuea_framework.broker.Service


class Service(valuea_framework.broker.Service.BaseService):
    def execute(self):
        return {'message': 'hello world!'}

Line 1 contains an import of the base class we’re extending from in line 4, this is a plain vanilla service, called “BaseService”.

We keep it simple, the only thing we do here is returning a message upon calling execute().

Note

Our class is called Service, this is a naming convention for services in the framework. Every file contains at most one service, which is named equally.

Next thing on our list is to try to run this service using only a python executable, which is what we’re going todo in the next block.

run_helloworld_local.py

#!/usr/bin/env python
# tell python we want to use "helloworld"
import services.valuea.samples.helloworld

# construct a new object from the helloworld service
srv = services.valuea.samples.helloworld.Service()

# execute the service and return the result to a variable named result
result = srv.execute()

# put our data on screen as text
print (result)

The emphasized lines contain the actual code, all starts with a directive to tell the shell we’er using a python interpreter on line 1 (not required) then we’re going to tell python we want to use the module “services.valuea.samples.helloworld”.

With the module included, we can construct a new helloworld service object, for which we can run the execute method.

Last thing on the list is to print our results on the screen, which returns something like:

{'message': 'hello world!'}

Expose service and test

This exercise consists of two parts, first we need to make sure there’s a listener running at our end to capture requests, next step is to publish a message (requesting our helloworld) to the queue and see if we can receive a result back.

msg_broker.py

#!/usr/bin/env python
import valuea_framework.broker.listener
valuea_framework.broker.listener.run()

Note

The message broker code above can be used to start one or more processes depending on your configuration (broker.conf), we will use the same code for every example.

Tip

When using PyCharm, you can easily start the listener in your debugger and trap received events.

Now we’re listening for requests, we should be able to deliver a message in another session using standard RabbitMQ libraries. For python we’re using pika to do this, but to ease the process we’ve build a simple wrapper to do the actual call.

run_helloworld_queue.py

#!/usr/bin/env python
from valuea_framework.connectors.rabbitmq.Simple import SimpleRpcClient

rpcclient = SimpleRpcClient(hostname='192.168.56.101',
                            exchange='default_exchange',
                            username='admin',
                            password='admin')


remote_procedure = 'valuea.samples.helloworld'

print(" [x] Requesting %s" % remote_procedure)
response = rpcclient.call(remote_procedure)
print(" [.] Got %r" % response)

The highlighted part in the above block constructs a new connection object, which connects to rabbitmq on the provided hostname/address using the same credentials created for testing.

Our next step is to define which procedure we want to call (valuea.samples.helloworld), telling the user we’re about to execute (using a simple print) and perform the actual call using rpcclient.call(), then when we receive a response, it will be printed to the console as well.

The output should look like this:

[x] Requesting valuea.samples.helloworld
[.] Got {u'message': u'hello world!'}

Note

The gui uses the same approach when calling services.