TAO/tao/Storable_File_Guard.cpp

   1 //=============================================================================
   2 /**
   3  *  @file   Storable_File_Guard.cpp
   4  *
   5  *  @author Rich Seibel (seibelr@ociweb.com)
   6  *  @author Byron Harris (harrisb@ociweb.com)
   7  */
   8 //=============================================================================
   9
  10 #include "tao/Storable_File_Guard.h"
  11 #include "tao/Storable_Base.h"
  12
  13 #include "tao/SystemException.h"
  14 #include "tao/debug.h"
  15
  16 TAO::Storable_File_Guard::
  17 Storable_File_Guard (bool redundant, bool use_backup)
  18   : fl_(nullptr)
  19   , redundant_(redundant)
  20   , closed_(1)
  21   , rwflags_(0)
  22   , use_backup_(use_backup)
  23 {
  24 }
  25
  26 TAO::Storable_File_Guard::
  27 ~Storable_File_Guard () noexcept(false)
  28 {
  29   delete fl_;
  30 }
  31
  32 void
  33 TAO::Storable_File_Guard::init_no_load(Method_Type method_type)
  34 {
  35   ACE_CString mode;
  36   this->rwflags_ = 0;
  37   switch (method_type)
  38     {
  39     case ACCESSOR:
  40     case CREATE_WITH_FILE:
  41       mode = "r";
  42       this->rwflags_ = mode_read;
  43       break;
  44     case CREATE_WITHOUT_FILE:
  45       mode = "rwc";
  46       this->rwflags_ = mode_write | mode_create;
  47       break;
  48     case MUTATOR:
  49       mode = "rw";
  50       this->rwflags_ = mode_read | mode_write;
  51       break;
  52     }
  53
  54   if( rwflags_ <= 0 )
  55     {
  56       errno = EINVAL;
  57       if (TAO_debug_level > 0)
  58         {
  59           TAOLIB_DEBUG ((LM_DEBUG,
  60                          ACE_TEXT ("(%P|%t) Storable_File_Guard:Invalid ")
  61                          ACE_TEXT ("flags\n")));
  62         }
  63       throw CORBA::PERSIST_STORE();
  64     }
  65
  66   // Create the stream
  67   fl_ = this->create_stream(mode.c_str ());
  68 }
  69
  70 void
  71 TAO::Storable_File_Guard::reload ()
  72 {
  73   if (redundant_)
  74     {
  75       if (fl_->open () != 0)
  76         {
  77           if (TAO_debug_level > 0)
  78             {
  79               TAOLIB_DEBUG ((LM_DEBUG,
  80                              ACE_TEXT ("(%P|%t) Storable_File_Guard::Open ")
  81                              ACE_TEXT ("failed in redundant\n")));
  82             }
  83           throw CORBA::PERSIST_STORE();
  84         }
  85
  86       // acquire a lock on it
  87       if (fl_->flock (0, 0, 0) != 0)
  88         {
  89           fl_->close ();
  90           if (TAO_debug_level > 0)
  91             {
  92               TAOLIB_DEBUG ((LM_DEBUG,
  93                              ACE_TEXT ("(%P|%t) Storable_File_Guard:flock ")
  94                              ACE_TEXT ("failed in redundant\n")));
  95             }
  96           throw CORBA::INTERNAL();
  97         }
  98
  99       // now that the file is successfully opened and locked it must be
 100       // unlocked/closed before we leave this class
 101       closed_ = 0;
 102
 103       if ( ! (rwflags_ & mode_create) )
 104         {
 105           // Check if our copy is up to date
 106           if (this->object_obsolete ())
 107             {
 108               this->mark_object_current ();
 109               this->load ();
 110             }
 111         }
 112     }
 113   else if ( ! this->is_loaded_from_stream () || (rwflags_ & mode_write) )
 114     {
 115       bool file_has_data = fl_->exists ();
 116
 117       if (fl_->open () != 0)
 118         {
 119           if (TAO_debug_level > 0)
 120             {
 121               TAOLIB_DEBUG ((LM_DEBUG,
 122                              ACE_TEXT ("(%P|%t) Storable_File_Guard:Open ")
 123                              ACE_TEXT ("failed in non-redundant\n")));
 124             }
 125           throw CORBA::PERSIST_STORE ();
 126         }
 127
 128       // now that the file is successfully opened
 129       // unlocked/closed before we leave this class
 130       closed_ = 0;
 131
 132       if (file_has_data && ! this->is_loaded_from_stream ())
 133         {
 134           this->load ();
 135         }
 136     }
 137 }
 138
 139 void
 140 TAO::Storable_File_Guard::init(Method_Type method_type)
 141 {
 142   this->init_no_load (method_type);
 143   this->reload ();
 144 }
 145
 146 bool
 147 TAO::Storable_File_Guard::object_obsolete ()
 148 { // Default implementation uses time to determine
 149   // if obsolete.
 150   return (fl_->last_changed () > this->get_object_last_changed ());
 151 }
 152
 153 void
 154 TAO::Storable_File_Guard::mark_object_current ()
 155 { // Default implementation is to set the last changed
 156   // time to that of the file lock.
 157   this->set_object_last_changed (fl_->last_changed ());
 158 }
 159
 160 void
 161 TAO::Storable_File_Guard::release ()
 162 {
 163   if ( ! closed_ )
 164     {
 165       if (this->use_backup_ &&
 166           (rwflags_ & mode_write) != 0)
 167         {
 168           fl_->create_backup ();
 169         }
 170
 171       // If we updated the disk, save the time stamp
 172       if(redundant_)
 173         {
 174           if( rwflags_ & mode_write )
 175             {
 176               // This is a costly call, but necessary if
 177               // we are running redundant. It ensures that
 178               // the data is written to disk.
 179               fl_->sync ();
 180
 181               this->mark_object_current ();
 182             }
 183
 184           // Release the lock
 185           fl_->funlock (0, 0, 0);
 186         }
 187       fl_->close ();
 188       closed_ = 1;
 189     }
 190
 191 }
 192
 193 TAO::Storable_Base &
 194 TAO::Storable_File_Guard::peer ()
 195 {
 196   return *fl_;
 197 }
 198
 199 int
 200 TAO::Storable_File_Guard::load ()
 201 {
 202   int result = 0;
 203   if (!this->use_backup_)
 204     { // Not using a backup file. Just attempt to
 205       // load from the stream and return.
 206       return this->load_from_stream ();
 207     }
 208
 209   // We are using a backup.
 210   try
 211     {
 212       // Attempt to load from the stream from the primary.
 213       result = this->load_from_stream ();
 214     }
 215   catch (const Storable_Read_Exception &ex)
 216     { // Failed to load from primary.
 217       ACE_CString state_str = Storable_Base::state_as_string (ex.get_state());
 218
 219       TAOLIB_ERROR ((LM_ERROR,
 220                      ACE_TEXT ("TAO: (%P|%t) ERROR: State %s ")
 221                      ACE_TEXT ("encountered reading persistent ")
 222                      ACE_TEXT ("state from file\n%s\n"),
 223                      state_str.c_str (), ex.get_file_name().c_str ()));
 224
 225       // The following opens the backup file, and copies it
 226       // to the primary file location.
 227       result = this->fl_->restore_backup ();
 228
 229       // result of 0 means OK. We should now have a good primary file.
 230       if (!result)
 231         {
 232           TAOLIB_ERROR ((LM_INFO,
 233                          ACE_TEXT ("TAO: (%P|%t) Attempting to restore ")
 234                          ACE_TEXT ("from backup\n")));
 235
 236           try
 237             { // Load the data from the newly restored primary.
 238               result = this->load_from_stream ();
 239             }
 240           catch (const Storable_Read_Exception&)
 241             { // Still having trouble reading from the file. Time to bail.
 242               TAOLIB_ERROR ((LM_ERROR,
 243                              ACE_TEXT ("TAO: (%P|%t) ERROR: Unable to restore ")
 244                              ACE_TEXT ("the state from backup.\n")));
 245               throw;
 246             }
 247           TAOLIB_ERROR ((LM_INFO,
 248                          ACE_TEXT ("TAO: (%P|%t) The state was restored ")
 249                          ACE_TEXT ("from backup.\n")));
 250         }
 251       else
 252         {
 253           TAOLIB_ERROR ((LM_ERROR,
 254                          ACE_TEXT ("TAO: (%P|%t) ERROR: Could not read ")
 255                          ACE_TEXT ("backup file\n")));
 256           throw;
 257         }
 258
 259     }
 260
 261   // Return a result value for the load operation.
 262   return result;
 263 }