NeuroCache

README
------

 _   _                       ____           _          
| \ | | ___ _   _ _ __ ___  / ___|__ _  ___| |__   ___ 
|  \| |/ _ \ | | | '__/ _ \| |   / _` |/ __| '_ \ / _ \
| |\  |  __/ |_| | | | (_) | |__| (_| | (__| | | |  __/
|_| \_|\___|\__,_|_|  \___/ \____\__,_|\___|_| |_|\___|
                                                       

This package contains the source code of NeuroCache program and all the libraries and
utilities. NeuroCache implements a neuro-based architecture for session caching system
distributed over the network and the protocol functionalities, and provides the cAPIs for
other program applications, such as the cLHy server <http://clhy.hyang.org>.

The NeuroCache application machines set of accompanying libraries and utilities to share
session state, and consists the following set of tools:

   * nsc_server    : Provide an infrastructure interface to run a cache server listening on
                     a network address.
   * nsc_client    : Provide an infrastructure interface to run a local client proxy and
                     manage multiplexing of requests to/from a cache server over a single
                     persistent connection.
   * nsc_test      : Provide an infrastructure interface to send a (configurable) barrage
                     of session caching requests to a given network address using the
                     neurocache protocol.
   * nsc_inteli    : A transparent proxy tool supporting the neurocache protocol that can
                     be used to monitor cache operation requests and responses between any
                     two end-points (e.g. between application and nsc_client, or between
                     nsc_client and nsc_server).
   * sslcryptonsc  : SSL/TLS implementation with NeuroCache based on OpenSSL, that allows
                     the servers to resume SSL/TLS sessions negotiated by any other server
                     on the network while increasing the load-balancing. There is no need
                     to route the incoming connections to the "same server" (that is common
                     to the load-balancers todays), and indeed doing so can defeat the
                     load-balancing performance.

The NeuroCache package contains the following libraries :

   * libneural     : The underlying Neural Abstraction Library (hence has recursive name as
                     "NEURAL") used by the NeuroCache libraries and utilities. The libneural
                     uses non-blocking sockets, with an addressing abstraction that allows
                     tools to transparently work over unix domain sockets or TCP/IPv4 sockets
                     by a change of address text. The libneural defines various object types
                     including:
                     - NEURAL_ADDRESS : The addressing abstraction converts to/from text
                       representations, indicates whether given addresses are valid for
                       listening on, connecting to, or both.
                     - NEURAL_CONNECTION : Encapsulates a network connection that can be used
                       for sending/receiving arbitrary binary data.
                     - NEURAL_LISTENER : Encapsulates a listening socket that can be used to
                       accept incoming connection requests on a configured address, creating
                       a NEURAL_CONNECTION wrapper for each accepted connection.
                     - NEURAL_SELECTOR : Provides an object that can be prepared with various
                       NEURAL_LISTENER and NEURAL_CONNECTION objects, and can then manage the
                       non-blocking I/O "event loop".
                     - NEURAL_BUFFER : Implements a FIFO data array and is used primarily for
                       representing the read and send parts of a NEURAL_CONNECTION object.
                     - NEURAL_decode_uint32 : Some helper functions to assist in serialising
                       data, particularly with respect to putting integral data into network
                       byte order (allowing interoperability between platforms with differing
                       byte-order).
   * libneurocache : This library provides APIs with the following headers:
                     - neurocache/nsc_plug.h : This header provides the NSC_PLUG abstraction
                       to encapsulate a connection and to implement the neurocache protocol
                       and various functions for manipulating the reading and writing of
                       neurocache requests or responses.
                     - neurocache/nsc_client.h : This header declares a higher-level (and much
                       simpler) API than nsc_plug.h, and useful in a program applications
                       that want API functions that do cache operations. This is the API used
                       to add neurocache support to other HTTP/web server, such as cLHy (known
                       as capi_socache_neuro).

   * libneurocacheserver
                   : The headers in this library declare the APIs for implementing a session
                     cache supporting the neurocache protocol.


BUG REPORT

Create a new ticket at NeuroCache repository that uses HySCM ticket system at:

      http://clhy.hyang.org/cgi-bin/neurocache-dev/neurocache/tktnew

or send an email containing your bug report to contributing@hyang.org / hyangcontrib@gmail.com