non/nonlib/Loggable.C

843 lines
18 KiB
C++
Raw Normal View History

2008-02-22 12:44:35 +01:00
/*******************************************************************************/
/* Copyright (C) 2008 Jonathan Moore Liles */
/* */
/* This program is free software; you can redistribute it and/or modify it */
/* under the terms of the GNU General Public License as published by the */
/* Free Software Foundation; either version 2 of the License, or (at your */
/* option) any later version. */
/* */
/* This program 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 General Public License for */
/* more details. */
/* */
/* You should have received a copy of the GNU General Public License along */
/* with This program; see the file COPYING. If not,write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/*******************************************************************************/
2008-06-21 06:38:29 +02:00
/* This class handles all journaling. All journaled objects must
inherit from Loggable as well as define a few special methods (via
macros), get and set methods, and have contructors and destructors
that call log_create() and log_destroy() in the appropriate
order. Any action that might affect multiple loggable objects
*must* be braced by calls to Loggable::block_start() and
Loggable::block_end() in order for Undo to work properly. */
2008-05-22 17:32:26 +02:00
2008-02-22 12:44:35 +01:00
#include "Loggable.H"
2008-02-25 05:14:19 +01:00
#include <stdlib.h>
2008-02-22 12:44:35 +01:00
#include <stdio.h>
2008-03-05 08:05:08 +01:00
#include <string.h>
2008-02-22 12:44:35 +01:00
2010-02-01 07:25:16 +01:00
#include "file.h"
// #include "const.h"
2010-02-01 07:25:16 +01:00
#include "debug.h"
#include "Mutex.H"
2008-05-22 22:58:36 +02:00
#include <algorithm>
using std::min;
using std::max;
bool Loggable::_readonly = false;
2008-02-22 21:20:44 +01:00
FILE *Loggable::_fp;
unsigned int Loggable::_log_id = 0;
int Loggable::_level = 0;
int Loggable::_dirty = 0;
off_t Loggable::_undo_offset = 0;
2008-02-22 12:44:35 +01:00
std::map <unsigned int, Loggable::log_pair > Loggable::_loggables;
2008-05-22 22:58:36 +02:00
std::map <std::string, create_func*> Loggable::_class_map;
std::queue <char *> Loggable::_transaction;
2008-02-24 08:42:41 +01:00
2008-06-05 06:27:55 +02:00
progress_func *Loggable::_progress_callback = NULL;
void *Loggable::_progress_callback_arg = NULL;
snapshot_func *Loggable::_snapshot_callback = NULL;
void *Loggable::_snapshot_callback_arg = NULL;
dirty_func *Loggable::_dirty_callback = NULL;
void *Loggable::_dirty_callback_arg = NULL;
static Mutex _lock;
Loggable::~Loggable ( )
{
Locker lock( _lock );;
_loggables[ _id ].loggable = NULL;
}
2008-06-04 06:41:53 +02:00
void
Loggable::block_start ( void )
{
Locker lock( _lock );;
++Loggable::_level;
}
void
Loggable::block_end ( void )
{
Locker lock( _lock );;
--Loggable::_level;
ASSERT( Loggable::_level >= 0, "Programming error" );
if ( Loggable::_level == 0 )
flush();
}
Loggable *
Loggable::find ( unsigned int id )
{
if ( _relative_id )
id += _relative_id;
return _loggables[ id ].loggable;
}
2008-06-04 06:41:53 +02:00
/** Open the journal /filename/ and replay it, bringing the end state back into RAM */
2008-02-22 21:20:44 +01:00
bool
Loggable::open ( const char *filename )
{
2008-04-20 04:15:54 +02:00
FILE *fp;
Loggable::_fp = NULL;
2008-04-20 04:15:54 +02:00
if ( ! ( fp = fopen( filename, "a+" ) ) )
2008-02-22 21:20:44 +01:00
{
2008-05-03 18:46:48 +02:00
WARNING( "Could not open log file for writing!" );
if ( ! ( fp = fopen( filename, "r" ) ) )
{
WARNING( "Could not open log file for reading!" );
return false;
}
else
{
_readonly = true;
}
2008-02-22 21:20:44 +01:00
}
_readonly = false;
2008-02-22 21:20:44 +01:00
load_unjournaled_state();
if ( newer( "snapshot", filename ) )
{
2008-07-12 06:24:32 +02:00
MESSAGE( "Loading snapshot" );
FILE *fp = fopen( "snapshot", "r" );
replay( fp );
fclose( fp );
}
else
{
2008-07-12 06:24:32 +02:00
MESSAGE( "Replaying journal" );
replay( fp );
}
fseek( fp, 0, SEEK_END );
_undo_offset = ftell( fp );
2008-04-20 04:15:54 +02:00
Loggable::_fp = fp;
2008-02-22 21:20:44 +01:00
return true;
}
bool
Loggable::load_unjournaled_state ( void )
{
FILE *fp;
fp = fopen( "unjournaled", "r" );
if ( ! fp )
{
DWARNING( "Could not open unjournaled state file for reading" );
return false;
}
unsigned int id;
char buf[BUFSIZ];
while ( fscanf( fp, "%X set %[^\n]\n", &id, buf ) == 2 )
_loggables[ id ].unjournaled_state = new Log_Entry( buf );
fclose( fp );
return true;
}
2008-06-05 06:27:55 +02:00
#include <sys/stat.h>
#include <unistd.h>
/** replay journal or snapshot */
bool
Loggable::replay ( const char *file )
{
if ( FILE *fp = fopen( file, "r" ) )
{
bool r = replay( fp );
fclose( fp );
return r;
}
else
return false;
}
/** replay journal or snapshot */
bool
Loggable::replay ( FILE *fp )
{
/* FIXME: bogus */
char buf[BUFSIZ];
2008-06-05 06:27:55 +02:00
struct stat st;
fstat( fileno( fp ), &st );
off_t total = st.st_size;
off_t current = 0;
if ( _progress_callback )
_progress_callback( 0, _progress_callback_arg );
while ( fscanf( fp, "%[^\n]\n", buf ) == 1 )
{
if ( ! ( ! strcmp( buf, "{" ) || ! strcmp( buf, "}" ) ) )
{
if ( *buf == '\t' )
do_this( buf + 1, false );
else
do_this( buf, false );
}
2008-06-05 06:27:55 +02:00
current = ftell( fp );
if ( _progress_callback )
_progress_callback( current * 100 / total, _progress_callback_arg );
}
2008-06-05 06:27:55 +02:00
if ( _progress_callback )
_progress_callback( 0, _progress_callback_arg );
clear_dirty();
2008-06-05 06:27:55 +02:00
return true;
}
2008-06-04 06:41:53 +02:00
/** close journal and delete all loggable objects, returing the systemt to a blank slate */
2008-05-04 00:50:32 +02:00
bool
Loggable::close ( void )
{
DMESSAGE( "closing journal and destroying all journaled objects" );
if ( _fp )
{
fclose( _fp );
_fp = NULL;
}
2008-05-04 00:50:32 +02:00
2008-07-12 06:24:32 +02:00
if ( ! snapshot( "snapshot" ) )
WARNING( "Failed to create snapshot" );
if ( ! save_unjournaled_state() )
WARNING( "Failed to save unjournaled state" );
for ( std::map <unsigned int, Loggable::log_pair >::iterator i = _loggables.begin();
i != _loggables.end(); ++i )
{
if ( i->second.loggable )
delete i->second.loggable;
if ( i->second.unjournaled_state )
delete i->second.unjournaled_state;
}
_loggables.clear();
2008-05-04 00:50:32 +02:00
return true;
}
/** save out unjournaled state for all loggables */
bool
Loggable::save_unjournaled_state ( void )
{
FILE *fp;
fp = fopen( "unjournaled", "w" );
if ( ! fp )
{
DWARNING( "Could not open unjournaled state file for writing!" );
return false;
}
for ( std::map <unsigned int, Loggable::log_pair >::iterator i = _loggables.begin();
i != _loggables.end(); ++i )
{
/* get the latest state */
if ( i->second.loggable )
i->second.loggable->record_unjournaled();
if ( i->second.unjournaled_state )
{
char *s = i->second.unjournaled_state->print();
fprintf( fp, "0x%X set %s\n", i->first, s );
free( s );
}
}
fclose( fp );
return true;
}
2008-06-04 06:41:53 +02:00
/** must be called after construction in create() methods */
void
Loggable::update_id ( unsigned int id )
{
/* make sure we're the last one */
ASSERT( _id == _log_id, "%u != %u", _id, _log_id );
assert( _loggables[ _id ].loggable == this );
_loggables[ _id ].loggable = NULL;
_log_id = max( _log_id, id );
/* return this id number to the system */
// --_log_id;
_id = id;
if ( _loggables[ _id ].loggable )
FATAL( "Attempt to create object with an ID (0x%X) that already exists. The existing object is of type \"%s\", the new one is \"%s\". Corrupt journal?", _id, _loggables[ _id ].loggable->class_name(), class_name() );
_loggables[ _id ].loggable = this;
}
/** return a pointer to a static copy of /s/ with all special characters escaped */
const char *
Loggable::escape ( const char *s )
{
static char r[512];
2008-05-06 07:34:46 +02:00
size_t i = 0;
for ( ; *s && i < sizeof( r ); ++i, ++s )
{
if ( '\n' == *s )
{
r[ i++ ] = '\\';
r[ i ] = 'n';
}
else if ( '"' == *s )
{
r[ i++ ] = '\\';
r[ i ] = '"';
}
else
r[ i ] = *s;
}
2008-05-06 07:34:46 +02:00
r[ i ] = '\0';
return r;
}
unsigned int Loggable::_relative_id = 0;
/* calls to do_this() between invocation of this method and
* end_relative_id_mode() will have all their IDs made relative to the
* highest available ID at this time of this call. Non-Mixer uses
* this to allow importing of module chains */
void
Loggable::begin_relative_id_mode ( void )
{
_relative_id = ++_log_id;
}
void
Loggable::end_relative_id_mode ( void )
{
_relative_id = 0;
}
2008-05-05 02:04:20 +02:00
/** 'do' a message like "Audio_Region 0xF1 set :r 123" */
bool
Loggable::do_this ( const char *s, bool reverse )
{
unsigned int id = 0;
2008-07-15 06:07:47 +02:00
char classname[40];
char command[40];
2008-05-07 17:19:55 +02:00
char *arguments = NULL;
int found = sscanf( s, "%s %X %s ", classname, &id, command );
2012-11-06 08:50:28 +01:00
if ( 3 != found )
FATAL( "Invalid journal entry format \"%s\"", s );
const char *create, *destroy;
if ( reverse )
{
2008-05-07 17:19:55 +02:00
// sscanf( s, "%s %*X %s %*[^\n<]<< %a[^\n]", classname, command, &arguments );
sscanf( s, "%s %*X %s%*[^\n<]<< %a[^\n]", classname, command, &arguments );
create = "destroy";
destroy = "create";
DMESSAGE( "undoing \"%s\"", s );
}
else
{
sscanf( s, "%s %*X %s %a[^\n<]", classname, command, &arguments );
create = "create";
destroy = "destroy";
}
if ( ! strcmp( command, destroy ) )
{
Loggable *l = find( id );
2008-04-25 23:35:51 +02:00
/* deleting eg. a track, which contains a list of other
2008-06-04 06:41:53 +02:00
widgets, causes destroy messages to be emitted for all those
widgets, but when replaying the journal the destroy message
causes the children to be deleted also... This is a temporary
hack. Would it be better to queue up objects for deletion
(when?) */
2008-04-25 23:35:51 +02:00
if ( l )
delete l;
}
else if ( ! strcmp( command, "set" ) )
{
// printf( "got set command (%s).\n", arguments );
Loggable *l = find( id );
ASSERT( l, "Unable to find object 0x%X referenced by command \"%s\"", id, s );
2008-06-04 05:34:36 +02:00
Log_Entry e( arguments );
2008-04-20 04:15:54 +02:00
l->log_start();
2008-04-20 04:15:54 +02:00
l->set( e );
l->log_end();
}
else if ( ! strcmp( command, create ) )
{
2008-06-04 05:34:36 +02:00
Log_Entry e( arguments );
2008-05-22 22:58:36 +02:00
ASSERT( _class_map[ std::string( classname ) ], "Journal contains an object of class \"%s\", but I don't know how to create such objects.", classname );
{
if ( _relative_id )
id += _relative_id;
/* create */
Loggable *l = _class_map[ std::string( classname ) ]( e, id );
l->log_create();
/* we're now creating a loggable. Apply any unjournaled
* state it may have had in the past under this log ID */
Log_Entry *e = _loggables[ id ].unjournaled_state;
if ( e )
l->set( *e );
}
}
2008-05-07 04:32:37 +02:00
if ( arguments )
free( arguments );
return true;
}
2008-02-27 21:04:17 +01:00
/** Reverse the last journal transaction */
void
Loggable::undo ( void )
{
const int bufsiz = 1024;
char buf[bufsiz];
2008-02-25 05:14:19 +01:00
block_start();
long here = ftell( _fp );
fseek( _fp, _undo_offset, SEEK_SET );
backwards_fgets( buf, bufsiz, _fp );
if ( ! strcmp( buf, "}\n" ) )
2008-03-05 08:05:08 +01:00
{
DMESSAGE( "undoing block" );
for ( ;; )
{
backwards_fgets( buf, bufsiz, _fp );
2008-03-05 08:05:08 +01:00
char *s = buf;
if ( *s != '\t' )
break;
else
++s;
2008-03-05 08:05:08 +01:00
do_this( s, true );
}
}
else
do_this( buf, true );
2008-03-05 08:05:08 +01:00
off_t uo = ftell( _fp );
2008-03-05 08:05:08 +01:00
ASSERT( _undo_offset <= here, "WTF?" );
2008-02-27 21:04:17 +01:00
block_end();
_undo_offset = uo;
2008-02-25 05:14:19 +01:00
}
2008-06-19 06:14:14 +02:00
/** write a snapshot of the current state of all loggable objects to
* file handle /fp/ */
2008-06-05 06:27:55 +02:00
bool
Loggable::snapshot ( FILE *fp )
{
FILE *ofp = _fp;
if ( ! Loggable::_snapshot_callback )
{
DWARNING( "No snapshot callback defined" );
return false;
}
2008-06-05 06:27:55 +02:00
if ( ! ( _fp = fp ) )
{
_fp = ofp;
return false;
}
block_start();
Loggable::_snapshot_callback( _snapshot_callback_arg );
block_end();
_fp = ofp;
clear_dirty();
return true;
}
2008-02-25 05:14:19 +01:00
2008-06-19 06:14:14 +02:00
/** write a snapshot of the current state of all loggable objects to
* file /name/ */
bool
Loggable::snapshot ( const char *name )
{
FILE *fp;
if ( ! ( fp = fopen( name, "w" ) ))
return false;
2008-07-12 06:24:32 +02:00
bool r = snapshot( fp );
fclose( fp );
2008-06-05 06:27:55 +02:00
2008-07-12 06:24:32 +02:00
return r;
}
2008-06-04 06:41:53 +02:00
/** Replace the journal with a snapshot of the current state */
2008-04-24 00:29:14 +02:00
void
Loggable::compact ( void )
{
2008-04-24 02:33:44 +02:00
fseek( _fp, 0, SEEK_SET );
ftruncate( fileno( _fp ), 0 );
2008-04-24 00:29:14 +02:00
2008-06-05 06:27:55 +02:00
if ( ! snapshot( _fp ) )
FATAL( "Could not write snapshot!" );
2008-04-24 00:29:14 +02:00
fseek( _fp, 0, SEEK_END );
2008-04-24 02:33:44 +02:00
}
2008-04-24 00:29:14 +02:00
#include <stdarg.h>
/** Writes (part of) a line to the journal. Each separate line will be
* stored separately in _transaction until transaction is closed.
*/
2008-02-25 05:14:19 +01:00
void
Loggable::log ( const char *fmt, ... )
{
Locker lock( _lock );
static char * buf = NULL;
static size_t i = 0;
static size_t buf_size = 0;
if ( ! _fp )
return;
if ( NULL == buf )
{
buf_size = 1024;
buf = (char*)malloc( buf_size );
}
2008-02-25 05:14:19 +01:00
va_list args;
if ( fmt )
{
va_start( args, fmt );
for ( ;; )
{
size_t l = vsnprintf( buf + i, buf_size - i, fmt, args );
if ( l >= buf_size - i )
{
buf = (char*)realloc( buf, buf_size += (l + 1) + buf_size );
}
else
{
i += l;
break;
}
}
2008-02-25 05:14:19 +01:00
va_end( args );
}
2008-02-25 23:47:49 +01:00
if ( '\n' == buf[i-1] )
{
_transaction.push( strdup( buf ) );
i = 0;
}
2008-02-25 05:14:19 +01:00
}
2008-02-24 08:42:41 +01:00
2008-06-04 06:41:53 +02:00
/** End the current transaction and commit it to the journal */
void
Loggable::flush ( void )
{
if ( ! _fp )
{
2008-04-21 05:05:25 +02:00
// printf( "error: no log file open!\n" );
while ( ! _transaction.empty() )
{
free( _transaction.front() );
_transaction.pop();
}
return;
}
int n = _transaction.size();
if ( n > 1 )
fprintf( _fp, "{\n" );
while ( ! _transaction.empty() )
{
char *s = _transaction.front();
_transaction.pop();
if ( n > 1 )
fprintf( _fp, "\t" );
fprintf( _fp, "%s", s );
free( s );
}
if ( n > 1 )
fprintf( _fp, "}\n" );
if ( n )
/* something done, reset undo index */
_undo_offset = ftell( _fp );
fflush( _fp );
}
2008-02-24 08:42:41 +01:00
2008-06-04 06:41:53 +02:00
/** Print bidirectional journal entry */
2008-02-24 08:42:41 +01:00
void
2008-06-04 06:28:28 +02:00
Loggable::log_print( const Log_Entry *o, const Log_Entry *n ) const
2008-02-24 08:42:41 +01:00
{
2008-06-04 06:28:28 +02:00
if ( ! _fp )
return;
2008-02-24 08:42:41 +01:00
if ( n )
2008-06-04 06:28:28 +02:00
for ( int i = 0; i < n->size(); ++i )
{
const char *s, *v;
n->get( i, &s, &v );
log( "%s %s%s", s, v, n->size() == i + 1 ? "" : " " );
}
2008-02-24 08:42:41 +01:00
2008-06-04 06:28:28 +02:00
if ( o && o->size() )
2008-02-24 08:42:41 +01:00
{
2008-02-25 05:14:19 +01:00
if ( n ) log( " << " );
2008-06-04 06:28:28 +02:00
for ( int i = 0; i < o->size(); ++i )
{
const char *s, *v;
o->get( i, &s, &v );
log( "%s %s%s", s, v, o->size() == i + 1 ? "" : " " );
2008-06-04 06:28:28 +02:00
}
2008-02-24 08:42:41 +01:00
}
2008-02-25 05:14:19 +01:00
log( "\n" );
2008-02-24 08:42:41 +01:00
}
2008-06-04 06:41:53 +02:00
/** Remember current object state for later comparison. *Must* be
* called before any user action that might change one of the object's
* journaled properties. */
2008-02-24 08:42:41 +01:00
void
Loggable::log_start ( void )
{
Locker lock( _lock );;
2008-02-24 14:28:55 +01:00
if ( ! _old_state )
2008-04-20 04:15:54 +02:00
{
2008-06-04 05:47:26 +02:00
_old_state = new Log_Entry;
2008-02-24 14:28:55 +01:00
2008-06-04 05:47:26 +02:00
get( *_old_state );
2008-04-20 04:15:54 +02:00
}
2008-02-24 14:28:55 +01:00
++_nest;
2008-02-24 08:42:41 +01:00
}
2008-06-04 06:41:53 +02:00
/** Log any change to the object's state since log_start(). */
2008-02-24 08:42:41 +01:00
void
Loggable::log_end ( void )
{
Locker lock( _lock );;
ASSERT( _old_state, "Programming error: log_end() called before log_start()" );
2008-02-24 14:28:55 +01:00
if ( --_nest > 0 )
return;
2008-06-04 06:28:28 +02:00
Log_Entry *new_state;
2008-04-20 04:15:54 +02:00
2008-06-04 06:28:28 +02:00
new_state = new Log_Entry;
2008-04-20 04:15:54 +02:00
2008-06-04 06:28:28 +02:00
get( *new_state );
2008-02-24 08:42:41 +01:00
2008-06-06 05:26:51 +02:00
if ( Log_Entry::diff( _old_state, new_state ) )
{
2008-02-25 05:14:19 +01:00
log( "%s 0x%X set ", class_name(), _id );
2008-02-24 08:42:41 +01:00
2008-06-04 06:28:28 +02:00
log_print( _old_state, new_state );
set_dirty();
}
2008-02-24 08:42:41 +01:00
delete new_state;
delete _old_state;
2008-02-24 14:28:55 +01:00
2008-02-24 08:42:41 +01:00
_old_state = NULL;
2008-02-24 14:28:55 +01:00
if ( Loggable::_level == 0 )
Loggable::flush();
2008-02-24 08:42:41 +01:00
}
2008-06-04 06:41:53 +02:00
/** Log object creation. *Must* be called at the end of all public
* constructors for leaf classes */
2008-02-24 08:42:41 +01:00
void
2008-04-25 08:34:08 +02:00
Loggable::log_create ( void ) const
2008-02-24 08:42:41 +01:00
{
Locker lock( _lock );;
set_dirty();
if ( ! _fp )
/* replaying, don't bother */
return;
2008-02-27 21:04:17 +01:00
log( "%s 0x%X create ", class_name(), _id );
2008-02-24 08:42:41 +01:00
2008-04-20 04:15:54 +02:00
Log_Entry e;
get( e );
if ( e.size() )
log_print( NULL, &e );
else
log( "\n" );
if ( Loggable::_level == 0 )
Loggable::flush();
2008-02-24 08:42:41 +01:00
}
/** record this loggable's unjournaled state in memory */
void
Loggable::record_unjournaled ( void ) const
{
Log_Entry *e = new Log_Entry();
get_unjournaled( *e );
Log_Entry **le = &_loggables[ _id ].unjournaled_state;
if ( *le )
{
delete *le;
*le = NULL;
}
if ( e->size() )
*le = e;
else
delete e;
}
2008-06-04 06:41:53 +02:00
/** Log object destruction. *Must* be called at the beginning of the
* destructors of leaf classes */
2008-02-24 08:42:41 +01:00
void
2008-04-25 08:34:08 +02:00
Loggable::log_destroy ( void ) const
2008-02-24 08:42:41 +01:00
{
Locker lock( _lock );;
set_dirty();
if ( ! _fp )
/* tearing down... don't bother */
return;
/* the unjournaled state may have changed: make a note of it. */
record_unjournaled();
2008-05-07 17:19:55 +02:00
log( "%s 0x%X destroy << ", class_name(), _id );
2008-02-24 08:42:41 +01:00
2008-04-20 04:15:54 +02:00
Log_Entry e;
get( e );
2008-06-04 06:28:28 +02:00
log_print( NULL, &e );
if ( Loggable::_level == 0 )
Loggable::flush();
2008-02-24 08:42:41 +01:00
}