source: trunk/include/Arm4db.h @ 704

/**********************************************************************
 * Copyright (c) 2005-2008 David Carter <dcarter@arm4.org> and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors: 
 * David Carter - Initial API and implementation
 **********************************************************************/

#ifndef LIBARM4DB_H     /* Prevent multiple inclusion */
#define LIBARM4DB_H 1

#include <list>
#include <iostream>
#include <libxml/xmlreader.h>

#include "arm4_shm.h"
#include "arm4_db.h"
#include "Arm4dbConfig.h"
#include "Arm4dbBackEnd.h"
 
class Arm4db {
public:
        /* Constructors */

        /* Destructors */
        virtual ~Arm4db ();

        /* Accessors */

        /* Mutators */

        /* Operations */
        static Arm4db *getArm4db (const Arm4dbConfig &config); /* Singleton factory method */
        static Arm4db *getArm4db (void);
        
        arm_error_t closeDatabases (void);
        arm_error_t removeDatabases (void);

    std::ostream& exportDefinitions (std::ostream &os) const;
    std::ostream& exportAll (std::ostream &os) const;
    void import (const char *filename_ptr);
        void importFromMemory (const std::string &xml);

        void initializeThread (void) { m_backendPtr->initializeThread (); }

        arm_error_t openDatabases (void) { return m_backendPtr->openDatabases (); }
        arm_error_t openDatabasesReadOnly (void) { return m_backendPtr->openDatabasesReadOnly (); }
        arm_error_t closeDatabasesNoLock (void) { return m_backendPtr->closeDatabasesNoLock (); }

        arm_error_t initializeSequences (arm4_shm_header_t *header_ptr) { return m_backendPtr->initializeSequences (header_ptr); }

        arm_error_t processApplicationInstances (const arm4_shm_application_instance_t *app_instance_ptr)
                { return m_backendPtr->processApplicationInstances (app_instance_ptr); }
        arm_error_t processApplicationGroup (const arm4_shm_property_t *group_ptr)
                { return m_backendPtr->processApplicationGroup (group_ptr); }
        arm_error_t processApplicationInstanceId (const arm4_shm_property_t *property_ptr)
                { return m_backendPtr->processApplicationInstanceId (property_ptr); }
        arm_error_t processApplicationContext (const arm4_shm_context_property_t *property_ptr)
                { return m_backendPtr->processApplicationContext (property_ptr); }
        arm_error_t processApplicationAddress (const arm4_shm_address_t *address_ptr)
                { return m_backendPtr->processApplicationAddress (address_ptr); }
        arm_error_t processTransactionInstances (const arm4_shm_transaction_instance_t *tran_instance_ptr)
                { return m_backendPtr->processTransactionInstances (tran_instance_ptr); }
        arm_error_t processTransactionContext (const arm4_shm_context_property_t *property_ptr)
                { return m_backendPtr->processTransactionContext (property_ptr); }
        arm_error_t processTransactionUri (const arm4_shm_uri_t *uri_ptr)
                { return m_backendPtr->processTransactionUri (uri_ptr); }
        arm_error_t processTransactionMetricValue (const arm4_shm_metric_value_t *metric_ptr)
                { return m_backendPtr->processTransactionMetricValue (metric_ptr); }
        arm_error_t processTransactionUser (const arm4_shm_user_t *user_ptr)
                { return m_backendPtr->processTransactionUser (user_ptr); }
        arm_error_t processTransactionDiag (const arm4_shm_diag_t *diag_ptr)
                { return m_backendPtr->processTransactionDiag (diag_ptr); }
        arm_error_t processCorrelators (const arm4_shm_correlator_t *correlator_ptr)
                { return m_backendPtr->processCorrelators (correlator_ptr); }
        arm_error_t processSequence (const arm4_shm_db_sequence_t *sequence_ptr)
                { return m_backendPtr->processSequence (sequence_ptr); }
        arm_error_t processRegisterApplication (const arm4_shm_register_application_t *application_ptr,
                arm_id_t *appid_ptr,
                arm_boolean_t *is_new_ptr)
                { return m_backendPtr->processRegisterApplication (application_ptr, appid_ptr, is_new_ptr); }
        arm_error_t processRegisterApplicationIdentity (const arm4_shm_register_application_identity_t *identity_ptr)
                { return m_backendPtr->processRegisterApplicationIdentity (identity_ptr); }
        arm_error_t processRegisterApplicationContext (const arm4_shm_register_application_context_t *context_ptr)
                { return m_backendPtr->processRegisterApplicationContext (context_ptr); }
        arm_error_t processRegisterTransaction (const arm4_shm_register_transaction_t *transaction_ptr,
                arm_id_t *tranid_ptr,
                arm_boolean_t *is_new_ptr)
                { return m_backendPtr->processRegisterTransaction (transaction_ptr, tranid_ptr, is_new_ptr); }
        arm_error_t processRegisterTransactionIdentity (const arm4_shm_register_application_identity_t *identity_ptr)
                { return m_backendPtr->processRegisterTransactionIdentity (identity_ptr); }
        arm_error_t processRegisterTransactionContext (const arm4_shm_register_application_context_t *context_ptr)
                { return m_backendPtr->processRegisterTransactionContext (context_ptr); }
        arm_error_t processRegisterTransactionUri (const arm4_shm_register_transaction_uri_t *uri_ptr)
                { return m_backendPtr->processRegisterTransactionUri (uri_ptr); }
        arm_error_t processRegisterTransactionMetricBinding (const arm4_shm_register_transaction_metric_t *metric_ptr)
                { return m_backendPtr->processRegisterTransactionMetricBinding (metric_ptr); }
        arm_error_t processRegisterMetric (arm4_shm_register_metric_t *metric_ptr, arm_id_t *metricid_ptr)
                { return m_backendPtr->processRegisterMetric (metric_ptr, metricid_ptr); }
        arm_error_t processTraceStats (arm_time_t sample_time, arm4db_transaction_trace_stats_t *stats_ptr, int transaction_count)
                { return m_backendPtr->processTraceStats (sample_time, stats_ptr, transaction_count); }

        void saveApplicationDefinition (const arm_id_t &appl_id, const application_record_t &application)
                { m_backendPtr->saveApplicationDefinition (appl_id, application); }
        void saveApplicationIdentity (const arm_id_t &appl_id, const property_record_t &property)
                { m_backendPtr->saveApplicationIdentity (appl_id, property); }
        void saveApplicationContext (const arm_id_t &appl_id, const indexed_property_name_record_t &property)
                { m_backendPtr->saveApplicationContext (appl_id, property); }
        
        void saveMetricDefinition (const arm_id_t &metric_id, const metric_record_t &metric)
                { m_backendPtr->saveMetricDefinition (metric_id, metric); }
        
        void saveTransactionDefinition (const arm_id_t &tran_id, const transaction_record_t &transaction)
                { m_backendPtr->saveTransactionDefinition (tran_id, transaction); }
        void saveTransactionIdentity (const arm_id_t &tran_id, const property_record_t &property)
                { m_backendPtr->saveTransactionIdentity (tran_id, property); }
        void saveTransactionContext (const arm_id_t &tran_id, const indexed_property_name_record_t &property)
                { m_backendPtr->saveTransactionContext (tran_id, property); }
        void saveTransactionUri (const arm_id_t &tran_id, const char *uri_ptr)
                { m_backendPtr->saveTransactionUri (tran_id, uri_ptr); }
        void saveTransactionMetric (const arm_id_t &tran_id, const arm_metric_binding_t &binding)
                { m_backendPtr->saveTransactionMetric (tran_id, binding); }
        
        void saveApplicationInstance (const arm_app_start_handle_t app_handle, const application_instance_record_t &application)
                { m_backendPtr->saveApplicationInstance (app_handle, application); }
        void saveAppInstanceContextValue (const arm_app_start_handle_t app_handle, const indexed_property_value_record_t &property)
                { m_backendPtr->saveAppInstanceContextValue (app_handle, property); }
        void saveAppInstanceGroup (const arm_app_start_handle_t app_handle, const char *group_ptr)
                { m_backendPtr->saveAppInstanceGroup (app_handle, group_ptr); }
        void saveAppInstanceName (const arm_app_start_handle_t app_handle, const char *name_ptr)
                { m_backendPtr->saveAppInstanceName (app_handle, name_ptr); }
        void saveAppInstanceAddress (const arm_app_start_handle_t app_handle, const application_address_record_t &address_value)
                { m_backendPtr->saveAppInstanceAddress (app_handle, address_value); }

        void saveTransactionInstance (const arm_tran_start_handle_t tran_handle, const transaction_instance_record_t &transaction)
                { m_backendPtr->saveTransactionInstance (tran_handle, transaction); }
        void saveTranInstanceContextValue (const arm_tran_start_handle_t tran_handle, const indexed_property_value_record_t &property)
                { m_backendPtr->saveTranInstanceContextValue (tran_handle, property); }
        void saveTranInstanceMetricValue (const arm_tran_start_handle_t tran_handle, const metric_value_record_t &metric)
                { m_backendPtr->saveTranInstanceMetricValue (tran_handle, metric); }
        void saveTranInstanceUri (const arm_tran_start_handle_t tran_handle, const char *uri_ptr)
                { m_backendPtr->saveTranInstanceUri (tran_handle, uri_ptr); }
        void saveTranInstanceUser (const arm_tran_start_handle_t tran_handle, const user_record_t &user)
                { m_backendPtr->saveTranInstanceUser (tran_handle, user); }
        void saveTranInstanceDiag (const arm_tran_start_handle_t tran_handle, const char *diag_ptr)
                { m_backendPtr->saveTranInstanceDiag (tran_handle, diag_ptr); }
        void saveTranCorrelator (const arm_tran_start_handle_t tran_handle, const arm_correlator_t *correlator_ptr)
                { m_backendPtr->saveTranCorrelator (tran_handle, correlator_ptr); }
        void saveTranParentCorrelator (const arm_tran_start_handle_t tran_handle, const arm_correlator_t *correlator_ptr)
                { m_backendPtr->saveTranParentCorrelator (tran_handle, correlator_ptr); }

        void saveTraceStats (const arm_time_t sample_time, const arm4db_transaction_trace_stats_t &trace_stats)
                { m_backendPtr->saveTraceStats (sample_time, trace_stats); }

        /* Checkpoint the database transactions */
        void checkpoint (void) { m_backendPtr->checkpoint (); }
        
        /* Get transaction stats */
        void *getStats (void) { return m_backendPtr->getStats (); }

        /* Debugging routines */
        void dump (void) const { m_backendPtr->dump (); }
        
        /* Database backup and rollover */
        void backup (void) { m_backendPtr->backup (); }

    /* Reporting functions */
    void printSummaries (void) const { m_backendPtr->printSummaries (); }
    void printTransactions (void) const { m_backendPtr->printTransactions (); }
    
    std::list<arm_id_t> *getApplicationList (void)
                { return m_backendPtr->getApplicationList (); }
    std::list<arm_id_t> *getTransactionList (void)
                { return m_backendPtr->getTransactionList (); }
    std::list<arm_id_t> *getTransactionList (const arm_id_t &app_id)
                { return m_backendPtr->getTransactionList (app_id); }
        std::list<arm_tran_start_handle_t> *getTransactionInstanceList (const arm_id_t &tran_id)
                { return m_backendPtr->getTransactionInstanceList (tran_id); }
        int getApplicationCount (void)
                { return m_backendPtr->getApplicationCount (); }
        int getTransactionCount (void)
                { return m_backendPtr->getTransactionCount (); }
        int getTransactionCount (const arm_id_t &app_id)
                { return m_backendPtr->getTransactionCount (app_id); }
    
    arm_error_t getApplicationInformation (const arm_id_t &app_id, arm4db_application_summary_t *summary_ptr)
                { return m_backendPtr->getApplicationInformation (app_id, summary_ptr); }
    arm_error_t getTransactionInformation (const arm_id_t &tran_id, arm4db_transaction_summary_t *summary_ptr)
                { return m_backendPtr->getTransactionInformation (tran_id, summary_ptr); }
        const arm_correlator_t *getCorrelator (arm_tran_start_handle_t tran_handle, arm_correlator_t *correlator_ptr)
                { return m_backendPtr->getCorrelator (tran_handle, correlator_ptr); }
        const arm_correlator_t *getParentCorrelator (arm_tran_start_handle_t tran_handle, arm_correlator_t *correlator_ptr)
                { return m_backendPtr->getParentCorrelator (tran_handle, correlator_ptr); }
    
    void setTransactionTraceInformation (const arm_id_t &tran_id, const arm4db_transaction_summary_t &summary)
                { m_backendPtr->setTransactionTraceInformation (tran_id, summary); }
    
    std::ostream& exportApplicationDefinitions (std::ostream &os) const
                { return m_backendPtr->exportApplicationDefinitions (os); }
    std::ostream& exportTransactionDefinitions (std::ostream &os) const
                { return m_backendPtr->exportTransactionDefinitions (os); }
    std::ostream& exportMetricDefinitions (std::ostream &os) const
                { return m_backendPtr->exportMetricDefinitions (os); }
    std::ostream& exportApplications (std::ostream &os) const
                { return m_backendPtr->exportApplications (os); }
    std::ostream& exportTransactions (std::ostream &os) const
                { return m_backendPtr->exportTransactions (os); }
    std::ostream& exportTraceStats (std::ostream &os) const
                { return m_backendPtr->exportTraceStats (os); }

        /* Operators */

private:
        /* The main constructor is protected so we can implement a factory */
        Arm4db ();

        /* Mark these as private to prevent their use */
        Arm4db (const Arm4db &);
        Arm4db &operator= (const Arm4db &);
        
        static const Arm4dbConfig &getConfig (void) { return Arm4dbConfig::getConfig (); }
        void setBackEnd (void);
        void initializeLibrary (void) { m_backendPtr->initializeLibrary (); }

        // XML Parser routines
        void streamReader(xmlTextReaderPtr reader);
        void streamFile(const char *filename);
        void streamFileFromMemory(const std::string &xml);
        
        const xmlChar *getTextNode(xmlTextReaderPtr reader);
        arm_int32_t getIntNode(xmlTextReaderPtr reader);
        arm_int64_t getInt64Node(xmlTextReaderPtr reader);
        void getTimeNode(xmlTextReaderPtr reader, arm_time_t &time_value);
        void getIdNode(xmlTextReaderPtr reader, arm_id_t &id);
        void getDigestNode(xmlTextReaderPtr reader, char *digest_ptr);
        void getAddressNode(xmlTextReaderPtr reader, arm_uint8_t *address_ptr);
        void getCorrelatorNode(xmlTextReaderPtr reader, arm_correlator_t *correlator_ptr);
        void getMetricNode(xmlTextReaderPtr reader, metric_value_record_t &metric);
        
        void processAnyNode(xmlTextReaderPtr reader);
        
        void processArm4ApplicationDefinitionNode(xmlTextReaderPtr reader);
        void processApplicationIdentity(xmlTextReaderPtr reader, const arm_id_t &appl_id);
        void processApplicationContext(xmlTextReaderPtr reader, const arm_id_t &appl_id);

        void processArm4MetricDefinitionNode(xmlTextReaderPtr reader);

        void processArm4TransactionDefinitionNode(xmlTextReaderPtr reader);
        void processTransactionIdentity(xmlTextReaderPtr reader, const arm_id_t &tran_id);
        void processTransactionContext(xmlTextReaderPtr reader, const arm_id_t &tran_id);
        void processTransactionMetric(xmlTextReaderPtr reader, const arm_id_t &tran_id);

        void processArm4ApplicationInstanceNode(xmlTextReaderPtr reader);
        void processAppInstanceContextValue(xmlTextReaderPtr reader, const arm_app_start_handle_t app_handle);
        void processAppInstanceAddress(xmlTextReaderPtr reader, const arm_app_start_handle_t app_handle);
        
        void processArm4TransactionInstanceNode(xmlTextReaderPtr reader);
        void processTranInstanceContextValue(xmlTextReaderPtr reader, const arm_tran_start_handle_t tran_handle);
        void processTranInstanceMetricValue(xmlTextReaderPtr reader, const arm_tran_start_handle_t tran_handle);
        void processTranInstanceUser(xmlTextReaderPtr reader, const arm_tran_start_handle_t tran_handle);

        void processArm4TransactionTraceNode(xmlTextReaderPtr reader);

        void processArm4DefinitionsNode(xmlTextReaderPtr reader);
        void processArm4InstancesNode(xmlTextReaderPtr reader);
        void processArm4Node(xmlTextReaderPtr reader);
        void processRootNode(xmlTextReaderPtr reader);


        static Arm4dbBackEnd *m_backendPtr; // The actual database backend
        static Arm4db *m_singletonPtr;  // The current database instance
};

#endif /* LIBARM4DB_H */