From 9845d2476c05c14226ab2456dcc4636677f34897 Mon Sep 17 00:00:00 2001 From: Henri Herscher Date: Wed, 6 Jun 2007 13:43:28 +0000 Subject: Enhanced configurable tape file naming and added configurable tape path naming support. git-svn-id: https://oreka.svn.sourceforge.net/svnroot/oreka/trunk@443 09dcff7a-b715-0410-9601-b79a96267cd0 --- orkaudio/BatchProcessing.cpp | 6 +- orkbasecxx/AudioCapture.cpp | 12 ++ orkbasecxx/AudioCapture.h | 4 + orkbasecxx/AudioTape.cpp | 469 ++++++++++++++++++++++++++++++++++++++++++- orkbasecxx/AudioTape.h | 54 +++++ orkbasecxx/Config.cpp | 3 +- orkbasecxx/Config.h | 4 +- 7 files changed, 538 insertions(+), 14 deletions(-) diff --git a/orkaudio/BatchProcessing.cpp b/orkaudio/BatchProcessing.cpp index 6b9bf68..3a720dd 100644 --- a/orkaudio/BatchProcessing.cpp +++ b/orkaudio/BatchProcessing.cpp @@ -242,7 +242,11 @@ void BatchProcessing::ThreadHandler(void *args) throw(debug); } } - CStdString file = CONFIG.m_audioOutputPath + "/" + audioTapeRef->GetPath() + audioTapeRef->GetIdentifier(); + + CStdString path = CONFIG.m_audioOutputPath + "/" + audioTapeRef->GetPath(); + FileRecursiveMkdir(path); + + CStdString file = path + "/" + audioTapeRef->GetIdentifier(); outFileRef->Open(file, AudioFile::WRITE, false, fileRef->GetSampleRate()); } if(voIpSession) diff --git a/orkbasecxx/AudioCapture.cpp b/orkbasecxx/AudioCapture.cpp index 20aa0d7..706c657 100644 --- a/orkbasecxx/AudioCapture.cpp +++ b/orkbasecxx/AudioCapture.cpp @@ -186,6 +186,18 @@ CaptureEvent::CaptureEvent() m_type = EtUnknown; } +CStdString CaptureEvent::DirectionToShortString(int direction) +{ + switch(direction) + { + case DirIn: + return DIR_IN_SHORT; + case DirOut: + return DIR_OUT_SHORT; + } + return DIR_UNKN_SHORT; +} + CStdString CaptureEvent::DirectionToString(int direction) { switch(direction) diff --git a/orkbasecxx/AudioCapture.h b/orkbasecxx/AudioCapture.h index cb4cfc0..1d6ae78 100644 --- a/orkbasecxx/AudioCapture.h +++ b/orkbasecxx/AudioCapture.h @@ -107,12 +107,16 @@ public: #define DIR_IN "in" #define DIR_OUT "out" #define DIR_UNKN "unkn" +#define DIR_IN_SHORT "I" +#define DIR_OUT_SHORT "O" +#define DIR_UNKN_SHORT "U" typedef enum { DirIn = 0, DirOut = 1, DirUnkn = 2 } DirectionEnum; static CStdString DirectionToString(int); + static CStdString DirectionToShortString(int direction); static int DirectionToEnum(CStdString& dir); #define ET_UNKNOWN "unknown" diff --git a/orkbasecxx/AudioTape.cpp b/orkbasecxx/AudioTape.cpp index 593f7c3..c54e8ca 100644 --- a/orkbasecxx/AudioTape.cpp +++ b/orkbasecxx/AudioTape.cpp @@ -346,11 +346,191 @@ void AudioTape::PopulateTapeMessage(TapeMsg* msg, CaptureEvent::EventTypeEnum ev void AudioTape::GenerateCaptureFilePathAndIdentifier() { struct tm date = {0}; + ACE_OS::localtime_r(&m_beginDate, &date); int month = date.tm_mon + 1; // january=0, decembre=11 int year = date.tm_year + 1900; + m_filePath.Format("%.4d/%.2d/%.2d/%.2d/", year, month, date.tm_mday, date.tm_hour); + m_fileIdentifier.Format("%.4d%.2d%.2d_%.2d%.2d%.2d_%s", year, month, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec, m_portId); + + m_year.Format("%.4d", year); + m_day.Format("%.2d", date.tm_mday); + m_month.Format("%.2d", month); + m_hour.Format("%.2d", date.tm_hour); + m_min.Format("%.2d", date.tm_min); + m_sec.Format("%.2d", date.tm_sec); +} + +void AudioTape::GenerateFinalFilePath() +{ + if(CONFIG.m_tapePathNaming.size() > 0) + { + CStdString pathIdentifier; + std::list::iterator it; + + for(it = CONFIG.m_tapePathNaming.begin(); it != CONFIG.m_tapePathNaming.end(); it++) + { + CStdString element = *it; + int tapeAttributeEnum = TapeAttributes::TapeAttributeToEnum(element); + + switch(tapeAttributeEnum) { + case TapeAttributes::TaNativeCallId: + { + if(m_nativeCallId.size() > 0) + { + pathIdentifier += m_nativeCallId; + } + else + { + pathIdentifier += "nonativecallid"; + } + break; + } + case TapeAttributes::TaTrackingId: + { + if(m_trackingId.size() > 0) + { + pathIdentifier += m_trackingId; + } + else + { + pathIdentifier += "notrackingid"; + } + break; + } + case TapeAttributes::TaDirection: + { + pathIdentifier += CaptureEvent::DirectionToString(m_direction); + break; + } + case TapeAttributes::TaShortDirection: + { + pathIdentifier += CaptureEvent::DirectionToShortString(m_direction); + break; + } + case TapeAttributes::TaRemoteParty: + { + if(m_remoteParty.size() > 0) + { + pathIdentifier += m_remoteParty; + } + else + { + pathIdentifier += "noremoteparty"; + } + break; + } + case TapeAttributes::TaLocalParty: + { + if(m_localParty.size() > 0) + { + pathIdentifier += m_localParty; + } + else + { + pathIdentifier += "nolocalparty"; + } + break; + } + case TapeAttributes::TaLocalEntryPoint: + { + if(m_localEntryPoint.size() > 0) + { + pathIdentifier += m_localEntryPoint; + } + else + { + pathIdentifier += "nolocalentrypoint"; + } + break; + } + case TapeAttributes::TaLocalIp: + { + if(m_localIp.size() > 0) + { + pathIdentifier += m_localIp; + } + else + { + pathIdentifier += "nolocalip"; + } + break; + } + case TapeAttributes::TaRemoteIp: + { + if(m_remoteIp.size() > 0) + { + pathIdentifier += m_remoteIp; + } + else + { + pathIdentifier += "noremoteip"; + } + break; + } + case TapeAttributes::TaHostname: + { + char host_name[255]; + + memset(host_name, 0, sizeof(host_name)); + ACE_OS::hostname(host_name, sizeof(host_name)); + + if(strlen(host_name)) + { + pathIdentifier += host_name; + } + else + { + pathIdentifier += "nohostname"; + } + + break; + } + case TapeAttributes::TaYear: + { + pathIdentifier += m_year; + break; + } + case TapeAttributes::TaDay: + { + pathIdentifier += m_day; + break; + } + case TapeAttributes::TaMonth: + { + pathIdentifier += m_month; + break; + } + case TapeAttributes::TaHour: + { + pathIdentifier += m_hour; + break; + } + case TapeAttributes::TaMin: + { + pathIdentifier += m_min; + break; + } + case TapeAttributes::TaSec: + { + pathIdentifier += m_sec; + break; + } + case TapeAttributes::TaUnknown: + { + pathIdentifier += element; + break; + } + } + } + + if(pathIdentifier.size() > 0) + { + m_filePath = pathIdentifier; + } + } } void AudioTape::GenerateFinalFilePathAndIdentifier() @@ -360,42 +540,184 @@ void AudioTape::GenerateFinalFilePathAndIdentifier() // The config file specifies a naming scheme for the recordings, build the final file identifier CStdString fileIdentifier; std::list::iterator it; + for(it = CONFIG.m_tapeFileNaming.begin(); it != CONFIG.m_tapeFileNaming.end(); it++) { CStdString element = *it; - if(element.CompareNoCase("nativecallid") == 0) + int tapeAttributeEnum = TapeAttributes::TapeAttributeToEnum(element); + + switch(tapeAttributeEnum) { + case TapeAttributes::TaNativeCallId: { if(m_nativeCallId.size() > 0) + { + fileIdentifier += m_nativeCallId; + } + else + { + fileIdentifier += "nonativecallid"; + } + break; + } + case TapeAttributes::TaTrackingId: + { + if(m_trackingId.size() > 0) { - fileIdentifier += m_nativeCallId; + fileIdentifier += m_trackingId; } else { - fileIdentifier += "nonativecallid"; + fileIdentifier += "notrackingid"; } + break; } - else if (element.CompareNoCase("trackingid") == 0) + case TapeAttributes::TaDirection: + { + fileIdentifier += CaptureEvent::DirectionToString(m_direction); + break; + } + case TapeAttributes::TaShortDirection: { - if(m_trackingId.size() > 0) + fileIdentifier += CaptureEvent::DirectionToShortString(m_direction); + break; + } + case TapeAttributes::TaRemoteParty: + { + if(m_remoteParty.size() > 0) { - fileIdentifier += m_trackingId; + fileIdentifier += m_remoteParty; } else { - fileIdentifier += "notrackingid"; + fileIdentifier += "noremoteparty"; } + break; } - else + case TapeAttributes::TaLocalParty: { - fileIdentifier += element; + if(m_localParty.size() > 0) + { + fileIdentifier += m_localParty; + } + else + { + fileIdentifier += "nolocalparty"; + } + break; + } + case TapeAttributes::TaLocalEntryPoint: + { + if(m_localEntryPoint.size() > 0) + { + fileIdentifier += m_localEntryPoint; + } + else + { + fileIdentifier += "nolocalentrypoint"; + } + break; + } + case TapeAttributes::TaLocalIp: + { + if(m_localIp.size() > 0) + { + fileIdentifier += m_localIp; + } + else + { + fileIdentifier += "nolocalip"; + } + break; + } + case TapeAttributes::TaRemoteIp: + { + if(m_remoteIp.size() > 0) + { + fileIdentifier += m_remoteIp; + } + else + { + fileIdentifier += "noremoteip"; + } + break; + } + case TapeAttributes::TaHostname: + { + char host_name[255]; + + memset(host_name, 0, sizeof(host_name)); + ACE_OS::hostname(host_name, sizeof(host_name)); + + if(strlen(host_name)) + { + fileIdentifier += host_name; + } + else + { + fileIdentifier += "nohostname"; + } + + break; + } + case TapeAttributes::TaYear: + { + fileIdentifier += m_year; + break; + } + case TapeAttributes::TaDay: + { + fileIdentifier += m_day; + break; + } + case TapeAttributes::TaMonth: + { + fileIdentifier += m_month; + break; + } + case TapeAttributes::TaHour: + { + fileIdentifier += m_hour; + break; + } + case TapeAttributes::TaMin: + { + fileIdentifier += m_min; + break; + } + case TapeAttributes::TaSec: + { + fileIdentifier += m_sec; + break; + } + case TapeAttributes::TaUnknown: + { + std::map::iterator pair; + CStdString correctKey, mTagsValue; + + // Remove the [] + correctKey = element.substr(1, element.size()-2); + pair = m_tags.find(correctKey); + + if(pair != m_tags.end()) { + mTagsValue = pair->second; + fileIdentifier += mTagsValue; + } else { + fileIdentifier += element; + } + + break; + } } } + if(fileIdentifier.size() > 0) { m_fileIdentifier = fileIdentifier; } - m_filePath = ""; - CStdString path = CONFIG.m_audioOutputPath + "/"; + + GenerateFinalFilePath(); + + CStdString path = CONFIG.m_audioOutputPath + "/" + m_filePath + "/"; PreventFileIdentifierCollision(path, m_fileIdentifier , m_fileExtension); } } @@ -466,4 +788,129 @@ bool AudioTape::IsReadyForBatchProcessing() return false; } +//================================= + +CStdString TapeAttributes::TapeAttributeToString(int ta) +{ + switch(ta) { + case TaNativeCallId: + return TA_NATIVECALLID; + case TaTrackingId: + return TA_TRACKINGID; + case TaDirection: + return TA_DIRECTION; + case TaShortDirection: + return TA_SHORTDIRECTION; + case TaRemoteParty: + return TA_REMOTEPARTY; + case TaLocalParty: + return TA_LOCALPARTY; + case TaLocalEntryPoint: + return TA_LOCALENTRYPOINT; + case TaLocalIp: + return TA_LOCALIP; + case TaRemoteIp: + return TA_REMOTEIP; + case TaHostname: + return TA_HOSTNAME; + case TaYear: + return TA_YEAR; + case TaDay: + return TA_DAY; + case TaMonth: + return TA_MONTH; + case TaHour: + return TA_HOUR; + case TaMin: + return TA_MIN; + case TaSec: + return TA_SEC; + } + + return "[UnknownAttribute]"; +} + +int TapeAttributes::TapeAttributeToEnum(CStdString& ta) +{ + if(ta.CompareNoCase(TA_NATIVECALLID) == 0) + { + return TaNativeCallId; + } + if(ta.CompareNoCase(TA_TRACKINGID) == 0) + { + return TaTrackingId; + } + + if(ta.CompareNoCase(TA_DIRECTION) == 0) + { + return TaDirection; + } + + if(ta.CompareNoCase(TA_SHORTDIRECTION) == 0) + { + return TaShortDirection; + } + + if(ta.CompareNoCase(TA_REMOTEPARTY) == 0) + { + return TaRemoteParty; + } + + if(ta.CompareNoCase(TA_LOCALPARTY) == 0) + { + return TaLocalParty; + } + + if(ta.CompareNoCase(TA_LOCALENTRYPOINT) == 0) + { + return TaLocalEntryPoint; + } + + if(ta.CompareNoCase(TA_LOCALIP) == 0) + { + return TaLocalIp; + } + + if(ta.CompareNoCase(TA_REMOTEIP) == 0) + { + return TaRemoteIp; + } + + if(ta.CompareNoCase(TA_HOSTNAME) == 0) + { + return TaHostname; + } + + if(ta.CompareNoCase(TA_YEAR) == 0) + { + return TaYear; + } + + if(ta.CompareNoCase(TA_DAY) == 0) + { + return TaDay; + } + + if(ta.CompareNoCase(TA_MONTH) == 0) + { + return TaMonth; + } + + if(ta.CompareNoCase(TA_HOUR) == 0) + { + return TaHour; + } + + if(ta.CompareNoCase(TA_MIN) == 0) + { + return TaMin; + } + + if(ta.CompareNoCase(TA_SEC) == 0) + { + return TaSec; + } + + return TaUnknown; +} diff --git a/orkbasecxx/AudioTape.h b/orkbasecxx/AudioTape.h index 91ffccb..4cc6e3a 100644 --- a/orkbasecxx/AudioTape.h +++ b/orkbasecxx/AudioTape.h @@ -98,6 +98,7 @@ public: private: void GenerateCaptureFilePathAndIdentifier(); void GenerateFinalFilePathAndIdentifier(); + void GenerateFinalFilePath(); void PreventFileIdentifierCollision(CStdString& path, CStdString& identifier, CStdString& extension); void PopulateTapeMessage(TapeMsg* msg, CaptureEvent::EventTypeEnum eventType); @@ -105,6 +106,13 @@ private: CStdString m_fileIdentifier; CStdString m_fileExtension; //Corresponds to the extension the tape will have after compression + CStdString m_year; + CStdString m_day; + CStdString m_month; + CStdString m_hour; + CStdString m_min; + CStdString m_sec; + std::queue m_chunkQueue; std::queue m_eventQueue; @@ -122,5 +130,51 @@ private: typedef boost::shared_ptr AudioTapeRef; +//========================================================== + +class TapeAttributes +{ +public: +#define TA_NATIVECALLID "[nativecallid]" +#define TA_TRACKINGID "[trackingid]" +#define TA_DIRECTION "[direction]" +#define TA_SHORTDIRECTION "[shortdirection]" +#define TA_REMOTEPARTY "[remoteparty]" +#define TA_LOCALPARTY "[localparty]" +#define TA_LOCALENTRYPOINT "[localentrypoint]" +#define TA_LOCALIP "[localip]" +#define TA_REMOTEIP "[remoteip]" +#define TA_HOSTNAME "[hostname]" +#define TA_YEAR "[year]" +#define TA_DAY "[day]" +#define TA_MONTH "[month]" +#define TA_HOUR "[hour]" +#define TA_MIN "[min]" +#define TA_SEC "[sec]" + + typedef enum { + TaUnknown = 0, + TaNativeCallId = 1, + TaTrackingId = 2, + TaDirection = 3, + TaShortDirection = 4, + TaRemoteParty = 5, + TaLocalParty = 6, + TaLocalEntryPoint = 7, + TaLocalIp = 8, + TaRemoteIp = 9, + TaHostname = 10, + TaYear = 11, + TaDay = 12, + TaMonth = 13, + TaHour = 14, + TaMin = 15, + TaSec = 16 + } TapeAttributeEnum; + + static int TapeAttributeToEnum(CStdString& ta); + static CStdString TapeAttributeToString(int ta); +}; + #endif diff --git a/orkbasecxx/Config.cpp b/orkbasecxx/Config.cpp index d2400bb..e93a762 100644 --- a/orkbasecxx/Config.cpp +++ b/orkbasecxx/Config.cpp @@ -21,7 +21,7 @@ Config::Config() { m_log = log4cxx::Logger::getLogger("config"); - + m_serviceStartedTime = time(NULL); m_logMessages = LOG_MESSAGES_DEFAULT; m_logRms = LOG_RMS_DEFAULT; m_enableReporting = ENABLE_REPORTING_DEFAULT; @@ -94,6 +94,7 @@ void Config::Define(Serializer* s) s->IntValue(CAPTURE_FILE_BATCH_SIZE_KBYTE_PARAM, m_captureFileBatchSizeKByte); s->BoolValue(DEBUG_PARAM, m_debug); s->CsvValue(TAPE_FILE_NAMING_PARAM, m_tapeFileNaming); + s->CsvValue(TAPE_PATH_NAMING_PARAM, m_tapePathNaming); s->CsvValue(REMOTE_PROCESSING_INPUT_PATH_PARAM, m_remoteProcessingInputPath); s->StringValue(REMOTE_PROCESSING_OUTPUT_PATH_PARAM, m_remoteProcessingOutputPath); s->StringValue(REMOTE_PROCESSING_HOSTNAME_PARAM, m_remoteProcessingHostname); diff --git a/orkbasecxx/Config.h b/orkbasecxx/Config.h index c728860..50271c9 100644 --- a/orkbasecxx/Config.h +++ b/orkbasecxx/Config.h @@ -77,6 +77,7 @@ #define DEBUG_PARAM "Debug" #define DEBUG_DEFAULT false #define TAPE_FILE_NAMING_PARAM "TapeFileNaming" +#define TAPE_PATH_NAMING_PARAM "TapePathNaming" #define REMOTE_PROCESSING_INPUT_PATH_PARAM "RemoteProcessingInputPath" #define REMOTE_PROCESSING_OUTPUT_PATH_PARAM "RemoteProcessingOutputPath" #define REMOTE_PROCESSING_HOSTNAME_PARAM "RemoteProcessingHostname" @@ -96,7 +97,7 @@ public: CStdString GetClassName(); ObjectRef NewInstance(); inline ObjectRef Process() {return ObjectRef();}; - + time_t m_serviceStartedTime; bool m_logMessages; bool m_logRms; bool m_enableReporting; @@ -129,6 +130,7 @@ public: int m_captureFileBatchSizeKByte; bool m_debug; std::list m_tapeFileNaming; + std::list m_tapePathNaming; std::list m_remoteProcessingInputPath; CStdString m_remoteProcessingOutputPath; CStdString m_remoteProcessingHostname; -- cgit v1.2.3