icputils.h

Go to the documentation of this file.

#ifndef ICPUTILS_H
#define ICPUTILS_H

#include "IsisBase.h"
#include "isisvme_types.h"
#include "DAEstatus.h"

std::string convertLatin1ToUTF8(const std::string& latin_string);
std::string convertWindows1252ToUTF8(const std::string& win_string);

extern SECURITY_ATTRIBUTES* defaultNoInheritHandles();

class Win32Exception : public std::runtime_error
{
public:
        explicit Win32Exception(const std::string& message) : std::runtime_error(win32_message(message, GetLastError())) { }
        explicit Win32Exception(const std::string& message, DWORD code) : std::runtime_error(win32_message(message, code)) { }
private:
        static std::string win32_message(const std::string& message, DWORD code)
        {
                std::string s(message);
                s.append(": ");
        LPTSTR errMsg;
                FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER 
                   | FORMAT_MESSAGE_FROM_SYSTEM 
                   | FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL,
                  code,
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR) &errMsg,
                  0,
                  NULL);
                s.append(errMsg);
        LocalFree((LPVOID)errMsg);
                return s;
        }
};

class Win32StructuredException : public std::runtime_error
{
public:
        explicit Win32StructuredException(const std::string& message) : std::runtime_error(message) { }
        explicit Win32StructuredException(unsigned int code, EXCEPTION_POINTERS *pExp) : std::runtime_error(win32_message(code, pExp)) { }
private:
        static std::string win32_message(unsigned int code, EXCEPTION_POINTERS * pExp)
        {
                char buffer[256];
                _snprintf(buffer, sizeof(buffer), "Win32StructuredException code 0x%x pExpCode 0x%x pExpAddress %p", code, pExp->ExceptionRecord->ExceptionCode, pExp->ExceptionRecord->ExceptionAddress);
                buffer[sizeof(buffer)-1] = '\0';
                return std::string(buffer);
        }
};

class CRTLException : public std::runtime_error
{
public:
        explicit CRTLException(const std::string& message) : std::runtime_error(crtl_message(message, errno)) { }
        explicit CRTLException(const std::string& message, int code) : std::runtime_error(crtl_message(message, code)) { }
private:
        static std::string crtl_message(const std::string& message, int code)
        {
                std::string s(message);
                s.append(": ");
                s.append(strerror(code));
        }
};

class WinsockException : public std::runtime_error
{
public:
        explicit WinsockException(const std::string& message) : std::runtime_error(win32_message(message, WSAGetLastError())) { }
        explicit WinsockException(const std::string& message, DWORD code) : std::runtime_error(win32_message(message, code)) { }
private:
        static std::string win32_message(const std::string& message, DWORD code)
        {
                std::string s(message);
                s.append(": ");
        LPTSTR errMsg;
                FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER 
                   | FORMAT_MESSAGE_FROM_SYSTEM 
                   | FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL,
                  code,
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR) &errMsg,
                  0,
                  NULL);
                s.append(errMsg);
        LocalFree((LPVOID)errMsg);
                return s;
        }
};

void getConfigStringList(std::vector<std::string>& string_list, const std::string& config_item);
void getConfigIntList(std::vector<int>& int_list, const std::string& config_item);

static void RetryWIN32APIBOOL(boost::function<BOOL()> func, int nretry)
{
        BOOL ret = TRUE;
        for( ; ( (ret = func()) == FALSE ) && (nretry >= 0); --nretry)
        {
                Sleep(100);
        }
        if (ret == FALSE)
        {
                throw Win32Exception("RetryWIN32APIBOOL");
        }
}

class ThreadPriorityRaiser
{
private:
        int m_old_prio;

public:
        ThreadPriorityRaiser(int prio = THREAD_PRIORITY_ABOVE_NORMAL)
        {
                m_old_prio = GetThreadPriority(GetCurrentThread());
                if (m_old_prio == THREAD_PRIORITY_ERROR_RETURN)
                {
                        throw std::runtime_error("GetThreadPriority");
                }
                if (SetThreadPriority(GetCurrentThread(), prio) == 0)
                {
                        throw Win32Exception("SetThreadPriority");
                }
        }

        void revertPriority()
        {
                if (SetThreadPriority(GetCurrentThread(), m_old_prio) == 0)
                {
                        throw Win32Exception("SetThreadPriority");
                }
        }

        ~ThreadPriorityRaiser()
        {
                revertPriority();
        }
};

class ICPClock : public ISIS::Base
{
private:
        LARGE_INTEGER m_proc_freq, m_perf_counter;
        FILETIME m_filetime;
        double m_perf_to_ft;

public:
        ICPClock()
        {
                setLoggerName("ICPClock");
                syncToSystemTime();
        }

        void syncToSystemTime()
        {
                if (QueryPerformanceCounter(&m_perf_counter) == 0)
                {
                        throw Win32Exception("QueryPerformanceCounter");
                }
                GetSystemTimeAsFileTime(&m_filetime);
                if (QueryPerformanceFrequency(&m_proc_freq) == 0)  // counts per second
                {
                        throw Win32Exception("QueryPerformanceFrequency");
                }
                m_perf_to_ft = (double)m_proc_freq.QuadPart / 10000000.0; // convert to 100ns for FILETIME
        }

        void setParameters(LONGLONG perf_counter, LONGLONG proc_freq, FILETIME filetime)
        {
                // proc_freq == 0 if we are startiong from scratch e.g. 
                if ( (proc_freq != 0) && (proc_freq != m_proc_freq.QuadPart) )
                {
                        LOGSTR_ERROR("ICPClock proc frequency mismatch: " << proc_freq << " != " << m_proc_freq.QuadPart);
                        m_proc_freq.QuadPart = proc_freq;
                }
                m_filetime = filetime;
                m_perf_counter.QuadPart = perf_counter;
                m_perf_to_ft = (double)m_proc_freq.QuadPart / 10000000.0; // convert to 100ns for FILETIME
        }

        void getParameters(LONGLONG& perf_counter, LONGLONG& proc_freq, FILETIME& filetime)
        {
                filetime = m_filetime;
                proc_freq = m_proc_freq.QuadPart;
                perf_counter = m_perf_counter.QuadPart;
        }

        void getCurrentTimeAsFiletime(FILETIME& ft)
        {
                LARGE_INTEGER perf_counter, perf_elapsed;
                ULONGLONG filetime_elapsed;
                ULARGE_INTEGER ft_ul;
                // need to look at setting thread affinity mask
                if (QueryPerformanceCounter(&perf_counter) == 0)
                {
                        throw Win32Exception("QueryPerformanceCounter");
                }
                perf_elapsed.QuadPart = perf_counter.QuadPart - m_perf_counter.QuadPart;
                filetime_elapsed = static_cast<ULONGLONG>(0.5 + (double)perf_elapsed.QuadPart / m_perf_to_ft);
                ft_ul.LowPart = m_filetime.dwLowDateTime;
                ft_ul.HighPart = m_filetime.dwHighDateTime;
                ft_ul.QuadPart += filetime_elapsed;
                ft.dwLowDateTime = ft_ul.LowPart;
                ft.dwHighDateTime = ft_ul.HighPart;
        }

        void getCurrentTimeFromEpoch(time_t& tt)
        {
                FILETIME ft;
                getCurrentTimeAsFiletime(ft);
                tt = Poco::Timestamp::fromFileTimeNP(ft.dwLowDateTime, ft.dwHighDateTime).epochTime();
        }
};

extern Poco::SingletonHolder<ICPClock> g_icp_clock;

template <typename T>
struct ValueWithTimestamp
{
        T value;
        Poco::Timestamp time;

        Poco::Timestamp::TimeDiff timeDiff(const ValueWithTimestamp& v)
        {
                return time - v.time;
        }
        T valueDiff(const ValueWithTimestamp& v)
        {
                return value - v.value;
        }
};

class ICPTimer
{
private:
        std::string m_title;
        DAEstatus* m_status;
        struct timeb m_tb;
        SYSTEMTIME m_st;
        Poco::Timestamp m_ts;
        struct timings_t
        {
                FILETIME create;
                FILETIME exit;
                FILETIME kernel;
                FILETIME user;
        };
        timings_t m_thread_times;
        timings_t m_process_times;

public:
        ICPTimer();
        ICPTimer(const char* title, DAEstatus& status);
        ~ICPTimer();
        void start(const char* title = NULL);
        double info(const char* title, std::ostream& os, bool add_nl = true);
        double info(const char* title, DAEstatus& status);
        double info(const std::string& title, DAEstatus& status) { return info(title.c_str(), status); }
};

inline std::string padWithZeros(int number, int len)
{
        std::vector<char> buffer(len+1);
        char* bdata = buffer.data();
        if ( _snprintf(bdata, len+1, "%0*d", len, number) < 0 )
        {
                memset(bdata, '#', len);
        }
        bdata[len] = '\0';
        return bdata;
}

std::string fileNameFromMappedView(void* pMem);
void printComputerMemoryStats(DAEstatus& status);
void registerExtraLoggerChannels();
void setICPChannelReporter(DAEreport_func_t* report_func, void* report_arg);
int loadAppConfig(const std::string& app_name);
int removeWithRetry(const char* filename);

int createEmptyFileAndClose(const std::string& file_name, size_t file_size);
HANDLE createEmptyFile(const std::string& file_name, size_t file_size);
int compareBuffers(const std::string& title, const isisU32_t* buffer1, const isisU32_t* buffer2, int nbuffer, DAEstatus& status);

template <typename T>
void findConsecutive(const std::vector<T>& vec, T invalid_val, std::vector<int>& indexes, std::vector<int>& sizes);

int sendSMS(const std::string& phone, const std::string& message, DAEstatus& status);
int sendEmail(const std::string& sender, const std::string& recipient, const std::string& subject, const std::string& content, DAEstatus& status);

void pollUntilTasksComplete(const Poco::TaskManager& tm, int poll_time_in_ms);

int findFiles(const char* directory, const char* pattern, std::vector<std::string>& list, bool full_path = true);

void AddEventSource( PCTSTR pszName, PCTSTR pszMessageFile, DWORD dwCategoryCount);

std::string unescapeXML(const char* xml_str);
std::string escapeXML(const char* xml_str);

typedef unsigned char md5checksum_t[16];
int md5sumFile(const char* filename, unsigned char* md5sum, DAEstatus& status);
int md5sumString(const void* buffer, int len, unsigned char* md5sum, DAEstatus& status);
bool compareChecksums(const unsigned char* md5sum1, const unsigned char* md5sum2);
int updateChecksum(unsigned char* md5sum1, const unsigned char* md5sum2);
int parseSpectraRange(const std::string& spec_range, int& spec_from, int& spec_to);
std::string checksumAsString(md5checksum_t checksum);

typedef void (*overlap_complete_func_t)(void* arg);

void appendToFileAsync(const char* filename, const char* message);
void appendToFileAsync(HANDLE h, const char* message, bool close_after_write = false);
HANDLE createAppendFile(const char* filename);

typedef struct {  
        ULONG i[2];  
        ULONG buf[4];  
        unsigned char in[64];  
        unsigned char digest[16];
} MD5_CTX;

typedef void  (__stdcall *MD5Init_t)(MD5_CTX *);

typedef void  (__stdcall *MD5Update_t)(MD5_CTX *, const unsigned char *, unsigned int);

typedef void  (__stdcall *MD5Final_t)(MD5_CTX *);

class ICPCritical
{
private:
        CRITICAL_SECTION* m_critical;
        volatile LONG m_lockcount;
        ICPCritical() : m_critical(NULL), m_lockcount(0) { }

public:
        ICPCritical(CRITICAL_SECTION* pCsect, bool locked = true) : m_critical(pCsect), m_lockcount(0)
        {
                if (pCsect == NULL)
                {
                        throw std::runtime_error("ICPcritical: NULL");
                }
                if (locked)
                {
                        lock();
                }
        }
        void lock() 
        {
                EnterCriticalSection(m_critical);
                InterlockedIncrement(&m_lockcount);
        }
        void unlock() 
        { 
                if (m_lockcount > 0) 
                {
                        InterlockedDecrement(&m_lockcount);
                        LeaveCriticalSection(m_critical);
                } 
        }
        ~ICPCritical() 
        { 
                if (m_critical != NULL) 
                { 
                        while(m_lockcount > 0)
                        {
                                unlock();
                        }
                        m_critical = NULL; 
                }
        }
};


extern Poco::Mutex* atomic_mutex;

// 0 on success, -1 on error
template<typename T>
int atomic_write(const std::string& filename, const std::string& old_suffix, const std::string& new_suffix, T* data, int n)
{
        Poco::Mutex::ScopedLock _lock(*atomic_mutex);
        std::string old_file = filename + old_suffix;
        std::string new_file = filename + new_suffix;
        FILE* f = _fsopen(new_file.c_str(), "wbcN", _SH_DENYWR);    // "c" forces commit to disk on fflush() 
        if (f == NULL)
        {
                Sleep(100);
                f = _fsopen(new_file.c_str(), "wbcN", _SH_DENYWR);
        }
        if (f != NULL)
        {
                if (std::fwrite(data, sizeof(T), n, f) != n)
                { 
                        std::fclose(f); 
                        std::remove(new_file.c_str()); 
                        throw std::runtime_error("cannot write data"); 
                }
                if (std::fflush(f) != 0)
                { 
                        std::fclose(f); 
                        std::remove(new_file.c_str()); 
                        throw std::runtime_error("cannot flush data"); 
                }
                if (std::fclose(f) != 0)
                { 
                        std::remove(new_file.c_str()); 
                        throw std::runtime_error("cannot close data"); 
                }
                if (access(old_file.c_str(), 0) == 0)
                {
                        RetryWIN32APIBOOL(boost::bind(DeleteFile, old_file.c_str()), 10);
                }
                if (access(filename.c_str(), 0) == 0)
                {
                        RetryWIN32APIBOOL(boost::bind(MoveFile, filename.c_str(), old_file.c_str()), 10);
                }
                RetryWIN32APIBOOL(boost::bind(MoveFile, new_file.c_str(), filename.c_str()), 10);
                return 0;
        }
        else
        {
                throw std::runtime_error("atomic:write: cannot open file");
                return -1;
        }
}

// 0 on success, -1 on error
extern int flushed_write(const std::string& file, const void* data, int nbytes);

// 0 on success, -1 on error
template<typename T>
int atomic_read(const std::string& filename, const std::string& old_suffix, T* data, size_t n)
{
        Poco::Mutex::ScopedLock _lock(*atomic_mutex);
        std::string old_file = filename + old_suffix;
        FILE* f = _fsopen(filename.c_str(), "rbN", _SH_DENYNO);
        if (f == NULL)
        {
                f = _fsopen(old_file.c_str(), "rbN", _SH_DENYNO);
        }
        if (f != NULL)
        {
                size_t nread = fread(data, sizeof(T), n, f);
                fclose(f);
                if (nread == n)
                {
                        return 0;
                }
                else
                {
                        return -1;
                }
        }
        else
        {
                return -1;
        }
}

off_t file_size_bytes(const std::string& filename);
int64_t fileSizeBytes(const std::string& filename);



template <typename T>
inline size_t array_length(const T& /*data*/) 
{
        return boost::extent<T>::value;
}

LONGLONG diffFileTimes(const FILETIME& start, const FILETIME& finish);
double diffFileTimesInMilliSec(const FILETIME& start, const FILETIME& finish);

template<typename T1, typename T2> 
struct pair_second
{
        static const T2& second(const std::pair<T1, T2>& p)
        { 
                return p.second; 
        }
        typedef const T2& (*second_t)(const std::pair<T1, T2>& p); 
};

//
//template <typename Key, typename T>
//boost::transform_iterator< typename pair_second<Key,T>::second_t, typename std::map<Key,T>::const_iterator >& value_iterator(typename std::map<Key,T>::const_iterator& iter)
//{
//      return boost::make_transform_iterator(iter, pair_second<Key,T>::second);
//}

template <typename T>
class sum_values
{
        private:
                T sum;
        public:
                sum_values() : sum(0) { }
                void operator()(const T& val) { sum += val; }
                operator T() { return sum; }
};

template <typename T, typename U>
U sum_map_values(const std::map<T,U>& m)
{
        class sum_map_values_impl
        {
                private:
                        U sum;
                public:
                        sum_map_values_impl() : sum(0) { }
                        void operator()(const typename std::map<T,U>::value_type& p) { sum += p.second; }
                        operator U() { return sum; }
        };
        return std::for_each(m.begin(), m.end(), sum_map_values_impl());
}


template<typename T>
class GenericTask : public Poco::Task, ISIS::Base
{
        Poco::SharedPtr<Poco::Event> m_finish_event;
        typedef boost::function<T()> func_t;
        func_t m_func;

public:
        GenericTask(const std::string& name, Poco::SharedPtr<Poco::Event> finish_event, const func_t& func) : Poco::Task(name), Base("GenericTask"), m_finish_event(finish_event), m_func(func)  { }

        void runTask()
        {
                LOGSTR_DEBUG("Starting task " << name() << " thread id " << Poco::Thread::currentTid());
                m_func();
                m_finish_event->set();
//              setProgress(0.5);
//              if (isCancelled())
//              {
//                      return;
//              }
//              if (sleep(100))  // sleep returns true if we are cancelled
//              {
//                      return;
//              }
                LOGSTR_DEBUG("Terminating task " << name() << " thread id " << Poco::Thread::currentTid());
        }

        void cancel()
        {
                Poco::Task::cancel();
        }
};


class GenericProgressHandler
{
public:
        void onProgress(Poco::TaskProgressNotification* pNf)
        {
                pNf->release();
        }

        void onFinished(Poco::TaskFinishedNotification* pNf)
        {
                pNf->task()->name();
                pNf->release();
        }
};

template <class T>
class GenericWorkNotification : public Poco::Notification
{
private:
        T* m_data;
public:
        GenericWorkNotification(T* data) : m_data(data) { }
        T* data()
        {
                return m_data;
        }
};

template <class T>
class GenericWorker : public Poco::Runnable, ISIS::Base
{
private:
        GenericWorker() : Base("GenericWorker") { }
        Poco::NotificationQueue& m_queue;
public:
        GenericWorker(Poco::NotificationQueue& queue) : Base("GenericWorker"), m_queue(queue) { }
        virtual void run()
        {
                LOGSTR_DEBUG("Creating GenericWorker thread id " << Poco::Thread::currentTid());
                Poco::AutoPtr<Poco::Notification> pNf(m_queue.waitDequeueNotification());
                while(pNf)
                {
                        GenericWorkNotification<T>* pWorkNf = dynamic_cast<GenericWorkNotification<T>*>(pNf.get());
                        if (pWorkNf)
                        {
                                doWork(pWorkNf->data());
                        }
                        pNf = m_queue.waitDequeueNotification();
                }
                LOGSTR_DEBUG("Terminating GenericWorker thread id " << Poco::Thread::currentTid());
        }

        virtual void doWork(T* data) = 0;
};

#if 0
        WriteFileProgressHandler ph;
        m_taskmgr.addObserver(Poco::Observer<WriteFileProgressHandler, Poco::TaskProgressNotification>(ph, &WriteFileProgressHandler::onProgress));
        m_taskmgr.addObserver(Poco::Observer<WriteFileProgressHandler, Poco::TaskFinishedNotification>(ph, &WriteFileProgressHandler::onFinished));
        m_taskmgr.start(new WriteFileTask("write 1"));
        m_taskmgr.joinAll();
        Poco::NotificationQueue nq;
        Worker w1(nq);
        Poco::ThreadPool::defaultPool().start(w1);
        nq.enqueueNotification(new WorkNotification());
        while(!nq.empty())
        {
                Poco::Thread::sleep(100);
        }
        nq.wakeUpAll();  // tell them they are done - only works of queue is empty
        Poco::ThreadPool::defaultPool().joinAll();
        return 0;
#endif


//      Poco::ActiveMethod<int, uint32_t, DetectorCard> flushEvents;
//      int flushEventsImpl(const uint32_t last_address_read);

template <typename R>
class ActiveObject
{
public:
        typedef boost::function<R()> func_t;
    ActiveObject() : run(this, &ActiveObject::runImpl)
    {
    }

    Poco::ActiveMethod<R, func_t, ActiveObject> run;

private:
    R runImpl(const func_t& arg)
    {
        return arg();
    }
};

class ScopedSemaphore
{
private:
        Poco::Semaphore* m_sem;
        void operator=(const Poco::Semaphore&) { throw std::runtime_error("ScopedSemaphore"); }
        ScopedSemaphore(const Poco::Semaphore&) : m_sem(NULL) { throw std::runtime_error("ScopedSemaphore"); }

public:
        ScopedSemaphore(Poco::Semaphore& sem) : m_sem(&sem) { m_sem->wait(); }
        ~ScopedSemaphore() { m_sem->set(); }
};


template <typename T>
class SimpleStore
{
private:
        Poco::Mutex m_mutex;
        typedef typename std::list<T*> list_t;
        list_t m_vals;
public:
        T* get()
        {
                Poco::Mutex::ScopedLock _lock(m_mutex);
                if (m_vals.empty())
                {
                        return new T;
                }
                else
                {
                        T* ret = m_vals.back();
                        m_vals.pop_back();
                        return ret;
                }
        }
        void put(T* val)
        {
                Poco::Mutex::ScopedLock _lock(m_mutex);
                m_vals.push_back(val);
        }
        void clear()
        {
                Poco::Mutex::ScopedLock _lock(m_mutex);
                for(list_t::iterator it = m_vals.begin(); it != m_vals.end(); ++it)
                {
                        delete *it;
                }
                m_vals.clear();
        }
        ~SimpleStore()
        {
                clear();
        }
};


#if 0

template<typename T>
class poco_mempool_allocator
{
public:
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T value_type;
        template <class U> struct rebind {
                typedef poco_mempool_allocator<U> other;
        };
        poco_mempool_allocator() throw() { }
        poco_mempool_allocator(const poco_mempool_allocator&) throw() { }
        template<class U> poco_mempool_allocator(const poco_mempool_allocator<U>&) throw() { }
        ~poco_mempool_allocator() throw() { }
        pointer address(reference x) const { return &x; }
        const_pointer address(const_reference x) const { return &x; }
        pointer allocate(size_type n, void* hint = 0)
        {
                return static_cast<T*>(n*sizeof(T));
        }
        void deallocate(pointer p, size_type n) { }
        size_type max_size() const throw() { return bytes / sizeof(T); }
        void construct(pointer p, const T& val)
        {
                new(static_cast<void*>(p)) T(val);
        }
        void destroy(pointer p)
        {
                p->~T();
        }
};

template<typename T>
bool operator==(const poco_mempool_allocator<T>&, const poco_mempool_allocator<T>&)
{
        return true;
}

template<typename T>
bool operator!=(const poco_mempool_allocator<T>&, const poco_mempool_allocator<T>&)
{
        return false;
}

template<>
class poco_mempool_allocator<void>
{
public:
        typedef void* pointer;
        typedef const void* const_pointer;
        typedef void value_type;
        template <class U> struct rebind {
                typedef poco_mempool_allocator<U> other;
        }
};
#endif /* if 0 */

#endif /* ICPUTILS_H */