nonlib/Loggable.C

   1
   2 /*******************************************************************************/
   3 /* Copyright (C) 2008 Jonathan Moore Liles                                     */
   4 /*                                                                             */
   5 /* This program is free software; you can redistribute it and/or modify it     */
   6 /* under the terms of the GNU General Public License as published by the       */
   7 /* Free Software Foundation; either version 2 of the License, or (at your      */
   8 /* option) any later version.                                                  */
   9 /*                                                                             */
  10 /* This program is distributed in the hope that it will be useful, but WITHOUT */
  11 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       */
  12 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for   */
  13 /* more details.                                                               */
  14 /*                                                                             */
  15 /* You should have received a copy of the GNU General Public License along     */
  16 /* with This program; see the file COPYING.  If not,write to the Free Software */
  17 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18 /*******************************************************************************/
  19
  20 /* This class handles all journaling. All journaled objects must
  21    inherit from Loggable as well as define a few special methods (via
  22    macros), get and set methods, and have contructors and destructors
  23    that call log_create() and log_destroy() in the appropriate
  24    order. Any action that might affect multiple loggable objects
  25    *must* be braced by calls to Loggable::block_start() and
  26    Loggable::block_end() in order for Undo to work properly. */
  27
  28 #include "Loggable.H"
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #include "file.h"
  35
  36 // #include "const.h"
  37 #include "debug.h"
  38
  39 #include <algorithm>
  40 using std::min;
  41 using std::max;
  42
  43 \f
  44
  45 FILE *Loggable::_fp;
  46 unsigned int Loggable::_log_id = 0;
  47 int Loggable::_level = 0;
  48 int Loggable::_dirty = 0;
  49 off_t Loggable::_undo_offset = 0;
  50
  51 std::map <unsigned int, Loggable::log_pair > Loggable::_loggables;
  52
  53 std::map <std::string, create_func*> Loggable::_class_map;
  54 std::queue <char *> Loggable::_transaction;
  55
  56 progress_func *Loggable::_progress_callback = NULL;
  57 void *Loggable::_progress_callback_arg = NULL;
  58
  59 snapshot_func *Loggable::_snapshot_callback = NULL;
  60 void *Loggable::_snapshot_callback_arg = NULL;
  61
  62 dirty_func *Loggable::_dirty_callback = NULL;
  63 void *Loggable::_dirty_callback_arg = NULL;
  64
  65 \f
  66
  67 Loggable::~Loggable ( )
  68 {
  69     _loggables[ _id ].loggable = NULL;
  70 }
  71
  72 \f
  73
  74 void
  75 Loggable::block_start ( void )
  76 {
  77     ++Loggable::_level;
  78 }
  79
  80 void
  81 Loggable::block_end ( void )
  82 {
  83     --Loggable::_level;
  84
  85     ASSERT( Loggable::_level >= 0, "Programming error" );
  86
  87     if ( Loggable::_level == 0 )
  88         flush();
  89 }
  90
  91 Loggable *
  92 Loggable::find ( unsigned int id )
  93 {
  94     if ( _relative_id )
  95         id += _relative_id;
  96
  97     return _loggables[ id ].loggable;
  98 }
  99
 100 /** Open the journal /filename/ and replay it, bringing the end state back into RAM */
 101 bool
 102 Loggable::open ( const char *filename )
 103 {
 104     FILE *fp;
 105
 106     Loggable::_fp = NULL;
 107
 108     if ( ! ( fp = fopen( filename, "a+" ) ) )
 109     {
 110         WARNING( "Could not open log file for writing!" );
 111         return false;
 112     }
 113
 114     load_unjournaled_state();
 115
 116     if ( newer( "snapshot", filename ) )
 117     {
 118         MESSAGE( "Loading snapshot" );
 119
 120         FILE *fp = fopen( "snapshot", "r" );
 121
 122         replay( fp );
 123
 124         fclose( fp );
 125     }
 126     else
 127     {
 128         MESSAGE( "Replaying journal" );
 129
 130         replay( fp );
 131     }
 132
 133     fseek( fp, 0, SEEK_END );
 134     _undo_offset = ftell( fp );
 135
 136     Loggable::_fp = fp;
 137
 138     return true;
 139 }
 140
 141 bool
 142 Loggable::load_unjournaled_state ( void )
 143 {
 144     FILE *fp;
 145
 146     fp = fopen( "unjournaled", "r" );
 147
 148     if ( ! fp )
 149     {
 150         DWARNING( "Could not open unjournaled state file for reading" );
 151         return false;
 152     }
 153
 154     unsigned int id;
 155     char buf[BUFSIZ];
 156
 157     while ( fscanf( fp, "%X set %[^\n]\n", &id, buf ) == 2 )
 158         _loggables[ id ].unjournaled_state = new Log_Entry( buf );
 159
 160     fclose( fp );
 161
 162     return true;
 163 }
 164
 165 #include <sys/stat.h>
 166 #include <unistd.h>
 167
 168 /** replay journal or snapshot */
 169 bool
 170 Loggable::replay ( const char *file )
 171 {
 172     if ( FILE *fp = fopen( file, "r" ) )
 173     {
 174         bool r = replay( fp );
 175
 176         fclose( fp );
 177
 178         return r;
 179     }
 180     else
 181         return false;
 182 }
 183
 184 /** replay journal or snapshot */
 185 bool
 186 Loggable::replay ( FILE *fp )
 187 {
 188     /* FIXME: bogus */
 189     char buf[BUFSIZ];
 190
 191     struct stat st;
 192     fstat( fileno( fp ), &st );
 193
 194     off_t total = st.st_size;
 195     off_t current = 0;
 196
 197     if ( _progress_callback )
 198         _progress_callback( 0, _progress_callback_arg );
 199
 200     while ( fscanf( fp, "%[^\n]\n", buf ) == 1 )
 201     {
 202         if ( ! ( ! strcmp( buf, "{" ) || ! strcmp( buf, "}" ) ) )
 203         {
 204             if ( *buf == '\t' )
 205                 do_this( buf + 1, false );
 206             else
 207                 do_this( buf, false );
 208         }
 209
 210         current = ftell( fp );
 211
 212         if ( _progress_callback )
 213             _progress_callback( current * 100 / total, _progress_callback_arg );
 214     }
 215
 216     if ( _progress_callback )
 217         _progress_callback( 0, _progress_callback_arg );
 218
 219     clear_dirty();
 220
 221     return true;
 222 }
 223
 224 /** close journal and delete all loggable objects, returing the systemt to a blank slate */
 225 bool
 226 Loggable::close ( void )
 227 {
 228     DMESSAGE( "closing journal and destroying all journaled objects" );
 229
 230     if ( _fp )
 231     {
 232         fclose( _fp );
 233         _fp = NULL;
 234     }
 235
 236     if ( ! snapshot( "snapshot" ) )
 237         WARNING( "Failed to create snapshot" );
 238
 239     for ( std::map <unsigned int, Loggable::log_pair >::iterator i = _loggables.begin();
 240           i != _loggables.end(); ++i )
 241         if ( i->second.loggable )
 242             delete i->second.loggable;
 243
 244     save_unjournaled_state();
 245
 246     for ( std::map <unsigned int, Loggable::log_pair >::iterator i = _loggables.begin();
 247           i != _loggables.end(); ++i )
 248         if ( i->second.unjournaled_state )
 249             delete i->second.unjournaled_state;
 250
 251     _loggables.clear();
 252
 253     return true;
 254 }
 255
 256
 257 /** save out unjournaled state for all loggables */
 258 bool
 259 Loggable::save_unjournaled_state ( void )
 260 {
 261     FILE *fp;
 262
 263     fp = fopen( "unjournaled", "w" );
 264
 265     if ( ! fp )
 266     {
 267         DWARNING( "Could not open unjournaled state file for writing!" );
 268         return false;
 269     }
 270
 271     for ( std::map <unsigned int, Loggable::log_pair >::iterator i = _loggables.begin();
 272           i != _loggables.end(); ++i )
 273     {
 274         if ( i->second.unjournaled_state )
 275         {
 276             char *s = i->second.unjournaled_state->print();
 277
 278             fprintf( fp, "0x%X set %s\n", i->first, s );
 279
 280             free( s );
 281         }
 282     }
 283
 284     fclose( fp );
 285
 286     return true;
 287 }
 288
 289 /** must be called after construction in create() methods */
 290 void
 291 Loggable::update_id ( unsigned int id )
 292 {
 293     /* make sure we're the last one */
 294     ASSERT( _id == _log_id, "%u != %u", _id, _log_id );
 295     assert( _loggables[ _id ].loggable == this );
 296
 297     _loggables[ _id ].loggable = NULL;
 298
 299     _log_id = max( _log_id, id );
 300
 301     /* return this id number to the system */
 302 //            --_log_id;
 303
 304     _id = id;
 305
 306     if ( _loggables[ _id ].loggable )
 307         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() );
 308
 309     _loggables[ _id ].loggable = this;
 310 }
 311
 312 /** return a pointer to a static copy of /s/ with all special characters escaped */
 313 const char *
 314 Loggable::escape ( const char *s )
 315 {
 316     static char r[512];
 317
 318     size_t i = 0;
 319     for ( ; *s && i < sizeof( r ); ++i, ++s )
 320     {
 321         if ( '\n' == *s )
 322         {
 323             r[ i++ ] = '\\';
 324             r[ i ] = 'n';
 325         }
 326         else if ( '"' == *s )
 327         {
 328             r[ i++ ] = '\\';
 329             r[ i ] = '"';
 330         }
 331         else
 332             r[ i ] = *s;
 333     }
 334
 335     r[ i ] = '\0';
 336
 337     return r;
 338 }
 339
 340 unsigned int Loggable::_relative_id = 0;
 341
 342 /* calls to do_this() between invocation of this method and
 343  * end_relative_id_mode() will have all their IDs made relative to the
 344  * highest available ID at this time of this call. Non-Mixer uses
 345  * this to allow importing of module chains */
 346 void
 347 Loggable::begin_relative_id_mode ( void )
 348 {
 349     _relative_id = ++_log_id;
 350 }
 351
 352 void
 353 Loggable::end_relative_id_mode ( void )
 354 {
 355     _relative_id = 0;
 356 }
 357
 358
 359 /** 'do' a message like "Audio_Region 0xF1 set :r 123" */
 360 bool
 361 Loggable::do_this ( const char *s, bool reverse )
 362 {
 363     unsigned int id = 0;
 364
 365     char classname[40];
 366     char command[40];
 367     char *arguments = NULL;
 368
 369     int found = sscanf( s, "%s %X %s ", classname, &id, command );
 370
 371     ASSERT( 3 == found,  "Invalid journal entry format \"%s\"", s );
 372
 373     const char *create, *destroy;
 374
 375     if ( reverse )
 376     {
 377 //        sscanf( s, "%s %*X %s %*[^\n<]<< %a[^\n]", classname, command, &arguments );
 378         sscanf( s, "%s %*X %s%*[^\n<]<< %a[^\n]", classname, command, &arguments );
 379         create = "destroy";
 380         destroy = "create";
 381
 382         DMESSAGE( "undoing \"%s\"", s );
 383     }
 384     else
 385     {
 386         sscanf( s, "%s %*X %s %a[^\n<]", classname, command, &arguments );
 387         create = "create";
 388         destroy = "destroy";
 389     }
 390
 391     if ( ! strcmp( command, destroy ) )
 392     {
 393         Loggable *l = find( id );
 394
 395         /* deleting eg. a track, which contains a list of other
 396            widgets, causes destroy messages to be emitted for all those
 397            widgets, but when replaying the journal the destroy message
 398            causes the children to be deleted also... This is a temporary
 399            hack. Would it be better to queue up objects for deletion
 400            (when?) */
 401         if ( l )
 402             delete l;
 403     }
 404     else if ( ! strcmp( command, "set" ) )
 405     {
 406 //        printf( "got set command (%s).\n", arguments );
 407
 408         Loggable *l = find( id );
 409
 410         ASSERT( l, "Unable to find object 0x%X referenced by command \"%s\"", id, s );
 411
 412         Log_Entry e( arguments );
 413
 414         l->log_start();
 415         l->set( e );
 416         l->log_end();
 417     }
 418     else if ( ! strcmp( command, create ) )
 419     {
 420         Log_Entry e( arguments );
 421
 422         ASSERT( _class_map[ std::string( classname ) ], "Journal contains an object of class \"%s\", but I don't know how to create such objects.", classname );
 423
 424         {
 425             if ( _relative_id )
 426                 id += _relative_id;
 427
 428             /* create */
 429             Loggable *l = _class_map[ std::string( classname ) ]( e, id );
 430             l->log_create();
 431
 432             /* we're now creating a loggable. Apply any unjournaled
 433              * state it may have had in the past under this log ID */
 434
 435             Log_Entry *e = _loggables[ id ].unjournaled_state;
 436
 437             if ( e )
 438                 l->set( *e );
 439         }
 440
 441     }
 442
 443     if ( arguments )
 444         free( arguments );
 445
 446     return true;
 447 }
 448
 449 /** Reverse the last journal transaction */
 450 void
 451 Loggable::undo ( void )
 452 {
 453     const int bufsiz = 1024;
 454     char buf[bufsiz];
 455
 456     block_start();
 457
 458     long here = ftell( _fp );
 459
 460     fseek( _fp, _undo_offset, SEEK_SET );
 461
 462     backwards_fgets( buf, bufsiz, _fp );
 463
 464     if ( ! strcmp( buf, "}\n" ) )
 465     {
 466         DMESSAGE( "undoing block" );
 467         for ( ;; )
 468         {
 469             backwards_fgets( buf, bufsiz, _fp );
 470
 471             char *s = buf;
 472             if ( *s != '\t' )
 473                 break;
 474             else
 475                 ++s;
 476
 477             do_this( s, true );
 478         }
 479     }
 480     else
 481         do_this( buf, true );
 482
 483     off_t uo = ftell( _fp );
 484
 485     ASSERT( _undo_offset <= here, "WTF?" );
 486
 487     block_end();
 488
 489     _undo_offset = uo;
 490 }
 491
 492 /** write a snapshot of the current state of all loggable objects to
 493  * file handle /fp/ */
 494 bool
 495 Loggable::snapshot ( FILE *fp )
 496 {
 497     FILE *ofp = _fp;
 498
 499     if ( ! Loggable::_snapshot_callback )
 500     {
 501         DWARNING( "No snapshot callback defined" );
 502         return false;
 503     }
 504
 505     if ( ! ( _fp = fp ) )
 506     {
 507         _fp = ofp;
 508         return false;
 509     }
 510
 511     block_start();
 512
 513     Loggable::_snapshot_callback( _snapshot_callback_arg );
 514
 515     block_end();
 516
 517     _fp = ofp;
 518
 519     clear_dirty();
 520
 521     return true;
 522 }
 523
 524 /** write a snapshot of the current state of all loggable objects to
 525  * file /name/ */
 526 bool
 527 Loggable::snapshot ( const char *name )
 528 {
 529     FILE *fp;
 530
 531     if ( ! ( fp = fopen( name, "w" ) ))
 532         return false;
 533
 534     bool r = snapshot( fp );
 535
 536     fclose( fp );
 537
 538     return r;
 539 }
 540
 541 /** Replace the journal with a snapshot of the current state */
 542 void
 543 Loggable::compact ( void )
 544 {
 545     fseek( _fp, 0, SEEK_SET );
 546     ftruncate( fileno( _fp ), 0 );
 547
 548     if ( ! snapshot( _fp ) )
 549         FATAL( "Could not write snapshot!" );
 550
 551     fseek( _fp, 0, SEEK_END );
 552 }
 553
 554 #include <stdarg.h>
 555
 556 /** Writes (part of) a line to the journal. Each separate line will be
 557  * stored separately in _transaction until transaction is closed.
 558  */
 559 void
 560 Loggable::log ( const char *fmt, ... )
 561 {
 562     static char * buf = NULL;
 563     static size_t i = 0;
 564     static size_t buf_size = 0;
 565
 566     if ( ! _fp )
 567         return;
 568
 569     if ( NULL == buf )
 570     {
 571         buf_size = 1024;
 572         buf = (char*)malloc( buf_size );
 573     }
 574
 575     va_list args;
 576
 577     if ( fmt )
 578     {
 579         va_start( args, fmt );
 580
 581         for ( ;; )
 582         {
 583             size_t l = vsnprintf( buf + i, buf_size - i, fmt, args );
 584
 585             if ( l >= buf_size - i )
 586             {
 587                 buf = (char*)realloc( buf, buf_size += (l + 1) + buf_size );
 588             }
 589             else
 590             {
 591                 i += l;
 592                 break;
 593             }
 594         }
 595
 596         va_end( args );
 597     }
 598
 599     if ( '\n' == buf[i-1] )
 600     {
 601         _transaction.push( strdup( buf ) );
 602         i = 0;
 603     }
 604 }
 605
 606 /** End the current transaction and commit it to the journal */
 607 void
 608 Loggable::flush ( void )
 609 {
 610     if ( ! _fp )
 611     {
 612 //        printf( "error: no log file open!\n" );
 613
 614         while ( ! _transaction.empty() )
 615         {
 616             free( _transaction.front() );
 617             _transaction.pop();
 618         }
 619
 620         return;
 621     }
 622
 623     int n = _transaction.size();
 624
 625     if ( n > 1 )
 626         fprintf( _fp, "{\n" );
 627
 628     while ( ! _transaction.empty() )
 629     {
 630         char *s = _transaction.front();
 631
 632         _transaction.pop();
 633
 634         if ( n > 1 )
 635             fprintf( _fp, "\t" );
 636
 637         fprintf( _fp, "%s", s );
 638
 639         free( s );
 640     }
 641
 642     if ( n > 1 )
 643         fprintf( _fp, "}\n" );
 644
 645     if ( n )
 646         /* something done, reset undo index */
 647         _undo_offset = ftell( _fp );
 648
 649     fflush( _fp );
 650 }
 651
 652 /** Print bidirectional journal entry */
 653 void
 654 Loggable::log_print( const Log_Entry *o, const Log_Entry *n ) const
 655 {
 656     if ( ! _fp )
 657         return;
 658
 659     if ( n )
 660         for ( int i = 0; i < n->size(); ++i )
 661         {
 662             const char *s, *v;
 663
 664             n->get( i, &s, &v );
 665
 666             log( "%s %s%s", s, v, n->size() == i + 1 ? "" : " " );
 667         }
 668
 669     if ( o && o->size() )
 670     {
 671         if ( n ) log( " << " );
 672
 673         for ( int i = 0; i < o->size(); ++i )
 674         {
 675             const char *s, *v;
 676
 677             o->get( i, &s, &v );
 678
 679             log( "%s %s%s", s, v, o->size() == i + 1 ? "" : " " );
 680         }
 681     }
 682
 683     log( "\n" );
 684 }
 685
 686 /** Remember current object state for later comparison. *Must* be
 687  * called before any user action that might change one of the object's
 688  * journaled properties.  */
 689 void
 690 Loggable::log_start ( void )
 691 {
 692     if ( ! _old_state )
 693     {
 694         _old_state = new Log_Entry;
 695
 696         get( *_old_state );
 697     }
 698     ++_nest;
 699 }
 700
 701 /** Log any change to the object's state since log_start(). */
 702 void
 703 Loggable::log_end ( void )
 704 {
 705     ASSERT( _old_state, "Programming error: log_end() called before log_start()" );
 706
 707     if ( --_nest > 0 )
 708         return;
 709
 710     Log_Entry *new_state;
 711
 712     new_state = new Log_Entry;
 713
 714     get( *new_state );
 715
 716     if ( Log_Entry::diff( _old_state, new_state ) )
 717     {
 718         log( "%s 0x%X set ", class_name(), _id );
 719
 720         log_print( _old_state, new_state );
 721
 722         set_dirty();
 723     }
 724
 725     delete new_state;
 726     delete _old_state;
 727
 728     _old_state = NULL;
 729
 730     if ( Loggable::_level == 0 )
 731         Loggable::flush();
 732 }
 733
 734 /** Log object creation. *Must* be called at the end of all public
 735  * constructors for leaf classes  */
 736
 737 void
 738 Loggable::log_create ( void ) const
 739 {
 740     set_dirty();
 741
 742     if ( ! _fp )
 743         /* replaying, don't bother */
 744         return;
 745
 746     log( "%s 0x%X create ", class_name(), _id );
 747
 748     Log_Entry e;
 749
 750     get( e );
 751
 752     if ( e.size() )
 753         log_print( NULL, &e );
 754     else
 755         log( "\n" );
 756
 757     if ( Loggable::_level == 0 )
 758         Loggable::flush();
 759 }
 760
 761 /** record this loggable's unjournaled state in memory */
 762 void
 763 Loggable::record_unjournaled ( void ) const
 764 {
 765     Log_Entry *e = new Log_Entry();
 766
 767     get_unjournaled( *e );
 768
 769     Log_Entry *le = _loggables[ _id ].unjournaled_state;
 770
 771     if ( le )
 772         delete le;
 773
 774     if ( e->size() )
 775         _loggables[ _id ].unjournaled_state = e;
 776     else
 777     {
 778         /* don't waste space on loggables with no unjournaled properties */
 779         _loggables[ _id ].unjournaled_state = NULL;
 780         delete e;
 781     }
 782 }
 783
 784 /** Log object destruction. *Must* be called at the beginning of the
 785  * destructors of leaf classes */
 786 void
 787 Loggable::log_destroy ( void ) const
 788 {
 789     /* the unjournaled state may have changed: make a note of it. */
 790     record_unjournaled();
 791
 792     set_dirty();
 793
 794     if ( ! _fp )
 795         /* tearing down... don't bother */
 796         return;
 797
 798     log( "%s 0x%X destroy << ", class_name(), _id );
 799
 800     Log_Entry e;
 801
 802     get( e );
 803
 804     log_print( NULL, &e );
 805
 806     if ( Loggable::_level == 0 )
 807         Loggable::flush();
 808 }