Main / Edit / History / / Users Area

Tutorial: Hello World (v 1.x)

Lets write our first CppCMS based application:

First we create a file called hello.cpp and store in it the following content.

Includes:

We should import some definitions for our 1st application:

cppcms/application.h - the class application that every CppCMS application is derived from.
cppcms/applications_pool.h - class applications_pool - the class that manages user applications - creates new per HTTP request and caches them for future use.
cppcms/service.h - the service - central event loop of the network service.
cppcms/http_response.h the class we write our response to the client with.

So let's include them all.

#include <cppcms/application.h>
#include <cppcms/applications_pool.h>
#include <cppcms/service.h>
#include <cppcms/http_response.h>
#include <iostream>

Now we define our first application class, that is derived from cppcms::application. It should receive in its constructor a reference to the central CppCMS service that runs our application.

class hello : public cppcms::application {
public:
    hello(cppcms::service &srv) :
        cppcms::application(srv)
    {
    }
    virtual void main(std::string url);
};

At this point, in order to respond to user requests we just override cppcms::application::main member function that is always called for each request.

In this function we will simply write HTML to the output stream. The output stream can be accessed using the response member function of the application class that gives us access to the output stream out().

void hello::main(std::string /*url*/)
{
    response().out() <<
        "<html>\n"
        "<body>\n"
        "  <h1>Hello World</h1>\n"
        "</body>\n"
        "</html>\n";
}

Now lets setup our main function. First we create the service class that parses command line parameters and searches for configuration options

int main(int argc,char ** argv)
{
    try {
        cppcms::service srv(argc,argv);

Then we tell the applications_pool class to use our application - hello - by providing it a predefined object factory cppcms::applications_factory<hello>(). We then so call mount our application to the pool so it will be used for request handling.

        srv.applications_pool().mount(
          cppcms::applications_factory<hello>()
        );

And now we run our event loop. The run() function exits when the process receives SIGINT, SIGTERM or SIGUSR1 signal.

        srv.run();
    }
    catch(std::exception const &e) {
        std::cerr << e.what() << std::endl;
    }
}

That's it, our application is ready, now we can compile it as simply as:

c++ hello.cpp -lcppcms -o hello

Now we need to prepare the configuration file config.js that uses JSON file format for passing all options:

{
    "service" : {
        "api" : "http",
        "port" : 8080
    },
    "http" : {
        "script_names" : [ "/hello" ]
    }
}

We setup our service to listen on port 8080 using HTTP protocol (it is very useful for debugging our applications).

We also provide the script_names parameter that defines the path to the virtual "CGI Scripts" or in simple words the path that our application should be called from.

Now we can start the application