afnix-us-csm - standard collection session management service

       afnix-us-csm - standard collection session management service

Part
       The Part class is a taggable object which is bound by a unique key and provide a plist interface  access.
       The  part  object  is the foundation of the blob object and is also used to feed a collection. The key is
       represented by a uuid object.

       Predicate

              part-p

       Inheritance

              Taggable

       ConstructorsPart(none)
              The Part constructor creates an empty part

              Part(String)
              The Part constructor creates a part by name.

              Part(StringString)
              The Part constructor creates a part by name and info strings.

       Methodskid-p->Boolean(String)
              The kip-p predicate returns true if the part kid can be validated.

              property-p->Boolean(String)
              The property-p predicate returns true if the property name argument is defined in the part.

              get-kid->Uuid(none)
              The get-kid method returns the part kid.

              add->none(StringLiteral)
              The add method adds a property to the part.

              get-header->Plist(none)
              The get-header method returns the part header which is a plist with the part name, info and uuid.

              get-plist->Plist(none)
              The get-plist method returns the part plist.

              get-value->String(String)
              The get-value method returns the a part property value by name.

              to-lteral->Literal(String)
              The toliteral method returns the a part property literal by name.

       Blob
       The Blob class is a base class that models the behavior of  a  registered  blob  through  the  use  of  a
       registration  id. The blob is registered as soon as its registration id is set. If the registration id is
       unset, the object is unregistered or anonymous. The registration id can be anything as long as as  it  is
       understood  by the implementation that such registration is to be interpreted somewhere else. The blob is
       also a part which means that it has a name, info and unique key.

       Predicate

              blob-p

       Inheritance

              Part

       ConstructorsBlob(none)
              The Blob constructor creates an empty blob.

              Blob(String)
              The Blob constructor creates a blob by name.

              Blob(StringString)
              The Blob constructor creates a blob by name and info strings.

              Blob(StringStringString)
              The Blob constructor creates a blob by rid, name and info strings.

       Methodsrid-p->Boolean(none)
              The rid-p predicate returns true if the blob registration id is set.

              set-rid->none(String)
              The set-rid method sets the blob rid.

              get-rid->String(none)
              The get-rid method returns the blob rid.

       Bloc
       The Bloc class is a derived class which encapsulates the functionality of a blob coupled with a plist and
       a table of conditionals.

       Predicate

              bloc-p

       Inheritance

              Blob

       ConstructorsBloc(none)
              The Bloc constructor creates an empty bloc.

              Bloc(String)
              The Bloc constructor creates a bloc by name.

              Bloc(StringString)
              The Bloc constructor creates a bloc by name and info strings.

              Bloc(StringStringString)
              The Bloc constructor creates a bloc by rid, name and info strings.

       Methodsadd-credential->none(Credential)
              The add-credential method add a credential to the bloc.

              get-credential->Credential(String)
              The get-credential method returns a credential object by name.

       Carrier
       The Carrier class is a blob used to transport an object. The object transported by the  carrier  must  be
       serializable.

       Predicate

              carrier-p

       Inheritance

              Blob

       ConstructorsCarrier(none)
              The Carrier constructor creates an empty carrier.

              Carrier(Object)
              The Carrier constructor creates a carrier with an object.

              Carrier(ObjectString)
              The Carrier constructor creates a carrier with an object by name.

              Carrier(ObjectStringString)
              The Carrier constructor creates a carrier with an object by name and info strings.

              Carrier(CarrierStringStringString)
              The Carrier constructor creates a carrier with an object by rid, name and info strings.

       Methodsget-object->Object(none)
              The get-object method returns the carrier object.

       Delegate
       The  Delegate  class  is a carrier blob which delegates its transport to another object. Such approach is
       used when the carried object needs to remains locally (aka it cannot be serialized) but a reference to it
       can be sent to the remote peer.

       Predicate

              delegate-p

       Inheritance

              Carrier

       ConstructorsDelegate(none)
              The Delegate constructor creates an empty delegate.

              Delegate(Object)
              The Delegate constructor creates a delegate with an object.

              Delegate(ObjectString)
              The Delegate constructor creates a delegate with an object by name.

              Delegate(ObjectStringString)
              The Delegate constructor creates a delegate with an object by name and info strings.

              Delegate(DelegateStringStringString)
              The Delegate constructor creates a delegate with an object by rid, name and info strings.

              Delegate(DelegateStringStringStringString)
              The Delegate constructor creates a delegate  with  an  object  by  rid,  name,  info  strings  and
              delegation address.

       Methodsset-address->none(String)
              The set-address method sets the delegate address.

              get-address->String(none)
              The get-address method returns the delegate address.

       Realm
       The  Realm  class  is  an  abstract class design for the storage and management of authorities. The class
       provides the basic methods to create, check and validate an authority.

       Predicate

              realm-p

       Inheritance

              Nameable

       Methodsexists-p->Boolean(String)
              The exists-p predicate checks if an authority exists by kid.

              valid-p->Boolean(StringCredential)
              The valid-p predicate validates an authority by name and credential.

              get-info->String(none)
              The get-info-p method the real information string. Note that the get-name method is also available
              through the Nameable interface.

              create->none(StringCredential)
              The create method creates an authority by name and credential.

              update->none(Authority)
              The update method updates a workzone by authority.

       Session
       The Session class is a class that defines a session to be associated  with  a  transaction.  The  session
       object  is designed to be persistent so that its data information can be retreived at any time. A session
       object has also the particularity to have a limited lifetime. A session object is created by name with an
       identifier. The session object is designed to hold a variety of parameters that are suitable for both the
       authentication and the session lifetime. A  session  is  primarily  defined  by  name  with  an  optional
       information string. The session is generally associated an authentication visa which contains the session
       identity. The visa provides a secure mechanism compatible with a single sign on session. A session key is
       automatically generated when the session is created. Such key is used to generate a session hash id which
       can  be  used  as  a cookie value. The cookie name is also stored in the session object. When a cookie is
       generated, the session hash name is combined with the session hash id for the cookie production.

       Predicate

              session-p

       Inheritance

              Taggable

       ConstructorsSession(String)
              The Session constructor creates a session by name. The string argument is the session name.

              Session(StringString)
              The Session constructor creates a session with a name and  a  user.  The  first  argument  is  the
              session name. The second argument is the session information..

              Session(StringStringInteger)
              The  Session  constructor  creates  a  session  with  a  name, a user and a maximum age. The first
              argument is the session name. The second argument is the session informartion. The third  argument
              is the session maximum age expressed in seconds.

       Methodsexpire-p->Boolean(none)
              The expire-p predicate returns true if the session has expired.

              set-hash-id->none(String)
              The  set-hash-id  method  sets the session hash identifier. The session hash id must be unique and
              secured enough so that the session name cannot be derived from it.

              get-hash-id->String(none)
              The get-hash-id method returns the session hash identifier.

              set-path->none(String)
              The set-path method sets the session path.

              get-path->String(none)
              The get-path method returns the session path.

              get-max-age->Integer(none)
              The get-max-age method returns the session maximum age.

              set-max-age->none(Integer)
              The set-max-age method sets the session maximum age. The maximum age  is  an  integer  in  seconds
              relative to the current time. If the maximum age is set to 0, the session is closed.

              get-remaining-time->Integer(none)
              The get-remaining-time method returns the remaining valid session time.

              get-expire-time->Integer(none)
              The  get-expire-time method returns the session expiration time in seconds. The expiration time is
              an absolute time.

              set-expire-time->none(Integer)
              The set-expire-time method sets the session expiration time. The expiration time  is  an  absolute
              time in seconds.

              get-creation-time->Integer(none)
              The  get-creation-time  method returns the session creation time. The creation time is an absolute
              time in seconds.

              get-modification-time->Integer(none)
              The get-modification-time method returns the session creation time. The modification  time  is  an
              absolute time in seconds.

              get-cookie->Cookie(name)
              The  get-cookie  method bakes a session cookie. The string argument is the cookie name those value
              is the session hash id value.

              close->Cookie(name)
              The close method close a session by reseting the session maximum age to 0. The  method  returns  a
              cookie  that  can  be  used  for  closing the session on the peer side. The string argument is the
              cookie name those value is the session hash id value.

              set-visa->None(Visa)
              The set-visa method set the session visa.

              get-visa->Visa(None)
              The get-visa method returns the session visa.

AFNIX Service                                         AFNIX                                      afnix-us-csm(3)

       The  Standard  Content  Session  Management  service  is  an  original  implementation of various objects
       dedicated to the management of sessions, realms, identities and more generaly with data concentration  in
       the form of binary blobs.

       Generalconcepts
       The  afnix-csm  provides  the  support  for  manipulating content session in an ecclectic form. There are
       multiple types of objects which can broadly be categorized into general data management in  the  form  of
       data blobs, identity and credential management and finally session management.

       Blob
       The  concept  of  blob is central in the csm service. A blob is a registrable part. A part is an abstract
       taggable object uniquely identified by a uuid. The blob adds a registration identification, which enables
       them to be group into domains.