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 classapplication
that every CppCMS application is derived from.cppcms/applications_pool.h
- classapplications_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
./hello -c config.js
Go to our browser and hit http://localhost:8080/hello link to see our first CppCMS application working.
← Notes for Microsoft Windows users | Top | Starting with Templates →