customdb_samples/customdbsample/main.cpp

/* IBM Source Code */
/* (C) Copyright IBM Corp. 2009, 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 <ctime>
 
#include "dca/dca_base.h"
#include "dca/dca_customdb_toolbox.h"
#include "dca/dca_callbacks.h"
 
using namespace dca;
 
const std::string S_ToolName = "customdbsample";
const std::string S_ToolVersion = "1.2";
 
std::string custom_db_folder;
std::string categories_folder;
 
const std::string S_UsageString =
        "<redist-folder> <ticket> <product> <custom-db-folder> <categories-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"
        "  categories-folder - the folder where your XML files are located in\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;
}
 
static void PrintCategoriesInfo( const CategoriesInfo& myCategoriesInfo )
{
        // iterate and print out given locales
        const Locales myLocales = myCategoriesInfo.getLocales();
        if( myLocales.size() == 0 ) {
                std::cout << "There are no locales defined or not found!" << 
                        std::endl;
        }
        else {
                for( DCA_INDEX_TYPE i = 0; i < myLocales.size(); ++i ) {
                        const Locale myLocale = myLocales[i];
                        std::cout << "Locale #" << (i+1) << ", displayname='" <<
                                myLocale.displayName() << "', languageid='" <<
                                myLocale.languageId() << "'." << std::endl;
                }
        }
 
        // iterate and print out given groups
        const Groups myGroups = myCategoriesInfo.getGroups();
        if( myGroups.size() == 0 ) {
                std::cout << "There are no groups defined or not found!" << 
                        std::endl;
        }
        else {
                for( DCA_INDEX_TYPE i = 0; i < myLocales.size(); ++i ) {
                        const Group myGroup = myGroups[i];
                        std::cout << "Group #" << (i+1) << ", name='" <<
                                myGroup.name( "" ) << "', id=" <<
                                myGroup.id() << "." << std::endl;
                }
        }
 
        // iterate and print out given categories
        const Categories myCategories = myCategoriesInfo.getCategories();
        if( myCategories.size() == 0 ) {
                std::cout << "There are no categories defined or not found!" << 
                        std::endl;
        }
        else {
                for( DCA_INDEX_TYPE i = 0; i < myCategories.size(); ++i ) {
                        const Category myCategory = myCategories[i];
                        std::cout << "Category #" << (i+1) << ", name='" <<
                                myCategory.name( "" ) << "', id=" <<
                                myCategory.id() << ", groupid=" <<
                                myCategory.groupId() << "." << std::endl;
                }
        }
}
 
static void PrintUrlResult( const std::string& myUrlString, 
        const std::set< int >& myCatSet )
{
        std::cout << "URL '" << myUrlString << 
                "' contains the following categories: ";
        for( std::set< int >::const_iterator I = myCatSet.begin(),
                IEnd = myCatSet.end(); I != IEnd; ++I ) {
 
                std::cout << *I << std::endl;
        }
        std::cout << std::endl;
}
 
void InitializeCustomDatabase( const DcaInstance& aDca, const License& aLicense,
        UrlCustomDb& myUrlCustomDb )
{
        // initialize the UrlCustomModule
        UrlCustomDbModule myUrlCustomDbModule = 
                UrlCustomDbModule::create( aDca, aLicense );
 
        // create a CategoriesInfo by using the provided 
        // categories_folder
        const CategoriesInfo myCategoriesInfo = 
                myUrlCustomDbModule.createCategoriesInfo( 
                        categories_folder );
 
        // print out the custom CategoriesInfo
        PrintCategoriesInfo( myCategoriesInfo );
 
        // ensure that the Custom Database is already existing or if 
        // not, create a new blank Custom Database
        FunctionResult fr = myUrlCustomDbModule.createCustomDb( 
                custom_db_folder );
                
        if( !fr ) {
                if (fr.getReturnCode() == ERR_DATABASE_ALREADY_EXISTING) {
                        std::cout << "Database already existing..." << 
                                std::endl;
                } else {
                        std::cout << "Creation of Custom Database failed..." << 
                                std::endl;
                }
        }
 
        // set up a signature database connection
        DbConnectionData myDbConnectionData;
        SetupConnectionData( custom_db_folder, myDbConnectionData );
 
        // if the creation of the DbConnection will fail, there is no 
        // Custom Database available
        const DbConnection myDbConnection = 
                aDca.createDbConnection( aLicense, myDbConnectionData );
                
        // create the CustomDb instance and open the database
        myUrlCustomDb = myUrlCustomDbModule.openCustomDb( myDbConnection );     
}
 
int ProcessCustomDatabase( const DcaInstance& aDca, const License& aLicense )
{
        UrlCustomDb myUrlCustomDb;
 
        // Initialize and set up myUrlCustomDb
        InitializeCustomDatabase( aDca, aLicense, myUrlCustomDb );
 
        // this is the URL we want to use
        const std::string myUrlString( "www.an_example_custom_url.com" );
 
        // add a URL to the database and add category 0 and 1
        {
                std::set< int > myCatSet;
                myCatSet.insert( 0 );
                myCatSet.insert( 1 );
                myUrlCustomDb.setUrl( myUrlString, myCatSet );
        }
 
        // retrieve the categories for the URL
        {
                std::set< int > myCatSet;
                if( !myUrlCustomDb.getUrl( myUrlString, myCatSet ) ) {
                        // this should never happen!
                        std::cout << "We could not retrieve the previously added URL?" 
                                << std::endl;
                        return 5;
                }
        
                // print out the categories associated with given URL
                PrintUrlResult( myUrlString, myCatSet );
        }
        
        // remove the URL from the custom database
        myUrlCustomDb.removeUrl( myUrlString );
 
        // Again retrieve the URL from database - this should fail since we 
        // recently removed it from the custom database
        {
                std::set< int > myCatSet;
                if( myUrlCustomDb.getUrl( myUrlString, myCatSet ) ) {
                        // this should never happen!
                        std::cout << "We could still retrieve the URL we already removed?" 
                                << std::endl;
                        return 6;
                }
        }
        
        std::cout << "URL has been successfully removed from " << 
                "Custom Database." << std::endl;
 
        return 0;       
}
 
int main( int argc, char *argv[] )
{
        PrintToolHeader();
 
        int rc = 5;
 
        try {
                if( argc < 6 ) {
                        PrintUsage( argv[0] );
                        return 1;
                }
 
                std::string myRedistFolder = argv[ 1 ];
                const std::string myTicket = argv[ 2 ];
                const std::string myProduct = argv[ 3 ];
                custom_db_folder = argv[ 4 ];
                categories_folder = argv[ 5 ];
 
                if( myRedistFolder.empty() || myTicket.empty() ||
                         myProduct.empty() || custom_db_folder.empty() ||
                         categories_folder.empty() ) {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                // check for trailing fileslash on directories - and add if necessary
                char c = myRedistFolder[ myRedistFolder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        myRedistFolder += "/";
 
                c = custom_db_folder[ custom_db_folder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        custom_db_folder += "/";
 
                c = categories_folder[ categories_folder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        categories_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 ) ) {
                                // Create custom database, add an entry, remove entry,
                                // retrieve categories etc.
                                rc = ProcessCustomDatabase( myDca, myLicense );         
                        }
                }
        }
        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;
        }
        catch(...) {
                std::cerr << "Unknown exception caught." << std::endl;
                rc = 10;
        }
 
        // deinit the 3rd party libraries
        UnsetOpenSslCallbacks();
        DeinitCUrl();
 
        return rc;
}