Home  » Software  » P6Platform  » Features

Server Development Framework

Feature Summary
P6Platform™ is feature rich, enabling you to create servers fast, without having to create the infrastructure from scratch. Checkout this list of major features:

The foundation of P6Platform is a light-weight, platform independent, C++ based, COM framework. P6Platform's API's are provided as intuitive COM interfaces that allow developers to easily create re-usable software components and link those components together to create high performance server applications. This allows for a very high degree of code reuse and provides clean well defined components that are much easier to test.
The P6Platform provides a very robust configuration system with many powerful features. It's interfaces are simple and straight forward to use.

The API provides several powerful features:
  • Comments
  • Caller Configurable Substitution
  • Multi-line Values
  • Event Notifications (something changed, added, removed, etc.)
  • Platform independent config files
  • Value Lists
Our CRC components APIs are high performance implementations of both 16 bit and 32 bit CRCs with configurable polynomials.
Our SQL database componment provides access to SQLite and PostgreSQL via the same easy to use interface. The interface also provides the ability to output the result set directly as XML or JSON encoded data. It's also extensible, allowing you to add support for any SQL based database of your choosing. In addition it provides both synchronous and asynchronous database access.
All directory interfaces are wide-character (automatically converting to/from native file system encoding) and are 64-bits for large file support. Additional helper routines are also provided to normalize pathnames, create temp files and more.
We provide encoders and decoders for many common encodings such as ASN.1, Base64, UUEncode, etc.
An encrypted keystore is provided to secure sensative application information. It provides a simple, flexible API that makes it easy for your application to programmatically manage keys, certificates (supports certificate chains too), and arbitrary binary data (blobs). Data can be stored by name with full namespace support. A namespace is an user defined string which can be used to group entries in the keystore. This could be an application or component name and, for example, this allows all the keys in a application namespace to be retreived at once. The keystore can also be cryptographically signed to ensure integrity, and detect unauthorized modifications.
Crypto support is provided via OpenSSL. However, we have put a large effort to into providing a much cleaner API to this functionality. This makes OpenSSL easy to use and we have added documentation and examples on how to use this powerful component.
P6Platform provides file system I/O interfaces that provide wide-character file and pathname (automatically converting to/from native file system encoding). All file system APIs are 64-bits for large file support.
Included is a table driven, high performance finite state machine engine that is configurable though an easy XML description language. To ensure scalability, the finite state table has been abstracted from the state machine engine. This allows a single state table to be shared across as many instances of the state machine engine as needed.
All P6Platform APIs and interfaces are wide-character based so that internationalization is available from the very beginning of the project. Additionally we provide a robust set of standard APIs for manipulating wide character strings:
  • Wide-to-narrow and narrow-to-wide conversions
  • "Safe" string handling routines like wcslcpy() and wcslcat() etc.
  • All standard string API's, for example: wcsstr(), wcschr(), wcslwr() etc.
  • I18N file API's allow writing wide characters strings as UTF-8 and the resulting files are transportable between platforms (currently Windows, Linux, and Solaris).
  • String table support with automatic selection by locale
In-RAM counters and gauges provide developers with an extremely powerful way to instrument code. Applications can define any number of counters and gauges which can then be made available via SNMP (if desired) and monitored using any off-the-shelf monitoring package (for example, Cricket, Cacti, Nagios, HP OpenView, etc.). Instrumenting your code is vital for being able to determine server health and aids debugging issues and performance monitoring in the field. Many of P6Platform's own internal components and services create counters and gauges.
The P6Platform also provides a high-resolution interval time API. High resolution interval times are great for timing how long an operation takes to complete, time sections of code, and many other things.
Our JSON parser uses a streaming, SAX-like API. The parser also integrates with our XML DOM tree component, allowing all of our powerful XML components (like XPath 2.0 and XSLT 2.0) to use and manipulate JSON orignated data. Learn more in this article titled "XSLT and XPath for JSON".
The LDAP Client interfaces provide server applications with the ability to lookup, modify, and add directory entires. The API is object oriented thus simplifying the typical difficulties of other API's (e.g OpenLdap).
P6Platform's license interfaces allow developers to create their own application license which is composed of a signed file of name value pairs. The license component is provided for license file generation and verification. The interface is very flexible, enabling the application developer to implement virtually any type of licensing (eg. time-limited, enabling selected features, etc.).
The P6Platform includes very robust high-performance logging subsystem. Some of it's features are:
  • Unlimited user defined log levels
  • Log levels can be changed without recompiling your code.
  • Highly configurable log output formating allowing virtually any log format to be generated. Need to log XML? ... or maybe make your log output look just like apache's? You can using this feature!
  • Configurable automatic log rotation (multiple criteria, eg. hourly, daily, greater than a specified size, etc.)
  • Event filtering on a per consumer basis
  • Configurable synchronous or asynchronous operation
  • Extensibility: Custom log consumers can be easily added
  • Multiple simultaneous log consumers (destinations)
  • SNMP trap integration enables the sending of SNMP traps for specified log events.
  • I18N wide character support
P6Platform provides platform independent access to networking APIs. You can use our protocol components (SNMP, LDAP, etc.) or use P6Platform's low level APIs to implement your own protocols. The platform includes an asynchronous I/O event queue which enables you to write platform independent asynchronous I/O, reducing your applications CPU overhead and increasing scalability.
Both wide and narrow Perl compatible regular expression engine. We built our own regex engine that matches all of Perl's and Egrep's syntax and functionality. We did not stop there. We have made several improvements and have provided a hybrid-NFA DFA implementation. Our regular expressions provide an object API, which means you compile a regex once and can use it multiple times. We also have provided 2 levels of debug tracing so you can check to see if the regex you defined is working as you expected. We wrote this tracing for ourselves and liked it so much we knew that other developers would want it. To round things out, we've also added a Perl-like split() function as well.
Rules are defined in XML and use the XPath 2.0 embedded language for its expression language. Our XPath enabled rule engine implements forward chaining and represents all "facts" in a DOM XML tree (i.e., both stated and inferred facts). The rule engine is an interpreter of the rule XML language we have defined.
Using strings in safe manner is very important to providing secure products. The P6Platform includes a safe narrow string interface that provides both safety and performance.
Servers always need management consoles, and more often than not, these consoles use an insecure connection. To help improve security, P6Platform includes a console service which uses a secure SSHv2 connection for server management. The SSMC service is extensible allowing you to easily add your own management commands. This is not a general purpose SSH connection, and provides access to the management commands that are built-in to the platform and those you provide yourself.
A full SSH server protocol implementation (which the SSMC service is based on) is included as well. This implementation could easily be used as the based for a full blown SSH server. It supports subsystems, and multiple channels.
Full implementation of server side SNMP protocol. SNMP traps are fully integrated with logging service. Logging an event at the "Critical" level results in SNMP traps being sent (if desired). All In-RAM counters and gauges can be readable via SNMP just by editing a single file. All that is required is to define an SNMP OID for each named counter and your done.
Unit tests are a very important part of the development process and have been proven to help quality. We provide our unit test framework which has been designed to easily test components. All of the code in the P6Platform and it's APIs are unit tested continuously using this harness and have been since the very beginning. We strongly urge everyone to unit test their code early and often.
P6Platform is designed to facilitate the writing of high performance, highly multi-threaded applications. It provides platform independent APIs that allow you to create and manage threads and processes as well as synchronization APIs to manage resource contention.
Our time and date API's are a powerful abstraction for system wallclock time with conversion and normalization calls that make it easy to manipulate dates and times.
P6Platform timers services feature a theoretically unlimited number of asynchronous timers. You can define a timer by seconds to expire or define a wall clock time for expiration (eg. expire at 12:00am 01/01/2007). Common use: for protocol development, cron type applications.
SAX2 is a popular Java API for XML. With minor modifications to better support the C++ programming language and to have a small memory foot print, P6R's XML parser API is very close to the SAX2 standard. Full namespace support is provided in this non-validating parser. In addition to the SAX2 parser, we also have a full DOM XML parser. This parser has a traditional API that supports programs to walk up and down the generated tree. An XPath 2.0 interface is also provided which allows expressions to be written to select a subset of tree nodes returned via an enumerator. Regular expressions can also be used with XPath.
XPath 2.0 is an expression language that accesses elements in a DOM XML tree. It is a significant increase in functionality from its previous version. It is classified as an "embeddable" language in that it is embedded inside other scripting languages (e.g., XSLT). However, our version of XPath can used by itself as well as embedded into any application that uses an XML based scripting language (like our Rule Engine). We have also added several very useful extensions to XPath which can learn more about here.
XSLT is an extremely powerful language that is used to transform XML into other text based formats. Our XSLT processor implements version 2.0 of the XSLT standard, providing the most up to date features and also includes regex capabilities. Our XSLT engine also provides several extensions which can learn more about here.