Subversion Repositories DevTools

//---------------------------------------------------------------------------

#pragma warn -com
#include <LoggingMacros.h>
#pragma warn +com

#pragma hdrstop

#include "UdTransferManager.h"
#include "UdTransferThread.h"
#include "DataModule.h"
#include "UdTransferHistory.h"
#include "IDevice.h"

//---------------------------------------------------------------------------

namespace
{
    AnsiString GetSQLDateTime( TDateTime datetime )
    {
        AnsiString      sqldate;
        sqldate.sprintf("TO_DATE('%s','YYYY-MM-DD HH24:MI:SS')",
                        datetime.FormatString("yyyy-mm-dd hh:nn:ss").c_str());
        return sqldate;
    }
}

//---------------------------------------------------------------------------

#pragma package(smart_init)

UdTransferManager::UdTransferManager() :
    m_deviceSimulatorFactory( 0 )
{
    // Get required settings

    m_username = getenv("USERNAME");
    m_hostname = getenv("COMPUTERNAME");

    if( m_username.IsEmpty() )
    {
        char name[ 256 ];
        unsigned long size = sizeof( name );
        if( GetUserName( name, &size ) )
        {
            m_username = name;
        }
    }
    if( m_hostname.IsEmpty() )
    {
        char name[ 256 ];
        unsigned long size = sizeof( name );
        if( GetComputerName( name, &size ) )
        {
            m_hostname = name;
        }
    }

    m_tasksLock = new Syncobjs::TCriticalSection;

    // Load the device simulator library

    m_deviceSimulatorWrapperDll = ::LoadLibrary("DeviceSimulatorWrapperP.dll");
    if( m_deviceSimulatorWrapperDll == NULL )
    {
        MessageDlg("Failed to load library 'DeviceSimulatorWrapperP.dll'.\nDevice simulation functionality will not be available.",
            mtError, TMsgDlgButtons() << mbOK, 0 );
    }
    else
    {
        // Get a device factory instance

                m_getDeviceFactory = reinterpret_cast< getDeviceFactory_t >(
                                ::GetProcAddress( m_deviceSimulatorWrapperDll, "getDeviceFactory" ) );
        if( m_getDeviceFactory == NULL )
        {
            MessageDlg("Failed to get device factory from library 'DeviceSimulatorWrapperP.dll'.\nDevice simulation functionality will not be available.",
                mtError, TMsgDlgButtons() << mbOK, 0 );
        }
        else
        {
            m_deviceSimulatorFactory = m_getDeviceFactory();
        }
    }
}
//---------------------------------------------------------------------------

UdTransferManager::~UdTransferManager()
{
    UdTransferThreadItem thread = m_threads.begin();
    for( ; thread != m_threads.end(); thread++ )
    {
        if( (*thread).second != NULL )
        {
            (*thread).second->StopTransfer();
            delete (*thread).second;
        }
    }
    m_threads.clear();
    delete m_tasksLock;

    if( m_deviceSimulatorWrapperDll != NULL )
    {
        // Freeing the library deletes the factory instance

        FreeLibrary( m_deviceSimulatorWrapperDll );
        m_deviceSimulatorFactory = 0;
    }
}
//---------------------------------------------------------------------------

void UdTransferManager::AddNewTask( const UdTransferTask & task )
{
    // Add the new task to the database

    TADOQuery * txnquery = new TADOQuery(NULL);
    if( txnquery == NULL ) return;

    txnquery->Connection = Data_Module->IntegrationDBConnection;

    AnsiString sql_statement;
    sql_statement.sprintf("insert into TRANSFER_HISTORY "
                          "            (ADDED_TIME, USERNAME, HOSTNAME, STATUS, "
                          "             RAMP_TIME, SOURCE_PATH, BATCH_SIZE, "
                          "             DURATION, FREQUENCY, RECURRING, "
                          "             RAMP_TYPE, RAMP_GRADIENT, DESTINATION) "
                          "values      (sysdate, '%s', '%s', %d, "
                          "             %s, '%s', %d, "
                          "             %d, %d, %d, "
                          "             %d, %f, '%s') ",
                          m_username, m_hostname, (int)UdTransferPending,
                          GetSQLDateTime(task.rampTime), task.sourcePath, task.batchSize,
                          task.duration, task.frequency, task.recurring,
                          (int)task.rampType, task.gradient, task.destination);
    txnquery->SQL->Text = sql_statement;
    if( txnquery->ExecSQL() != 1 )
    {
        MERROR( "Failed to add new UD transfer task to the DB" );
    }
    txnquery->Close();

    // Now get its id and add it to our list

    sql_statement.sprintf("select TRANSFER_NO, ADDED_TIME "
                          "from   TRANSFER_HISTORY "
                          "where  USERNAME = '%s' and "
                          "       HOSTNAME = '%s' and "
                          "       STATUS = %d and "
                          "       RAMP_TIME = %s and "
                          "       BATCH_SIZE = %d and "
                          "       DURATION = %d and "
                          "       FREQUENCY = %d and "
                          "       RECURRING = %d and "
                          "       RAMP_TYPE = %d and "
                          "       RAMP_GRADIENT = %f "
                          "order by ADDED_TIME desc ",
                          m_username, m_hostname, (int)UdTransferPending,
                          GetSQLDateTime(task.rampTime), task.batchSize,
                          task.duration, task.frequency, task.recurring,
                          (int)task.rampType, task.gradient);
    txnquery->SQL->Text = sql_statement;
    txnquery->Open();

    UdTransferTask newTask( task );
    if( !txnquery->Eof )
    {
        newTask.id = txnquery->FieldByName("TRANSFER_NO")->AsInteger;

        m_tasksLock->Acquire();
        m_tasks.push_back( newTask );
        m_tasksLock->Release();

        if( !LaunchTask( newTask ) )
        {
            MERROR( "Failed to launch newly added task (" << newTask.id << ")" );
        }
    }
    else
    {
        MERROR( "Failed to retrieve ID of added UD transfer task" );
    }

    delete txnquery;
}
//---------------------------------------------------------------------------

void UdTransferManager::LoadPendingTasks()
{
    TADOQuery * txnquery = new TADOQuery(NULL);
    if( txnquery == NULL ) return;

    txnquery->Connection = Data_Module->IntegrationDBConnection;

    AnsiString sql_statement;
    sql_statement.sprintf("select TRANSFER_NO, BATCH_SIZE, DURATION, FREQUENCY, "
                          "       RECURRING, SOURCE_PATH, RAMP_TIME, RAMP_TYPE, "
                          "       RAMP_GRADIENT, STATUS, DESTINATION "
                          "from   TRANSFER_HISTORY "
                          "where  STATUS = %d and "
                          "       USERNAME = '%s' and "
                          "       HOSTNAME = '%s' ",
                          (int)UdTransferPending,
                          m_username,
                          m_hostname);
    txnquery->SQL->Text = sql_statement;
    txnquery->Open();

    UdTransferTask task;
    while( !txnquery->Eof )
    {
        task.id                 = txnquery->FieldByName("TRANSFER_NO")->AsInteger;
        task.batchSize      = txnquery->FieldByName("BATCH_SIZE")->AsInteger;
        task.duration       = txnquery->FieldByName("DURATION")->AsInteger;
        task.frequency      = txnquery->FieldByName("FREQUENCY")->AsInteger;
        task.recurring      = (txnquery->FieldByName("RECURRING")->AsInteger > 0);
        task.sourcePath     = txnquery->FieldByName("SOURCE_PATH")->AsString;
        task.rampTime       = txnquery->FieldByName("RAMP_TIME")->AsDateTime;
        task.rampType       = (RampTestType)txnquery->FieldByName("RAMP_TYPE")->AsInteger;
        task.gradient       = txnquery->FieldByName("RAMP_GRADIENT")->AsFloat;
        task.state          = (UdTransferTaskState)txnquery->FieldByName("STATUS")->AsInteger;
        task.destination    = txnquery->FieldByName("DESTINATION")->AsString;

        m_tasksLock->Acquire();
        m_tasks.push_back( task );
        m_tasksLock->Release();
        
        txnquery->Next();
    }

    delete txnquery;

    if( !m_tasks.empty() )
    {
        // Ask user to start any previously pending tasks

        AnsiString msg;
        if( m_tasks.size() == 1 )
        {
            msg = "There is a UD task currently pending. Do you want to start it now?";
        }
        else
        {
            msg = "There are " + IntToStr(m_tasks.size()) + " UD transfer tasks currently pending.";
            msg += "\nDo you want to start them now?";
        }

        if( MessageDlg(msg, mtConfirmation, TMsgDlgButtons() << mbYes << mbNo, 0 ) == mbYes )
        {
            m_tasksLock->Acquire();
            try {
                UdTransferTaskItem it = m_tasks.begin();
                for( ; it != m_tasks.end(); it++ )
                {
                    if( (*it).state == UdTransferPending )
                    {
                        LaunchTask( (*it) );
                    }
                }
            }
            __finally
            {
                m_tasksLock->Release();
            }
        }
    }
}
//---------------------------------------------------------------------------

void UdTransferManager::UpdateTask( const UdTransferTask & task,
                                    const AnsiString & comment )
{
    // Find our locally stored task

    m_tasksLock->Acquire();
    try {
        UdTransferTaskItem it = m_tasks.begin();
        for( ; it != m_tasks.end(); it++ )
        {
            if( (*it).id == task.id ) break;
        }

        if( (it != m_tasks.end()) ) // TODO: && ((*it) != task) )
        {
            bool taskDone = (((*it).state > UdTransferAborted) &&
                             (task.state <= UdTransferAborted));

            TADOQuery * txnquery = new TADOQuery(NULL);
            if( txnquery == NULL ) return;

            txnquery->Connection = Data_Module->IntegrationDBConnection;

            // Find parameters that have changed and add them to the update query

            std::stringstream stream;
            stream << "update TRANSFER_HISTORY set ";
            if( (*it).batchSize != task.batchSize )     stream << " BATCH_SIZE = " << task.batchSize << ",";
            if( (*it).duration != task.duration )       stream << " DURATION = " << task.duration << ",";
            if( (*it).frequency != task.frequency )     stream << " FREQUENCY = " << task.frequency << ",";
            if( (*it).recurring != task.recurring )     stream << " RECURRING = " << task.recurring << ",";
            if( (*it).sourcePath != task.sourcePath )   stream << " SOURCE_PATH = '" << task.sourcePath.c_str() << "',";
            if( (*it).destination != task.destination ) stream << " DESTINATION = '" << task.destination.c_str() << "',";
            if( (*it).state != task.state )             stream << " STATUS = " << task.state << ",";
            if( (*it).rampType != task.rampType )       stream << " RAMP_TYPE = " << task.rampType << ",";
            if( (*it).gradient != task.gradient )       stream << " RAMP_GRADIENT = " << task.gradient << ",";
            if( (*it).rampTime != task.rampTime )       stream << " RAMP_TIME = " << GetSQLDateTime(task.rampTime).c_str() << ",";
            if( !comment.IsEmpty() )                    stream << " COMMENTS = '" << comment.c_str() << "',";
            if( taskDone )                              stream << " END_TIME = sysdate,";

            AnsiString sql_statement, temp;
            temp = stream.str().c_str();
            temp.Delete(temp.Length(), 1); // Remove last comma

            sql_statement.sprintf("%s where TRANSFER_NO = %d",
                                    temp, task.id);

            txnquery->SQL->Text = sql_statement;
            if( txnquery->ExecSQL()!= 1 )
            {
                MERROR( "Failed to update transfer history on statement: " << sql_statement );
            }

            delete txnquery;
            (*it) = task;

            if( taskDone )
            {
                m_tasks.erase( it );

                UdTransferThreadItem thread = m_threads.find( task.id );
                if( thread != m_threads.end() )
                {
                    (*thread).second->StopTransfer();
                }
            }
        }
    }
    __finally
    {
        m_tasksLock->Release();
    }

    UdTransferHistoryForm->RefreshHistory();
}
//---------------------------------------------------------------------------

bool UdTransferManager::GetTaskDetails( UdTransferTask & task )
{
    bool found = false;

    m_tasksLock->Acquire();
    try {
        UdTransferTaskItem it = m_tasks.begin();
        for( ; it != m_tasks.end(); it++ )
        {
            if( (*it).id == task.id )
            {
                found = true;
                task = (*it);
                break;
            }
        }
    }
    __finally
    {
        m_tasksLock->Release();
    }

    return found;
}
//---------------------------------------------------------------------------

bool UdTransferManager::LaunchTask( const UdTransferTask & task )
{
    bool launched = false;

    // Ensure we haven't already got a thread for this task

    UdTransferThreadItem thread = m_threads.find( task.id );
    if( thread == m_threads.end() )
    {
        m_threads[task.id] = new UdTransferThread( task, this, m_deviceSimulatorFactory );
        launched = true;
    }

    return launched;
}
//---------------------------------------------------------------------------

bool UdTransferManager::GetTaskStatistics( const int & taskId,
                                           UdTransferStatistics & stats )
{
    bool found = false;

    // Check if we are currently processing the device, if so
    // request the stats from the task thread

    UdTransferThreadItem thread = m_threads.find( taskId );
    if( thread != m_threads.end() )
    {
        if( (*thread).second != NULL )
        {
            (*thread).second->GetTransferStatistics( stats );
            found = true;
        }
    }

    // Otherwise grab the info from the database

    if( !found )
    {
        TADOQuery * txnquery = new TADOQuery(NULL);
        if( txnquery == NULL ) return false;

        txnquery->Connection = Data_Module->IntegrationDBConnection;

        AnsiString sql_statement;
        sql_statement.sprintf("select ADDED_TIME, END_TIME, NUMBER_FILES, NUMBER_BYTES, BATCH_HISTORY "
                              "from   TRANSFER_HISTORY "
                              "where  TRANSFER_NO = %d",
                              taskId);
        txnquery->SQL->Text = sql_statement;
        txnquery->Open();

        if( !txnquery->Eof )
        {
            stats.completed  = true;
            stats.startTime = txnquery->FieldByName("ADDED_TIME")->AsDateTime;
            stats.processedFiles = txnquery->FieldByName("NUMBER_FILES")->AsInteger;
            stats.processedBytes = txnquery->FieldByName("NUMBER_BYTES")->AsInteger;

            // End time may not be populated in times of program crashes. Ignore the
            // problem here and handle it when the statistics get used.
            try
            {
                stats.endTime = txnquery->FieldByName("END_TIME")->AsDateTime;
            }
            catch( EDatabaseError & e ) { }

            AnsiString batches = txnquery->FieldByName("BATCH_HISTORY")->AsString;
            if( !batches.IsEmpty() &&
                (batches != "(null)") )
            {
                // Tokenise our batch history string to our list

                TStringList * list = new TStringList;
                try {
                    if( list != NULL )
                    {
                        try {
                            list->CommaText = batches;
                            for( int i = 0; i < list->Count; i++ )
                            {
                                stats.batches.push_back( list->Strings[i].ToInt() );
                            }
                        }
                        catch( EConvertError & e ) {} // Ignore
                    }
                }
                __finally
                {
                    delete list;
                }
            }
            found = true;
        }
        delete txnquery;
    }

    return found;
}
//---------------------------------------------------------------------------

void UdTransferManager::UpdateTaskStatistics( const int & taskId,
                                              const UdTransferStatistics & stats )
{
    // Format the batches list into a comma delimited string

    AnsiString batches;
    BatchSizeItem batch = (int *)stats.batches.begin();
    for( ; batch != stats.batches.end(); batch++ )
    {
        if( batch != stats.batches.begin() ) batches += ",";
        batches += IntToStr( *batch );
    }

    TADOQuery * txnquery = new TADOQuery(NULL);
    if( txnquery == NULL ) return;

    txnquery->Connection = Data_Module->IntegrationDBConnection;

    AnsiString sql_statement;
    sql_statement.sprintf("update TRANSFER_HISTORY set "
                          "       NUMBER_FILES = %d, "
                          "       NUMBER_BYTES = %d, "
                          "       BATCH_HISTORY = '%s' "
                          "where  TRANSFER_NO = %d",
                          stats.processedFiles,
                          stats.processedBytes,
                          batches,
                          taskId);
    txnquery->SQL->Text = sql_statement;
    if( txnquery->ExecSQL() != 1 )
    {
        MERROR( "Failed to persist transfer statistics to database for task " << taskId );
    }
    txnquery->Close();
    delete txnquery;

    UdTransferHistoryForm->RefreshHistory();
}
//---------------------------------------------------------------------------

bool UdTransferManager::IsTaskRunning()
{
    bool running = false;

    UdTransferThreadItem thread = m_threads.begin();
    for( ; thread != m_threads.end(); thread++ )
    {
        if( ((*thread).second != NULL) &&
            (*thread).second->IsRunning() )
        {
            running = true;
            break;
        }
    }

    return running;
}