Sierra
An OpenPrivacy Reputation Management Framework

RCE (Reputation Calculation Engine)

The RCE package contains all top-level components necessary for Reputation calculation.

Components:

    RCE:

    A Reputation Calculation Engine (RCE) is basically a mechanism to abstract
    the calcluation of a Reputation. Reputations (opinions) can be added to an
    RCE and then the RCE can provide some mechanism to respond with for
    getReputation.

    An RCE just provides the calculation across an aggregated set of
    Reputations.  For performance, and portability reasons an RCE should use a
    StoreEngine component to handle its own data persistence. The RCE should use a
    StoreManager so that Sierra can be deployed with the correct RCE -> Store
    mapping.

    Every public method within an RCE declares that it throws a SierraException.
    This is neeeded because it is not known in what environments an RCE could be
    running in.  An RCE could be networked, rely on a database or other resource
    that may have problems in the future and this could lead to unknown state
    situations where an Exception could arise.

    An RCE is able to serve data from large, legacy databases - without
    requiring the administrators of these databases to change the way in which
    they operate.

    A Reputation Calculation Engine (RCE) can act as a translator to a
    proprietary protocol (e.g., SQL) communicating with the legacy database to
    extract reputation metrics that it can use for internal data-mining as well
    as collaborations (perhaps after anonymizing to protect its valuable
    resource and self interest) with external entities.

        Determines the Nym under which this RCE is running.  Since every
        Reputation object is signed (see the Reputation component), if this RCE
        is going to create answers to getReputation() request it has to sign its
        newly created Reputations.  

        +getNym () : Nym
        -------------------------------------------------------------------------
        Similar to the getReptuation( Reference ) method except that advanced
        query info can specified. A ReferenceRCEQuery should always be
        supported.  RCE implementations can support additional RCEQuery
        component implementations which developers can use to provide advanced
        custom queries.

        +getReputation (RCEQuery) : Reputation
        -------------------------------------------------------------------------
        Overloaded method to support a query based on a Reference.  This
        component is actually lighter than a ReferenceRCEQuery so it is more
        convenient for developers to use this.

        +getReputation (Reference) : Reputation
        -------------------------------------------------------------------------
        Add a Reputation to this RCE. If the RCE does not directly support this
        Reputation an RCE must throw an Exception. A good example of this is
        when a Reputation is added to an RCE but it doesn't have a stable/fast
        mechanism to index its Payloads. Additional Talon components may used to
        index/manage Reputations that the RCE can't  handle by itself.

        +putReputation (Reputation) : void 

    RCEManager:

    An RCEManager is the central location where you should obtain an RCE.  The
    main advantage is when you want to provide additional logic to obtain an RCE
    and then keep this in a reusable form.  The default logic is to use an
    RCEContext but applications can define their own.

        +getRCE (RCEContext) : RCE
        -------------------------------------------------------------------------
        +getRCE () : RCE

    RCEContext:

    Abstracts runtime information about a Reputation request. This could include
    the target RCE, bias, etc. Basically anything that needs to be passed to an
    RCEManager at runtime to determine the correct RCE to use.  Talon Type
    Reference URIs are another good way to explicitly tell an RMF which RCE you
    would like to use.

        Specify the target RCE for this request. This may be specific to a
        Sierra implementation. If the target is unknown you might get an
        Exception from your RCE.
    
        talon:// URIs should be supported so that you can target a specific
        component instance of an RCE.
    
        Example: 

          talon://universe/component/example.MeanRCE/hashcode/9872365

        +getTargetRCE () : URI
        -------------------------------------------------------------------------
        +setTargetRCE (URI) : void

    RCEQuery:
    
    Tag component which is used to query an RCE.  Sierra is expected to use this
    component with known RCEQuery components but this also allows developers do
    develop their own RCEQuery components for specific applications.

    

Implementations:

Sierra has additional documentation for this package.