ansible4ozw 0.0.2 → 0.0.3

data/lib/ansible/zwave/openzwave/src/platform/unix/EventImpl.h

@@ -0,0 +1,62 @@
+//-----------------------------------------------------------------------------
+//
+//	EventImpl.h
+//
+//	POSIX implementation of a cross-platform event
+//
+//	Copyright (c) 2010, Greg Satz <satz@iranger.com>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#ifndef _EventImpl_H
+#define _EventImpl_H
+
+#include <pthread.h>
+#include <errno.h>
+
+namespace OpenZWave
+{
+	class EventImpl
+	{
+	private:
+		friend class Event;
+		friend class SocketImpl;
+		friend class Wait;
+
+		EventImpl();
+		~EventImpl();
+
+		void Set();
+		void Reset();
+		
+		bool Wait( int32 _timeout );	// The wait method is to be used only by the Wait::Multiple method
+		bool IsSignalled();
+
+		pthread_mutex_t		m_lock;
+		pthread_cond_t		m_condition;
+		bool			m_manualReset;
+		bool			m_isSignaled;
+		unsigned int		m_waitingThreads;
+	};
+
+} // namespace OpenZWave
+
+#endif //_EventImpl_H
+

data/lib/ansible/zwave/openzwave/src/platform/unix/LogImpl.cpp

@@ -0,0 +1,304 @@
+//-----------------------------------------------------------------------------
+//
+//	LogImpl.cpp
+//
+//  Unix implementation of message and error logging
+//
+//	Copyright (c) 2010, Greg Satz <satz@iranger.com>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#include <string>
+#include <cstring>
+#include "Defs.h"
+#include "LogImpl.h"
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::LogImpl>
+//	Constructor
+//-----------------------------------------------------------------------------
+LogImpl::LogImpl
+(
+	string const& _filename,
+	bool const _bAppendLog,
+	bool const _bConsoleOutput,
+	LogLevel const _saveLevel,
+	LogLevel const _queueLevel,
+	LogLevel const _dumpTrigger
+):
+	m_filename( _filename ),					// name of log file
+	m_bConsoleOutput( _bConsoleOutput ),		// true to provide a copy of output to console
+	m_bAppendLog( _bAppendLog ),				// true to append (and not overwrite) any existing log
+	m_saveLevel( _saveLevel ),					// level of messages to log to file
+	m_queueLevel( _queueLevel ),				// level of messages to log to queue
+	m_dumpTrigger( _dumpTrigger )				// dump queued messages when this level is seen
+{
+	if ( !m_bAppendLog )
+	{
+		FILE* pFile = fopen( m_filename.c_str(), "w" );
+		if( pFile != NULL )
+		{
+			fclose( pFile );
+		}
+	}
+	setlinebuf(stdout);	// To prevent buffering and lock contention issues
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::~LogImpl>
+//	Destructor
+//-----------------------------------------------------------------------------
+LogImpl::~LogImpl
+(
+)
+{
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::Write>
+//	Write to the log
+//-----------------------------------------------------------------------------
+void LogImpl::Write
+( 
+	LogLevel _logLevel,
+	uint8 const _nodeId,
+	char const* _format, 
+	va_list _args
+)
+{
+	// create a timestamp string
+	string timeStr = GetTimeStampString();
+	string nodeStr = GetNodeString( _nodeId );
+
+	// handle this message
+	if( (_logLevel <= m_queueLevel) || (_logLevel == LogLevel_Internal) )	// we're going to do something with this message...
+	{
+		char lineBuf[1024] = {};
+		int lineLen = 0;
+		if( _format != NULL && _format[0] != '\0' )
+		{
+			va_list saveargs;
+			va_copy( saveargs, _args );
+			lineLen = vsnprintf( lineBuf, sizeof(lineBuf), _format, _args );
+			va_end( saveargs );
+		}
+
+		// should this message be saved to file (and possibly written to console?)
+		if( (_logLevel <= m_saveLevel) || (_logLevel == LogLevel_Internal) )
+		{
+			char outBuf[1124];
+			char *outBufPtr = outBuf;
+			// save to file
+			FILE* pFile = fopen( m_filename.c_str(), "a" );
+			if ( pFile != NULL )
+			{
+				if( _logLevel != LogLevel_Internal )						// don't add a second timestamp to display of queued messages
+				{
+					strcpy( outBufPtr, timeStr.c_str() );
+					outBufPtr += timeStr.length();
+					strcpy( outBufPtr, nodeStr.c_str() );
+					outBufPtr += nodeStr.length();
+				}
+
+				if( lineLen > 0 )
+				{
+					uint32 len = ( outBufPtr - outBuf ) + lineLen;
+					if( len >= sizeof(outBuf) )
+					{
+						lineLen = sizeof(outBuf) - 3;
+					}
+					strncpy( outBufPtr, lineBuf, lineLen );
+					outBufPtr += lineLen;
+				}
+
+				*outBufPtr++ = '\n';
+				*outBufPtr = '\0';
+
+				// print message to file (and possibly screen)
+				fputs( outBuf, pFile );
+				if( m_bConsoleOutput )
+				{
+					fputs( outBuf, stdout );
+				}
+
+				fclose( pFile );
+			}
+		}
+
+		if( _logLevel != LogLevel_Internal )
+		{
+			char queueBuf[1024];
+			string threadStr = GetThreadId();
+			snprintf( queueBuf, sizeof(queueBuf), "%s%s%s", timeStr.c_str(), threadStr.c_str(), lineBuf );
+			Queue( queueBuf );
+		}
+	}
+
+	// now check to see if the _dumpTrigger has been hit
+	if( (_logLevel <= m_dumpTrigger) && (_logLevel != LogLevel_Internal) && (_logLevel != LogLevel_Always) )
+		QueueDump();
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::Queue>
+//	Write to the log queue
+//-----------------------------------------------------------------------------
+void LogImpl::Queue
+( 
+	char const* _buffer
+)
+{
+	string bufStr = _buffer;
+	m_logQueue.push_back( bufStr );
+
+	// rudimentary queue size management
+	if( m_logQueue.size() > 500 )
+	{
+		m_logQueue.pop_front();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::QueueDump>
+//	Dump the LogQueue to output device
+//-----------------------------------------------------------------------------
+void LogImpl::QueueDump
+( 
+)
+{
+	Log::Write( LogLevel_Always, "" );
+	Log::Write( LogLevel_Always, "Dumping queued log messages");
+	Log::Write( LogLevel_Always, "" );
+	list<string>::iterator it = m_logQueue.begin();
+	while( it != m_logQueue.end() )
+	{
+		string strTemp = *it;
+		Log::Write( LogLevel_Internal, strTemp.c_str() );
+		it++;
+	}
+	m_logQueue.clear();
+	Log::Write( LogLevel_Always, "" );
+	Log::Write( LogLevel_Always, "End of queued log message dump");
+	Log::Write( LogLevel_Always, "" );
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::Clear>
+//	Clear the LogQueue
+//-----------------------------------------------------------------------------
+void LogImpl::QueueClear
+( 
+)
+{
+	m_logQueue.clear();
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::SetLoggingState>
+//	Sets the various log state variables
+//-----------------------------------------------------------------------------
+void LogImpl::SetLoggingState
+(
+	LogLevel _saveLevel,
+	LogLevel _queueLevel,
+	LogLevel _dumpTrigger
+)
+{
+	m_saveLevel = _saveLevel;
+	m_queueLevel = _queueLevel;
+	m_dumpTrigger = _dumpTrigger;
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::GetTimeStampAndThreadId>
+//	Generate a string with formatted current time
+//-----------------------------------------------------------------------------
+string LogImpl::GetTimeStampString
+( 
+)
+{
+	// Get a timestamp
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	struct tm *tm;
+	tm = localtime( &tv.tv_sec );
+
+	// create a time stamp string for the log message
+	char buf[100];
+	snprintf( buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d:%03d ", 
+		tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+		  tm->tm_hour, tm->tm_min, tm->tm_sec, tv.tv_usec / 1000 );
+	string str = buf;
+	return str;
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::GetNodeString>
+//	Generate a string with formatted node id
+//-----------------------------------------------------------------------------
+string LogImpl::GetNodeString
+(
+	uint8 const _nodeId
+)
+{
+	if( _nodeId == 0 )
+	{
+		return "";
+	}
+	else
+		if( _nodeId == 255 ) // should make distinction between broadcast and controller better for SwitchAll broadcast
+		{
+			return "contrlr, ";
+		}
+		else
+		{
+			char buf[20];  
+			snprintf( buf, sizeof(buf), "Node%03d, ", _nodeId );
+			return buf;
+		}
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::GetThreadId>
+//	Generate a string with formatted thread id
+//-----------------------------------------------------------------------------
+string LogImpl::GetThreadId
+( 
+)
+{
+	char buf[20];
+	snprintf( buf, sizeof(buf), "%08x ", pthread_self() );
+	string str = buf;
+	return str;
+}
+
+//-----------------------------------------------------------------------------
+//	<LogImpl::SetLogFileName>
+//	Provide a new log file name (applicable to future writes)
+//-----------------------------------------------------------------------------
+void LogImpl::SetLogFileName
+( 
+	string _filename
+)
+{
+	m_filename = _filename;
+}

data/lib/ansible/zwave/openzwave/src/platform/unix/LogImpl.h

@@ -0,0 +1,70 @@
+//-----------------------------------------------------------------------------
+//
+//	LogImpl.h
+//
+//  Unix implementation of message and error logging
+//
+//	Copyright (c) 2010, Greg Satz <satz@iranger.com>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+#ifndef _LogImpl_H
+#define _LogImpl_H
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+#include <sys/time.h>
+#include "Log.h"
+
+namespace OpenZWave
+{
+	class LogImpl : public i_LogImpl
+	{
+	private:
+		friend class Log;
+
+		LogImpl( string const& _filename, bool const _bAppendLog, bool const _bConsoleOutput, LogLevel const _saveLevel, LogLevel const _queueLevel, LogLevel const _dumpTrigger );
+		~LogImpl();
+
+		void Write( LogLevel _level, uint8 const _nodeId, char const* _format, va_list _args );
+		void Queue( char const* _buffer );
+		void QueueDump();
+		void QueueClear();
+		void SetLoggingState( LogLevel _saveLevel, LogLevel _queueLevel, LogLevel _dumpTrigger );
+		void SetLogFileName( string _filename );
+
+		string GetTimeStampString();
+		string GetNodeString( uint8 const _nodeId );
+		string GetThreadId();
+
+		string m_filename;						/**< filename specified by user (default is ozw_log.txt) */
+		bool m_bConsoleOutput;					/**< if true, send log output to console as well as to the file */
+		bool m_bAppendLog;						/**< if true, the log file should be appended to any with the same name */
+		list<string> m_logQueue;				/**< list of queued log messages */
+		LogLevel m_saveLevel;
+		LogLevel m_queueLevel;
+		LogLevel m_dumpTrigger;
+	};
+
+} // namespace OpenZWave
+
+#endif //_LogImpl_H
+

data/lib/ansible/zwave/openzwave/src/platform/unix/MutexImpl.cpp

@@ -0,0 +1,136 @@
+//----------------------------------------------------------------------------
+//
+//  MutexImpl.cpp
+//
+//  POSIX implementation of the cross-platform mutex
+//
+//	Copyright (c) 2010, Greg Satz <satz@iranger.com>
+//	All rights reserved.
+//
+//	SOFTWARE NOTICE AND LICENSE
+//
+//	This file is part of OpenZWave.
+//
+//	OpenZWave is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as published
+//	by the Free Software Foundation, either version 3 of the License,
+//	or (at your option) any later version.
+//
+//	OpenZWave is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU Lesser General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
+//
+//-----------------------------------------------------------------------------
+
+#include "Defs.h"
+#include "Log.h"
+#include "MutexImpl.h"
+
+#include <stdio.h>
+#include <errno.h>
+
+using namespace OpenZWave;
+
+//-----------------------------------------------------------------------------
+//	<MutexImpl::MutexImpl>
+//	Constructor
+//-----------------------------------------------------------------------------
+MutexImpl::MutexImpl
+(
+):
+	m_lockCount( 0 )
+{
+	pthread_mutexattr_t ma;
+
+	pthread_mutexattr_init ( &ma );
+	pthread_mutexattr_settype( &ma, PTHREAD_MUTEX_RECURSIVE );
+	int err = pthread_mutex_init( &m_criticalSection, &ma );
+	if( err != 0 )
+	{
+		fprintf(stderr, "MutexImpl::MutexImpl error %d (%d)\n", errno, err );
+	}
+	pthread_mutexattr_destroy( &ma );
+}
+
+//-----------------------------------------------------------------------------
+//	<MutexImpl::~MutexImpl>
+//	Destructor
+//-----------------------------------------------------------------------------
+MutexImpl::~MutexImpl
+(
+)
+{
+	pthread_mutex_destroy( &m_criticalSection );
+}
+
+//-----------------------------------------------------------------------------
+//	<MutexImpl::Lock>
+//	Lock the mutex
+//-----------------------------------------------------------------------------
+bool MutexImpl::Lock
+(
+	bool const _bWait
+)
+{
+	if( _bWait )
+	{
+		// We will wait for the lock
+		int err = pthread_mutex_lock( &m_criticalSection );
+		if( err == 0 )
+		{
+			++m_lockCount;
+			return true;
+		}
+		fprintf(stderr, "MutexImpl::Lock error %d (%d)\n", errno, err);
+		return false;
+	}
+
+	// Returns immediately, even if the lock was not available.
+	if( pthread_mutex_trylock( &m_criticalSection ) )
+	{
+		return false;
+	}
+	
+	++m_lockCount;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//	<MutexImpl::Unlock>
+//	Release our lock on the mutex
+//-----------------------------------------------------------------------------
+void MutexImpl::Unlock
+(
+)
+{
+	if( !m_lockCount )
+	{
+		// No locks - we have a mismatched lock/release pair
+		assert(0);
+	}
+	else
+	{
+		--m_lockCount;
+		int err = pthread_mutex_unlock( &m_criticalSection );
+		if( err != 0 )
+		{
+			fprintf(stderr, "MutexImpl::Unlock error %d (%d)\n", errno, err);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//	<MutexImpl::IsSignalled>
+//	Test whether the mutex is free
+//-----------------------------------------------------------------------------
+bool MutexImpl::IsSignalled
+(
+)
+{
+	return( 0 == m_lockCount );
+}
+