| Option | Description |
| -LogServiceMaxSize | Sets the maximum size, in bytes, of the log record storage area.The default value is 1024.This option corresponds to the qosMaxSize configuration property in the EORB::LwLogService::Config struct. |
| -LogServiceEntryLocking | Turns locking on or off in the service implementation.The default value is on.This option corresponds to the qosWithLocking configuration property in the EORB::LwLogService::Config struct. |
| -LogServiceUIOP | Runs the service on a UIOP endpoint. Only available on systems where UIOP is a supported transport.The default is no. |
# 3.2.1 Running on a Fixed Endpoint
The server can be run on a fixed endpoint by running with the -ORBPOAEndpoints argument. The Log Service servant is created within a child POA LogService so for example can be run on a fixed IIOP endpoint with:
-ORBPOAEndpoints LogService:iiop:<host>:<port>
and resolved as an initial reference by a client using:
-ORBInitRef LogService=corbaloc:iiop:<host>:<port>/LogService
# 3.2.2 lwlogcpp Source Code
The source code for creating a log service executable can be found in the provided code examples (examples/cpp/services/lwlog/server).
# CHAPTER
# Creating Applications
The main tasks which may normally be performed when using the Spectra ORB Lightweight Log Service include:
• creation of a log service server for storing records of data or events sent by clients
• creation of clients which supply the data or events
• creation of clients which use the log’s records
This section, Creating Applications, describes how the specific features and requirements for the Spectra ORB Lightweight Log Service can be used to achieve the tasks listed above. The section is organised into a sequence of topics which describes how to
• create a log service server
• create a combined client which demonstrates how to write and read data to and from the log server1
The topics use examples to illustrate how relevant tasks can be achieved.
# 4.1 Server
The following code demonstrates how to create a Lightweight Log Service server.
# 4.1.1 The IDL File
An IDL file, lwlog.idl in this example, defines the log service example’s interface. The interface contains a single operation, shutdown(), which is used to shutdown or stop the server.
```txt
interface lwlog_example
{
oneway void shutdown();
};
```
The IDL compiler generates the server files, lwlog\_s.h and lwlog\_s.cpp. The lwlog\_s.h file will be imported into the developer-written server implementation files, lwlog\_i.h and lwlog\_i.cpp, shown below.
# 4.1.2 Developer-written Implementation Files
# 4.1.2.1 The Header File
```cpp
#ifndef _lwlog_i_h_
#define _lwlog_i_h_
#include "lwlog_s.h"
class lwlog_impl : virtual public POA_lwlog {
public:
lwlog_impl (CORBA::ORB_ptr orb);
virtual void shutdown (EORB_ENV_ARG1);
private:
CORBA::ORB_ptr porb;
};
#endif
```
The Header file declares the lwlog class. In addition to a default constructor declared here, this class contains the public shutdown() operation (previously declared in the lwlog.idl file). The private variable, porb, is declared which will be used to hold a pointer to the ORB object.
The declaration for the shutdown() operation uses a Spectra ORB portable exception macro. The Spectra ORB portable exception macros are an alternative method for passing exception information on platforms that do not support C++ exceptions (see the Platforms Without C++ Exception Support section of the User Guide for details).
# 4.1.2.2 The Implementation File
The server implementation file, server.cpp, configures, instantiates, runs and shuts down the log server.
# The Includes
The implementation file includes the following header files:
• LwLogService.h - for the Lightweight Log Service
• lwlog\_i.h - the developer-written implementation header file declaring the log example’s implementation class, lwlog\_impl.
```c
#include "eOrb/EORB/LwLogService.h"
#include "lwlog_i.h"
```
A ‘usage’ message to list valid command-line arguments is provided:
```txt
static void usage ()
```
```txt
{
printf ("Valid optional arguments :\n");
printf (" -LogServiceEntryLocking <on | off> (default on)\n");
printf (" -LogServiceMaxSize <num> (default 1024)\n");
#if EORB_USE_UIOP
printf (" -LogServiceUIOP (default no)\n");
#endif
}
```
# Main
The main operation is defined using the Spectra ORB EORB\_MAIN macro, which is for code portability for systems without a main entry point.
The following essential variables are declared and given default values; a check for command-line arguments which over-ride these defaults is also performed.
• config - a PrismTech-specific structure holding values which determine certain aspects of the log’s behaviour
• ref - an object reference to the Log interface
• poa - a pointer to the ORB’s Portable Object Adapter instance
• oid - a pointer to the object id of the log servant associated with the POA instance, poa
# Log Initialisation
The log’s configuration structure, config, is initialised, followed by initialisation of the ORB, POA, log example implementation, and log service instance. The IOR for the log service is then published by registering it with the ORB as an initial reference. The Spectra ORB-specific Stdio and File plugins then ensure that this reference is both published to stdout and written to a file corresponding to the name of the registered reference. Note that the normal try-catch block has been replaced with the EORB\_TRY and EORB\_CATCH macros.
```cpp
orb = CORBA::ORB_init (argc, argv EORB_ENV_VARN);
EORB_CHECK_ENV;
CORBA::Object_var obj;
PortableServer::POA_var poa;
PortableServer::POA_var child;
CORBA::PolicyList poaPolicies (0);
obj = orb->resolve_initial_references ("RootPOA"
EORB_ENV_VARN);
poa = PortableServer::POA::_narrow (obj EORB_ENV_VARN);
child = poa->create_POA
(
"LogService",
PortableServer::POAManager::_nil (),
poaPolicies
```
```cpp
EORB_ENV_VARN
);
ref = EORB::LwLogService::init (orb, child, config EORB_ENV_VARN);
EORB_CHECK_ENV;
orb->register_initial_reference ("LogService", ref EORB_ENV_VARN);
EORB_CHECK_ENV;
servant = new LwLog_Example_impl (orb.in());
EORB_CHECK_ENV;
oid = poa->activate_object (servant EORB_ENV_VARN);
EORB_CHECK_ENV;
LwLog_Example_var server = servant->_this (EORB_ENV_VAR1);
EORB_CHECK_ENV;
orb->register_initial_reference (
"server",
server
EORB_ENV_VARN
);
EORB_CHECK_ENV;
```
The orb->run() operation is then executed, starting the event loop which waits for incoming requests from clients.
When the log service is stopped the ORB’s shutdown operation is called via the lwlog\_example\_impl’s shutdown() operation (defined in lwog\_i.cpp).
```c
orb->run (EORB_ENV_VAR1);
// Clean up
orb->destroy (EORB_ENV_VAR1);
EORB_CHECK_ENV;
}
EORB_CATCH (CORBA::Exception, exc)
{
printf ("Exception: %s\n", exc._rep_id());
return 1;
}
EORB_END_TRY
delete servant;
printf ("lwlog server complete\n");
return 0;
}
```
# 4.2 Client
The client code shown here demonstrates how to create a Lightweight Log Service client.
# Implementation
The client implementation file, client.cpp, imports the CosLwLogService.h header file. Instead of including the developer-written lwlog\_i.h header file, the client includes the IDL-generated lwlog.h file which contains the interface declarations needed by the client to connect, via the ORB and POA, to the log server implementation.
```c
#include "lwlog.h"
#include "CosLwLogService.h"
```
The starttime variable, type LogTime, is declared: starttime records the time, in seconds and nanoseconds, when a log record is created. This variable will be used by the example for retrieving records based on their creation time stamps.
```txt
static CosLwLog::LogTime starttime;
```
The printRecords() operation demonstrates how to obtain information about a sequence of log records by using CosLwLog::LogRecordSequence.
The LogRecordSequence subscript operator is used to obtain direct access to the buffer underlying the records sequence: this enables simple retrieval of each record’s id, log creation time and ProducerLogRecord (the info value) for each record held in the records sequence.
```cpp
static void printRecords (CosLwLog::LogRecordSequence * records)
{
printf (" Recovered %d records\n\n", records->length());
for (CORBA::ULong i = 0; i < records->length(); i++)
{
CosLwLog::RecordId id = records->get_buffer ()[i].id;
CosLwLog::LogTime time = records->get_buffer ()[i].time;
CosLwLog::ProducerLogRecord info = records->get_buffer ()[i].info;
printf (" RecordId : %d\n", (int) id);
printf (" Time : %d secs %d nsecs\n", time.seconds, time.nanoseconds);
printf (" Producer Id : %s\n", info.producerId.in());
printf (" Producer Name : %s\n", info.producerName.in());
printf (" Log Level : %d\n", info.level);
printf (" Log Data : %s\n\n", info.logData.in());
}
}
```
The client uses get\_current\_time to set starttime and thus synchronize itself w it h t h e s e r v e r. T h i s v a l u e i s u s e d b y t h e r e t r i e v e R e c o r d s a n d retrieveRecordsByProducerId operations to ensure that records with correct timestamps are retrieved.
```c
static void current_time (LwLog_Example_ptr server EORB_ENV_ARGN)
{
starttime = server->get_current_time (EORB_ENV_VAR1);
EORB_CHECK_ENV_RETURN_VOID;
}
```
The get\_status() operation demonstrates how to use the LogStatus interface to obtain a log’s current status.
T h e o p e r a t i o n s u ce s s i v e l y c a l l s t h e i n t e r f a ce ’s g e t \_ m a x \_ s i z e ( ) , get\_current\_size() and get\_n\_records() operations.1
```c
/*
* get_status : all three of the CosLwlog object references are of
* the type CosLwLog::LogStatus so can be used to call this operation
* which prints the current statis of the log.
*/
static void get_status (CosLwLog::LogStatus * status EORB_ENV_ARGN)
{
CORBA::ULongLong size;
size = status->get_max_size (EORB_ENV_VAR1);
EORB_CHECK_ENV_RETURN_VOID;
printf (" Max Size : %d\n", (int) size);
size = status->get_current_size (EORB_ENV_VAR1);
EORB_CHECK_ENV_RETURN_VOID;
printf (" Current Size : %d\n", (int) size);
size = status->get_n_records (EORB_ENV_VAR1);
EORB_CHECK_ENV_RETURN_VOID;
printf (" Number of Records : %d\n\n", (int) size);
}
```
The writeRecords() operation demonstrates how the LogProducer interface can be used to add a sequence of log producer records to a log.
1. See interface LogStatus on page 16 for a complete list of available LogStatus operations.
After creating a sequence of producer log records, the operation creates a sequence of ProducerLogRecords. Each ProducerLogRecord, rec, is added to the sequence of ProducerLogRecords after being assigned producerId, producerName, log level, and logData values.
The completed ProducerLogRecords sequence is then written to the log using the ProducerLogRecords::write\_records() operation. The status of the log is subsequently obtained and printed.
```c
/*
* writeRecords illustrates CosLwLog::LogProducer functionality
*/
static void writeRecords (CosLwLog::LogProducer * producer EORB_ENV_ARGN)
{
CORBA::ULong size = 4;
CosLwLog::ProducerLogRecordSequence records;
records.length (size);
printf ("\\nWriting %d records\n\n", size);
/* Create the records */
for (CORBA::ULong i = 0; i < size; i++)
{
CosLwLog::ProducerLogRecord rec;
char id[8];
char data[16];
sprintf (id, "ID %d", i);
sprintf (data, "Data Entry %d", i);
rec.producerId = CORBA::string_dup (id);
rec.producerName = CORBA::string_dup ("LwLog Example");
rec.level = (CORBA::UShort) i;
rec.logData = CORBA::string_dup (data);
records.get_buffer ()[i] = rec;
}
/* Write the records to the log */
producer->write_records (records EORB_ENV_VARN);
EORB_CHECK_ENV_RETURN_VOID;
/* Print the status of the log */
printf (" Current status\n");
get_status (producer EORB_ENV_VARN);
EORB_CHECK_ENV_RETURN_VOID;
}
```
The retrieveRecords() operation demonstrates how the LogConsumer interface can retrieve a sequence of log producer records from a log.
The variables used by the operation, as part of the retrieval process, are:
• LogRecordSequence records - structure which will hold the retrieved records
• RecordId id - variable holding the id value which will be used to identify the records to be retrieved
• howMany - an unsigned long specifiying the number of records which are to be retrieved (4 in this example) by the operation
```c
/*
* retrieveRecords illustrates CosLwLog::LogConsumer
retrieve_records functionality
*/
static void retrieveRecords (CosLwLog::LogConsumer * consumer EORB_ENV_ARGN)
{
CosLwLog::LogRecordSequence * records;
CosLwLog::RecordId id;
CORBA::ULong howMany = 4;
printf("\nRetrieving records\n\n");
/* Using the starttime saved during witeRecords operation
* obtain the RecordId of the record that has a matching or
* later timestamp */
id = consumer->get_record_id_from_time (starttime EORB_ENV_VARN);
EORB_CHECK_ENV_RETURN_VOID;
/* Starting with the returned id retrieve the required number
* of records from the log.
*/
records = consumer->retrieve_records (id, howMany EORB_ENV_VARN);
EORB_CHECK_ENV_RETURN_VOID;
/* Display the results */
printRecords (records);
delete records;
}
```
The retrieveRecordsByProducerID() operation shows how the LogConsumer interface can selectively retrieve a log record using its producer id and the time the record was created.
```cpp
/*
* retrieveRecordsByProducerId illustrates CosLwLog::LogConsumer
* retrieve_records_by_producer_id functionality where only records
* with a matching producer id to that in vals will be returned.
* The other consumer retrieve operations are similar to this one.
*/
static void retrieveRecordsByProducerId
(
CosLwLog::LogConsumer * consumer
EORB_ENV_ARGN
)
{
CosLwLog::LogRecordSequence * records;
```
```c
CosLwLog::RecordId id;
CORBA::ULong howMany = 4;
CosLwLog::StringSeq vals;
printf("\nRetrieving records by producer id\n\n");
vals.length (1);
vals[0] = CORBA::string_dup("ID 1");
/* Using the starttime saved during witeRecords operation
* obtain the RecordId of the record that has a matching or
* later timestamp */
id = consumer->get_record_id_from_time (starttime EORB_ENV_VARN);
EORB_CHECK_ENV_RETURN_VOID;
/* Starting with the returned id retrieve the required number
* of records from the log that also have a matching producer id.
* In this case 4 records are requested but only one will be returned.
*/
records = consumer->retrieve_records_by_producer_id
(
id,
howMany,
vals
EORB_ENV_VARN
);
EORB_CHECK_ENV_RETURN_VOID;
/* Display the results */
printRecords (records);
delete records;
}
```
The client’s main function is implemented using the Spectra ORB EORB\_MAIN macro. The main function performs initialisations and declarations (including the ORB and Log objects). Main then runs the operations, described above, which demonstrate the various Log operations.
```cpp
EORB_MAIN (client)
{
EORB_DECLARE_ENV;
printf ("LwLog client starting\n\n");
EORB::Plugin::IIOP::add();
EORB_TRY
{
CORBA::ORB_var orb;
CORBA::Object_var obj;
LwLog_Example_var server;
CosLwLog::Log_var log;
/* initialise the Orb */
```
```c
orb = CORBA::ORB_init (argc, argv EORB_ENV_VARN);
EORB_CHECK_ENV;
obj = orb->resolve_initial_references ("server" EORB_ENV_VARN);
EORB_CHECK_ENV;
server = LwLog_Example::_narrow (obj EORB_ENV_VARN);
EORB_CHECK_ENV;
/* Initialise the administartor object reference */
obj = orb->resolve_initial_references ("LogService" EORB_ENV_VARN);
EORB_CHECK_ENV;
log = CosLwLog::Log::_narrow (obj EORB_ENV_VARN);
EORB_CHECK_ENV;
/* Get the empty status of the log using the administrator */
printf (" Default status\n");
get_status (log EORB_ENV_VARN);
EORB_CHECK_ENV;
/* Obtain the server's current time */
current_time (server EORB_ENV_VARN);
EORB_CHECK_ENV;
/* Write and read records */
writeRecords (log EORB_ENV_VARN);
EORB_CHECK_ENV;
retrieveRecords (log EORB_ENV_VARN);
EORB_CHECK_ENV;
retrieveRecordsByProducerId (log EORB_ENV_VARN);
EORB_CHECK_ENV;
/* Clear the log of all the records */
log->clear_log (EORB_ENV_VAR1);
EORB_CHECK_ENV;
/* Get the now empty status of the log using the administrator */
printf (" Final status\n");
get_status (log EORB_ENV_VARN);
EORB_CHECK_ENV;
/* Destroy the log */
log->destroy (EORB_ENV_VAR1);
EORB_CHECK_ENV;
server->shutdown (EORB_ENV_VAR1);
// Clean up
```
```c
orb->destroy (EORB_ENV_VAR1);
EORB_CHECK_ENV;
}
EORB_CATCH (CORBA::Exception, exc)
{
printf ("Exception: %s\n", exc._rep_id());
}
EORB_END_TRY
printf ("LwLog client complete\n");
return 0;
}
```
# INDEX
# I n d e x
# A
AdministrativeState . . . . . 13
# C
clear\_log . . . . . . . . 22
# D
destroy . . . . 22
# G
get\_administrative\_state . . . . . 16
get\_availability\_status . . . . 16
get\_current\_size . . . 16
get\_log\_full\_action. . . . 16
get\_max\_size . . . 16
get\_n\_records . . 17
get\_operational\_state . . . . 17
get\_record\_id\_from\_time. . . . 18
# I
InvalidParam. . . . 24
# L
LogAdministrator . . . . 22
LogConsumer . . . . . 18
LogFullAction . . . . . 13
LogLevel. . . . . 12
LogLevelSequence . . . . . 12
LogProducer . . . . . 17
LogRecordSequence. . . . . . 12
LogStatus . . . . . 16
LogTime . . . . . 15
# M
module CosLwLog . . . . . . . . 17
# O
OperationalState . . . . 13
# P
ProducerLogRecord . . . . . . 15
ProducerLogRecordSequence . . . . . . . . . . . 12
# R
RecordId . . . 12
retrieve\_records . . . 19
retrieve\_records\_by\_level . . 19
retrieve\_records\_by\_producer\_id . . . . . . . . . . . 20
retrieve\_records\_by\_producer\_name . . . . . . . . 21
Running from the Command Line . . . . . . . 27
# S
set\_administrative\_state . . . . . . 23
set\_log\_full\_action . . . 23
set\_max\_size . . . 23
StringSeq . . . . 13
# W
write\_record . 17
write\_records. . 18
[🔗 Link to the original document](.spectra-orb-c-edition-lightweight-log-service-user-guide-2/spectra-orb-c-edition-lightweight-log-service-user-guide.pdf)