customdb_samples/createdbsample/main.cpp

/* IBM Source Code */
/* (C) Copyright IBM Corp. 2012 */
/* Licensed Materials - Property of IBM */
/* US Government Users Restricted Rights - Use duplication or disclosure restricted by GSA Schedule Contract with IBM Corp. */
 
#include <string>
#include <set>
#include <iostream>
#include <fstream>
#include <sstream>
#include <ctime>
 
#include "dca/dca_base.h"
#include "dca/dca_customdb_toolbox.h"
#include "dca/dca_url_classification.h"
#include "dca/dca_callbacks.h"
 
using namespace dca;
 
const std::string S_ToolName = "createdbsample";
const std::string S_ToolVersion = "1.0";
 
std::string custom_db_folder;
 
// URL sample string
const std::string S_UrlString( "www.an_example_custom_url.com" );
 
const std::string S_UsageString =
        "<redist-folder> <ticket> <product> <custom-db-folder>\n"
        "  redist-folder - the folder where the DCA is installed to\n"
        "  ticket - a valid ticket\n"
        "  product - the product associated with your ticket\n"
        "  custom-db-folder - the folder where the Custom Database should be created in\n\n"
        ;
 
#ifdef WIN32
#       define DCA_BINDIR               "bin/Win32"
#else
#       define DCA_BINDIR               "bin/linux"
#endif
 
#define DCA_INITDIR             "init"
 
#define DCA_LOGDIR              "./logs"
 
static void SetupInitData( const std::string& redist_folder, InitData& initData )
{
        initData.binDir = redist_folder + DCA_BINDIR;
        initData.initDir = redist_folder + DCA_INITDIR;
        initData.logDir = DCA_LOGDIR;
}
 
static void SetupLicense( const std::string& ticket, const std::string& product,
        LicenseData& licenseData )
{
        licenseData.ticket      = ticket;
        licenseData.product     = product;
}
 
static void SetupConnectionData( const std::string& custom_db_folder, 
        DbConnectionData& cData )
{
        cData.useLocalDatabase = true;
        cData.dbType = DBT_Custom;
        cData.customData.configDir = custom_db_folder;
}
 
static void PrintToolHeader()
{
        std::cout << "IBM DCA Sample: " << S_ToolName << " (" << S_ToolVersion << 
                ")" << std::endl;
}
 
static void PrintUsage( const char *name )
{
        std::cout << " usage:" << std::endl;
        std::cout << name << " " << S_UsageString << std::endl;
}
 
static void PrintLicenseInfo( const License& aLicense )
{
        const time_t expirationDate = aLicense.getExpirationDate();
        struct tm *expirationTime = localtime( &expirationDate );
 
        std::cout << "License Info:" << std::endl;
        std::cout << "  DCA is " << ( aLicense.isLicensed() ? "licensed." : 
                "not licensed." ) << std::endl;
        std::cout << "  MaxUsers:" << aLicense.getMaxUsers() << 
                std::endl;
        std::cout << "  MaxSessions:" << aLicense.getMaxSessions() << 
                std::endl;
        std::cout << "  Ticket:" << aLicense.getTicket() << 
                std::endl;
        std::cout << "  Session:" << aLicense.getSession() << 
                std::endl;
        std::cout << "  Last Message:" << aLicense.getLastMessage() << 
                std::endl;
        std::cout << "  Expiration Date:" << asctime( expirationTime ) << 
                std::endl;
}
 
void AddUrlAndCategories( UrlCustomDb& aUrlCustomDb, const std::string& aUrlString,
        const CategorySet& aCategories )
{
        std::ostringstream log;
        log << "  Added URL '" << aUrlString << "'";
 
        int added_cnt = 0;
 
        for( CategorySet::const_iterator I = aCategories.begin(),
                IEnd = aCategories.end(); I != IEnd; ++I ) 
        {
                if( added_cnt == 0 )
                        log << " with categories [";
 
                log << (*I);
 
                if( ( added_cnt == 0 ) || ( added_cnt < (int)aCategories.size() - 1 ) )
                        log << ", ";
 
                ++added_cnt;
        }
        if( added_cnt ) 
                log << "]";
 
        log << " to the custom database";
 
        // add the URL to the custom database with the given categories
        aUrlCustomDb.setUrl( aUrlString, aCategories );
        std::cout << log.str() << std::endl;
}
 
void RemoveUrl( UrlCustomDb& aUrlCustomDb, const std::string& aUrlString )
{
   aUrlCustomDb.removeUrl( aUrlString );
   std::cout << "  Removed URL '" << aUrlString << 
           "' from the custom database" << std::endl;
}
 
bool LookupUrl( const DcaInstance& theDca, const UrlDbClassifier& aUrlDbClassifier,
        const std::string& aUrlString, UrlClassificationResults& 
        aUrlClassificationResults )
{
        Url myUrl = Url::create( theDca, aUrlString );
        
        FunctionResult myFR = aUrlDbClassifier.classify( myUrl, aUrlClassificationResults );
        if( !myFR ) {
                std::cerr << "Error occured while calling UrlDbClassifier::classify() RC:" <<
                        myFR.getReturnCode() << ", Details:" << myFR.getDescription() <<
                        std::endl;
                return false;
        }
 
        return true;
}
 
bool CreateCustomDbFile( UrlCustomDbModule& aUrlCustomDbModule, 
        const std::string& dbfolder )
{
        FunctionResult fr = aUrlCustomDbModule.createCustomDb( 
                dbfolder );
 
        if( !fr ) {
                if (fr.getReturnCode() == ERR_DATABASE_ALREADY_EXISTING) {
                        std::cerr << "Error: Database already exists" << 
                                std::endl;                      
                } 
                else {
                        std::cerr << "Creation of custom database failed: RC:" << 
                                fr.getReturnCode() << ", Details:" << 
                                fr.getDescription() << std::endl;
                }
                return false;
        }
 
        return true;
}
 
bool CreateCustomDbInstances( const DcaInstance& theDca, const License& aLicense, 
        UrlCustomDbModule& aUrlCustomDbModule, DbConnection& aDbConnection, 
        const std::string& dbfolder, UrlCustomDb& aUrlCustomDb )
{
        try {
                // set up a the database connection to the custom database
                DbConnectionData myDbConnectionData;
                SetupConnectionData( dbfolder, myDbConnectionData );
 
                // Create a database connect to the custom database file. On error
                // this will throw a ExDca exception
                aDbConnection = theDca.createDbConnection( aLicense, myDbConnectionData );
                        
                // create the CustomDb instance. On error this will throw a ExDca exception
                aUrlCustomDb = aUrlCustomDbModule.openCustomDb( aDbConnection );        
 
                return true;
        }
        catch( const ExDca& ex ) {
                std::cerr << "EcDca Exception caught. Details: " <<  ex.getDescription() 
                        << " (" << ex.getReturnCode() << ")" << std::endl;
                return false;
        }
        catch( const std::exception& stdex ) {
                std::cerr << "std::exception caught. Details: " << stdex.what() << 
                        std::endl;
                return false;
        }
}
 
bool CreateUrlClassificationInstances( const DcaInstance& theDca, const License& aLicense,
        const DbConnection& aDbConnection, UrlClassification& aUrlClassification, 
        UrlDbClassifier& aUrlDbClassifier ) 
{
        try {
                // create the url classification module itself
                aUrlClassification = UrlClassification::create( theDca, aLicense );
 
                // create an UrlDbClassifier
                aUrlDbClassifier = aUrlClassification.createDbClassifier( aDbConnection );
 
                return true;
        }
        catch( const ExDca& ex ) {
                std::cerr << "EcDca Exception caught. Details: " <<  ex.getDescription() 
                        << " (" << ex.getReturnCode() << ")" << std::endl;
                return false;
        }
        catch( const std::exception& stdex ) {
                std::cerr << "std::exception caught. Details: " << stdex.what() << 
                        std::endl;
                return false;
        }
        catch(...) {
                std::cerr << "Unknown exception caught" << std::endl;
                return false;
        }
}
 
bool ProcessCustomDatabase( const DcaInstance& theDca, const License& aLicense )
{
        std::cout << "Started ProcessCustomDatabase" << std::endl;
 
        std::cout << "* Initializing custom database module" << std::endl;
 
        // initialize the UrlCustomModule
        UrlCustomDbModule myUrlCustomDbModule = 
                UrlCustomDbModule::create( theDca, aLicense );
 
        std::cout << "* Creating new custom database file in folder '" << 
                custom_db_folder << "'" << std::endl;
 
        // create the custom database file physically
        if( !CreateCustomDbFile( myUrlCustomDbModule, custom_db_folder ) ) {
                return false;
        }
 
        // create a database connection and a UrlCustomDb instance and connect then to
        // the custom database file
        std::cout << "* Creating DbConnection and UrlCustomDb instance"
                << std::endl;
 
        DbConnection myDbConnection;
        UrlCustomDb myUrlCustomDb;
 
        if( !CreateCustomDbInstances( theDca, aLicense, myUrlCustomDbModule, 
                myDbConnection, custom_db_folder, myUrlCustomDb ) ) {
                return false;
        }
 
        std::cout << "* Starting Test by adding an URL and Categories to the custom database"
                << std::endl;
 
        // Add an URL (S_UrlString) to the custom database, categorized as 0 and 1
        CategorySet myCategories;
        myCategories.insert( 0 );
        myCategories.insert( 1 );
 
        AddUrlAndCategories( myUrlCustomDb, S_UrlString, myCategories );
 
        std::cout << "* Try to retrieve added URL and Categories from the custom database"
                << std::endl;
 
        // Retrieve the URL and its categories by using the UrlCustomDb instance
        CategorySet myResultCategories;
        if( !myUrlCustomDb.getUrl( S_UrlString, myResultCategories ) ) {
                        std::cerr << "Could not retrieve URL '" << S_UrlString << 
                        "' from UrlCustomDb instance" << std::endl;
                return false;
        }
 
        if( myResultCategories.size() != 2 ) {
                std::cerr << "Could not retrieve the correct categories for URL '" << 
                        S_UrlString << "' using UrlCustomDb instance" << std::endl;
                return false;
        }
 
        CategorySet::const_iterator IEnd = myResultCategories.end();
        if( myResultCategories.find( 0 ) != IEnd &&
                myResultCategories.find( 1 ) != IEnd )
                std::cout << "  Lookup URL '" << S_UrlString << 
                "' returned category 0 and 1" << std::endl; 
 
        std::cout << "* Removing previously added URL from the custom database"
                << std::endl;
 
        // Remove the URL S_UrlStirng from custom database
        RemoveUrl( myUrlCustomDb, S_UrlString );
 
        std::cout << "* Verifying that it isn't in the custom database anymore"
                << std::endl;
 
        // Verify that it's not in the custom database anymore
        if( myUrlCustomDb.getUrl( S_UrlString, myResultCategories ) ) {
                std::cerr << "URL '" << S_UrlString << "' is still in the " << 
                        "custom database." << std::endl;
                return false;
        }
 
        std::cout << "* Re-adding URL and Categories to the custom database for the next test"
                << std::endl;
 
        // Add URL again 
        AddUrlAndCategories( myUrlCustomDb, S_UrlString, myCategories );
 
        // Now testing URL Classification with the custom database connection
        // This is the common way how clients will use the custom database for lookups
 
        UrlClassification myUrlClassification;
        UrlDbClassifier myUrlDbClassifier;
 
        std::cout << "* Creating UrlClassification and UrlDbClassifier instance" 
                << std::endl;
 
        if( !CreateUrlClassificationInstances( theDca, aLicense, myDbConnection, 
                myUrlClassification, myUrlDbClassifier ) )
        {
                // error logging is done in CreateUrlClassificationInstances
                return false;
        } 
 
        // Retrieve the URL and its categories by using the UrlClassification
        std::cout << "* Retrieving URL and Categories by using the UrlClassification instances"
                << std::endl;
 
        UrlClassificationResults myResults;
        if( !LookupUrl( theDca, myUrlDbClassifier, S_UrlString, myResults ) ) {
                std::cerr << "Could not retrieve URL '" << S_UrlString << 
                        "' from UrlDbClassifier instance" << std::endl;
                return false;
        }
 
        if( myResults.size() != 2 ) {
                std::cerr << "Could not retrieve the correct categories for URL '" << 
                        S_UrlString << "' using UrlDbClassifier instance" << std::endl;
                return false;
        }
 
        if( myResults.contains( 0 ) && myResults.contains( 1 ) ) {
                std::cout << "  Lookup URL '" << S_UrlString << 
                "' returned category 0 and 1" << std::endl; 
        }
 
        std::cout << "* Done, leaving test function, cleanup of local instances " <<
                "is done automatically by going out-of-scope" << std::endl;
 
        return true;
}
 
int main( int argc, char *argv[] )
{
        PrintToolHeader();
 
        int rc = 5;
 
        try {
                if( argc < 5 ) {
                        PrintUsage( argv[0] );
                        return rc;
                }
 
                std::string myRedistFolder = argv[ 1 ];
                const std::string myTicket = argv[ 2 ];
                const std::string myProduct = argv[ 3 ];
                custom_db_folder = argv[ 4 ];
 
                if( myRedistFolder.empty() || myTicket.empty() ||
                    myProduct.empty() || custom_db_folder.empty() ) {
                        PrintUsage( argv[0] );
                        return rc;
                }
 
                // check for trailing fileslash on directories - and add if necessary
                char c = *(myRedistFolder.rbegin());
                if( c != '/' && c != '\\' )
                        myRedistFolder += "/";
 
                c = *(custom_db_folder.rbegin());
                if( c != '/' && c != '\\' )
                        custom_db_folder += "/";
 
                // init the 3rd party libraries
                InitCUrl();
                SetOpenSslCallbacks();
 
                { // scope for DcaInstance and License
 
                        // setup DCA directories
                        InitData myInitData;
                        SetupInitData( myRedistFolder, myInitData );
 
                        // instantiate the DCA API
                        DcaInstance myDca;
                        myDca = DcaInstance::create( myInitData );
 
                        // setup license data
                        LicenseData myLicenseData;
                        SetupLicense( myTicket, myProduct, myLicenseData );
                        const License myLicense = myDca.createLicense( myLicenseData );
 
                        // print out all information about the created License object
                        PrintLicenseInfo( myLicense );
                        
                        if( myLicense.isLicensed( UrlCustomDbModule::ID ) ) {
                                // Call the main test routine
                                if( ProcessCustomDatabase( myDca, myLicense ) )
                                        rc = 0;
                        }
                }
        }
        catch( const ExDca& ex ) {
                std::cerr << "DCA Exception occured. Details: " <<  ex.getDescription() 
                        << " (" << ex.getReturnCode() << ")" << std::endl;
                rc = 10;
        }
        catch( const std::exception& s ) {
                std::cerr << "std::exception occured. Details: " << s.what() <<
                        std::endl;
                rc = 10;
        }
 
        // deinit the 3rd party libraries
        UnsetOpenSslCallbacks();
        DeinitCUrl();
 
        return rc;
}