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