EventEngine.idl

module event {

    structure KeyValue {
        string key;     
        string value;   
    };
    
    structure Event {

        enumeration Type {
            STATE,                      
            TRIGGER                     
        };
        
        Type            type;           
        vector<string>  id;             
        boolean         asserted;       
        time            timeStamp;      
        vector<KeyValue> context;       
    };

    interface Engine_1_0_1 {

        /* Event registration and query */
        /* ---------------------------- */
        
        structure EventDesc {

            enumeration Type {
                NODE,                   
                DYN_NODE,               
                LEAF                    
            };

            Type eventDescType;         
            Event.Type eventType;       
            string dynNodeContext;      
            string idComp;              
            string name;                
            vector<EventDesc> entries;  
        };
        
        int listEventDescs(in vector<string> eventIdPrefix,
                           out vector<EventDesc> eventDescs);

        
        /* Action definition and query */
        /* --------------------------- */

        vector<string> listActionTypes();

        structure Action {
            string id;                  
            string name;                
            boolean isSystem;           
            string type;                
            vector<KeyValue> arguments; 
        };

        int addAction(in Action action, out string actionId);

        int modifyAction(in Action action);

        int deleteAction(in string actionId);

        vector<Action> listActions();

        int triggerAction(in string actionId, out string errMsg,
                          in vector<KeyValue> context);

        int testAction(in Action action, out string errMsg,
                       in vector<KeyValue> context);

        
        /* Rule Definition and query */
        /* ------------------------- */

        structure Condition {

            enumeration Op {
                AND,                    
                OR,                     
                XOR                     
            };
            
            enumeration MatchType {
                ASSERTED,               
                DEASSERTED,             
                BOTH                    
            };
            
            boolean negate;             
            Op operation;               
            MatchType matchType;        
            vector<string> eventId;     
            vector<Condition> conditions; 
        };

        structure Rule {
            string id;                  
            string name;                
            boolean isSystem;           
            boolean isEnabled;          
            boolean isAutoRearm;        
            boolean hasMatched;         
            Condition condition;        
            vector<string> actionIds;   
            vector<KeyValue> arguments; 
        };
        
        int addRule(in Rule rule, out string ruleId);

        int modifyRule(in Rule rule);

        int enableRule(in string ruleId);
        
        int disableRule(in string ruleId);
        
        int deleteRule(in string ruleId);

        vector<Rule> listRules();

        
        /* Deliver and confirm events. */
        /* --------------------------- */
        
        int deliverEvent(in Event event);

        int rearmRule(in string ruleId);

    };
    
}