ssphys/SSPhys/GetCommand.cpp

   1 // GetCommand.cpp: implementation of the GetCommand class.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4
   5 #include "stdafx.h"
   6 #include "GetCommand.h"
   7 #include <SSPhysLib\SSFiles.h>
   8 #include <SSPhysLib\SSItemInfoObject.h>
   9 #include <SSPhysLib\SSVersionObject.h>
  10 #include <SSPhysLib\FileName.h>
  11 #include <SSPhysLib\SSProjectObject.h>
  12 #include <io.h>
  13 #include <fcntl.h>
  14 #include <fstream>
  15 #include <strstream>
  16
  17 #include "windows.h"
  18 //////////////////////////////////////////////////////////////////////
  19 // Construction/Destruction
  20 //////////////////////////////////////////////////////////////////////
  21 bool fexists (const char* file)
  22 {
  23   FILE* pFile = fopen (file, "r");
  24   if (pFile)
  25   {
  26     fclose (pFile);
  27     return true;
  28   }
  29   return false;
  30 }
  31
  32 //---------------------------------------------------------------------------
  33 CGetCommand::CGetCommand ()
  34   : CCommand ("get"),
  35     m_Version (-1),
  36     m_bForceOverwrite (false),
  37     m_bBulkGet (false)
  38 {
  39 }
  40
  41 COptionInfoList CGetCommand::GetOptionsInfo () const
  42 {
  43   COptionInfoList options = CCommand::GetOptionsInfo();
  44   options.push_back (COptionInfo ('v', 'v', "version", "version to get", COptionInfo::requiredArgument));
  45   options.push_back (COptionInfo ('f', 'f', "force-overwrite", "overwrite target file", COptionInfo::noArgument));
  46   options.push_back (COptionInfo ('b', 'b', "bulk", "bulk operation: get all intermediate files with the same name as the source name", COptionInfo::noArgument));
  47   return options;
  48 }
  49
  50 bool CGetCommand::SetOption (const COption& option)
  51 {
  52   switch (option.id)
  53   {
  54   case 'v':
  55     m_Version = atoi ((const char*) option.value);
  56     break;
  57   case 'f':
  58     m_bForceOverwrite = true;
  59     break;
  60   case 'b':
  61     m_bBulkGet = true;
  62     break;
  63   default:
  64     return false;
  65   }
  66   return true;
  67 }
  68
  69 bool CGetCommand::SetArguments (CArguments& args)
  70 {
  71   if (args.empty ())
  72     throw SSException ("no argument");
  73
  74   m_PhysFile = args.front ();
  75   args.pop ();
  76
  77   if (args.empty ())
  78     throw SSException ("missing argument");
  79
  80   m_DestFile = args.front ();
  81   args.pop ();
  82
  83   return true;
  84
  85 }
  86
  87
  88 class CActionVisitor : public ISSActionVisitor
  89 {
  90 public:
  91   virtual ~CActionVisitor () {}
  92
  93   virtual bool Apply (const SSLabeledAction& rAction)           { return Apply ((const SSAction&) rAction); }
  94 //  virtual bool Apply (const SSSingleFileAction& rAction)      { return Apply ((const SSAction&) rAction); }
  95   virtual bool Apply (const SSCreatedProjectAction& rAction)    { return Apply ((const SSAction&) rAction); }
  96   virtual bool Apply (const SSCreatedFileAction& rAction)       { return Apply ((const SSAction&) rAction); }
  97   virtual bool Apply (const SSAddedProjectAction& rAction)      { return Apply ((const SSAction&) rAction); }
  98   virtual bool Apply (const SSAddedFileAction& rAction)         { return Apply ((const SSAction&) rAction); }
  99   virtual bool Apply (const SSDeletedProjectAction& rAction)    { return Apply ((const SSAction&) rAction); }
 100   virtual bool Apply (const SSDeletedFileAction& rAction)       { return Apply ((const SSAction&) rAction); }
 101   virtual bool Apply (const SSRecoveredProjectAction& rAction)  { return Apply ((const SSAction&) rAction); }
 102   virtual bool Apply (const SSRecoveredFileAction& rAction)     { return Apply ((const SSAction&) rAction); }
 103   virtual bool Apply (const SSRollbackAction& rAction)          { return Apply ((const SSAction&) rAction); }
 104
 105   virtual bool Apply (const SSDestroyedProjectAction& rAction)  { return Apply ((const SSAction&) rAction); }
 106   virtual bool Apply (const SSDestroyedFileAction& rAction)     { return Apply ((const SSAction&) rAction); }
 107   virtual bool Apply (const SSRenamedProjectAction& rAction)    { return Apply ((const SSAction&) rAction); }
 108   virtual bool Apply (const SSRenamedFileAction& rAction)       { return Apply ((const SSAction&) rAction); }
 109   virtual bool Apply (const SSCheckedInAction& rAction)         { return Apply ((const SSAction&) rAction); }
 110   virtual bool Apply (const SSSharedAction& rAction)            { return Apply ((const SSAction&) rAction); }
 111
 112 protected:
 113   virtual bool Apply (const SSAction& rAction)
 114   {
 115     return true;
 116   }
 117 };
 118
 119
 120 std::string CreateTempFile ( const char* pzPrefix = NULL, const char* pzPath = NULL)
 121 {
 122   return tempnam( pzPath, pzPrefix );
 123 //  while( true )
 124   {
 125 //    std::string cPath = tempnam( pzPath, pzPrefix );
 126 //        if (Open (cPath, O_RDWR | O_CREAT | O_EXCL ) < 0)
 127 //    {
 128 //          if ( errno == EEXIST )
 129 //      {
 130 //                  continue;
 131 //          }
 132 //      else
 133 //      {
 134 ////                throw errno_exception( "Failed to create file" );
 135 //          }
 136 //        }
 137 //    else
 138 //    {
 139 //          Close ();
 140 //      break;
 141 //        }
 142   }
 143 }
 144
 145 class CAutoFile
 146 {
 147 public:
 148   CAutoFile (std::string name, bool bDelete = true)
 149     : m_FileName (name),
 150       m_bDeleteFile (bDelete)
 151   {
 152   }
 153
 154   CAutoFile (CAutoFile const & r)
 155     : m_bDeleteFile (r.m_bDeleteFile),
 156       m_FileName (r.Detatch ())
 157   {
 158   }
 159
 160   CAutoFile& operator= (CAutoFile const & r)
 161   {
 162     if (this != &r)
 163     {
 164       if (m_FileName != r.GetPath())
 165       {
 166         if (m_bDeleteFile)
 167           Unlink ();
 168         m_bDeleteFile = r.m_bDeleteFile;
 169       }
 170       else if (r.m_bDeleteFile)
 171         m_bDeleteFile = r.m_bDeleteFile;
 172       m_FileName = r.Detatch();
 173     }
 174     return (*this);
 175   }
 176
 177   ~CAutoFile()
 178   {
 179     if (m_bDeleteFile)
 180       Unlink ();
 181   }
 182
 183   std::string     GetPath () const  { return m_FileName; }
 184
 185   std::string Detatch() const;
 186   int Unlink();
 187
 188 protected:
 189
 190   std::string m_FileName;
 191   mutable bool m_bDeleteFile;
 192 };
 193
 194 std::string CAutoFile::Detatch() const
 195 {
 196   m_bDeleteFile = false;
 197   return m_FileName;
 198 }
 199
 200 int CAutoFile::Unlink()
 201 {
 202   if ( m_bDeleteFile )
 203   {
 204           m_bDeleteFile = false;
 205           return( unlink( m_FileName.c_str () ) );
 206   }
 207   else
 208   {
 209           return( 0 );
 210   }
 211 }
 212
 213
 214
 215 class CReverseDelta
 216 {
 217 public:
 218   CReverseDelta (const char* buffer, size_t length)
 219     : m_pBuffer (buffer), m_length (length)
 220   {
 221   }
 222
 223   bool operator () (std::istream& input, std::ostream& output) const
 224   {
 225     for (long i = 0; i < m_length; )
 226     {
 227       const FD* pfd = (const FD*) (m_pBuffer+i);
 228       i += sizeof(FD);
 229 //      printf ("fd: %d, start %d, len %d\n", pfd->command, pfd->start, pfd->end);
 230
 231       switch (pfd->command)
 232       {
 233       case 2:
 234         // assert finito
 235         break;
 236       case 1:
 237         {
 238           char b[256];
 239           long size = pfd->end;
 240           input.seekg(pfd->start);
 241           if (input.fail ())
 242             throw SSException ("reverse delta: invalid seek beyond file size");
 243
 244           while (size > 0)
 245           {
 246             long s = __min (size, sizeof (b));
 247             input.read (b, s);
 248             output.write (b, s);
 249             size -= s;
 250           }
 251         }
 252         break;
 253       case 0:
 254         output.write (m_pBuffer+i, pfd->end);
 255         i += pfd->end;
 256         break;
 257       default:
 258         std::strstream msg;
 259         msg << "unknown reverse delta command " << pfd->command;
 260         throw SSException (msg.str());
 261         break;
 262       }
 263     }
 264
 265     return true;
 266   }
 267 protected:
 268   const char* m_pBuffer;
 269   size_t m_length;
 270 };
 271
 272
 273 class CHistoryHandler : public CActionVisitor
 274 {
 275 public:
 276   CHistoryHandler (std::string src)
 277     : m_File (src, false)
 278   {
 279   }
 280
 281   std::string GetPath ()
 282   {
 283     return m_File.GetPath();
 284   }
 285
 286   virtual bool SaveAs (std::string name, bool overwrite = false) = 0;
 287
 288 protected:
 289   CAutoFile m_File;
 290
 291 };
 292
 293 class CReverseHistoryHandler : public CHistoryHandler
 294 {
 295 public:
 296   CReverseHistoryHandler (std::string src)
 297     : CHistoryHandler (src)
 298   {
 299   }
 300
 301   virtual bool Apply (const SSCheckedInAction& rAction)
 302   {
 303     SSRecordPtr pRecord = rAction.GetFileDelta();
 304     CAutoFile targetFile (CreateTempFile());
 305
 306     std::ifstream input (m_File.GetPath().c_str(), std::ios::in|std::ios::binary);
 307     if (!input.is_open())
 308       return false;
 309     std::ofstream output (targetFile.GetPath().c_str(), std::ios::out|std::ios::binary);
 310     if (!output.is_open())
 311       return false;
 312
 313     CReverseDelta revDelta ((const char*)pRecord->GetBuffer(), pRecord->GetLen());
 314     bool ret = revDelta (input, output);
 315
 316     input.close();
 317     output.close ();
 318
 319     if (ret)
 320     {
 321       m_File = targetFile;
 322     }
 323     return ret;
 324   }
 325
 326   virtual bool SaveAs (std::string name, bool overwrite = false)
 327   {
 328     return ::CopyFile (GetPath ().c_str(), name.c_str(), !overwrite) != 0;
 329   }
 330
 331   virtual bool Apply (const SSAction& rAction)
 332   {
 333     throw SSException ("unsuported action in CReverseHistoryHandler");
 334   }
 335
 336 };
 337
 338 class CProjectHistoryHandler : public CHistoryHandler
 339 {
 340 public:
 341   CProjectHistoryHandler (std::string src)
 342     : CHistoryHandler (src)
 343   {
 344     SSProjectFile projectFile (GetPath ());
 345     BuildList (projectFile);
 346   }
 347
 348   virtual bool SaveAs (std::string name, bool overwrite = false)
 349   {
 350     return false;
 351   }
 352
 353   virtual bool Apply (const SSLabeledAction& rAction)           { /* nothing to do */ return true; }
 354 ////  virtual bool Apply (const SSSingleFileAction& rAction)      { return Apply ((const SSAction&) rAction); }
 355   virtual bool Apply (const SSCreatedProjectAction& rAction)    { /* nothing to do */ return true; }
 356   virtual bool Apply (const SSCreatedFileAction& rAction)       { /* nothing to do */ return true; }
 357   virtual bool Apply (const SSAddedProjectAction& rAction);
 358   virtual bool Apply (const SSAddedFileAction& rAction);
 359   virtual bool Apply (const SSDeletedProjectAction& rAction);
 360   virtual bool Apply (const SSDeletedFileAction& rAction);
 361   virtual bool Apply (const SSRecoveredProjectAction& rAction);
 362   virtual bool Apply (const SSRecoveredFileAction& rAction);
 363
 364   virtual bool Apply (const SSDestroyedProjectAction& rAction);
 365   virtual bool Apply (const SSDestroyedFileAction& rAction);
 366   virtual bool Apply (const SSRenamedProjectAction& rAction);
 367   virtual bool Apply (const SSRenamedFileAction& rAction);
 368 //  virtual bool Apply (const SSCheckedInAction& rAction)         { return Apply ((const SSAction&) rAction); }
 369 // TODO:
 370 //  virtual bool Apply (const SSSharedFileAction& rAction)        { return Apply ((const SSAction&) rAction); }
 371
 372 protected:
 373   virtual bool Apply (const SSAction& rAction)
 374   {
 375     throw SSException ("unsuported action in CProjectHistoryHandler");
 376   }
 377
 378   typedef std::vector<SSProjectObject>::iterator iterator;
 379   std::vector<SSProjectObject> m_Items;
 380
 381   void BuildList (SSProjectFile& rFile);
 382   iterator FindItem (std::string physFile);
 383   iterator InsertItem (SSProjectObject object);
 384
 385 };
 386
 387
 388 void CProjectHistoryHandler::BuildList (SSProjectFile& rFile)
 389 {
 390   // iterate all records and add them to the collection
 391   SSRecordPtr recordPtr = rFile.GetFirstRecord ();
 392   while (recordPtr)
 393   {
 394     if (recordPtr->GetType() == eProjectEntry)
 395     {
 396       SSProjectObject projectObject (recordPtr);
 397       m_Items.push_back (projectObject);
 398     }
 399
 400     recordPtr = rFile.GetNextRecord (recordPtr);
 401   }
 402 }
 403
 404 CProjectHistoryHandler::iterator CProjectHistoryHandler::FindItem (std::string physFile)
 405 {
 406   iterator itor;
 407   iterator end = m_Items.end();
 408   iterator found = end;
 409
 410   for (itor = m_Items.begin(); itor != end; ++itor)
 411   {
 412     SSProjectObject& po = *itor;
 413     //    std::cout << itemPtr->GetPhysical () << std::endl;
 414     if (physFile == po.GetPhysFile())
 415     {
 416       if (found != end)
 417         throw SSException ("duplicate entry");
 418
 419       found = itor;
 420     }
 421   }
 422
 423   return found;
 424 }
 425
 426 CProjectHistoryHandler::iterator CProjectHistoryHandler::InsertItem (SSProjectObject object)
 427 {
 428   m_Items.push_back (object);
 429   iterator last = m_Items.end();
 430   return --last;
 431 }
 432
 433 bool CProjectHistoryHandler::Apply (const SSAddedFileAction& rAction)
 434 {
 435   iterator itor = FindItem (rAction.GetPhysical());
 436   if (itor != m_Items.end())
 437     m_Items.erase(itor);
 438   else
 439     throw SSException ("item not found");
 440
 441   return true;
 442 }
 443
 444 bool CProjectHistoryHandler::Apply (const SSAddedProjectAction& rAction)
 445 {
 446   iterator itor = FindItem (rAction.GetPhysical());
 447   if (itor != m_Items.end())
 448     m_Items.erase(itor);
 449   else
 450     throw SSException ("item not found");
 451
 452   return true;
 453 }
 454
 455 bool CProjectHistoryHandler::Apply (const SSDeletedFileAction& rAction)
 456 {
 457   iterator itor = FindItem (rAction.GetPhysical());
 458   if (itor != m_Items.end ())
 459   {
 460     SSProjectObject& po = *itor;
 461     po.Recover ();
 462   }
 463   else
 464     throw SSException ("item not found");
 465
 466   return true;
 467 }
 468 bool CProjectHistoryHandler::Apply (const SSDeletedProjectAction& rAction)
 469 {
 470   iterator itor = FindItem (rAction.GetPhysical());
 471   if (itor != m_Items.end ())
 472   {
 473     SSProjectObject& po = *itor;
 474     po.Recover ();
 475   }
 476   else
 477     throw SSException ("item not found");
 478
 479   return true;
 480 }
 481 bool CProjectHistoryHandler::Apply (const SSRecoveredFileAction& rAction)
 482 {
 483   iterator itor = FindItem (rAction.GetPhysical());
 484   if (itor != m_Items.end ())
 485   {
 486     SSProjectObject& po = *itor;
 487     po.Delete ();
 488   }
 489   else
 490     throw SSException ("item not found");
 491
 492   return true;
 493 }
 494 bool CProjectHistoryHandler::Apply (const SSRecoveredProjectAction& rAction)
 495 {
 496   iterator itor = FindItem (rAction.GetPhysical());
 497   if (itor != m_Items.end ())
 498   {
 499     SSProjectObject& po = *itor;
 500     po.Delete ();
 501   }
 502   else
 503     throw SSException ("item not found");
 504
 505   return true;
 506 }
 507
 508 bool CProjectHistoryHandler::Apply (const SSDestroyedProjectAction& rAction)
 509 {
 510   if (FindItem (rAction.GetPhysical ()) != m_Items.end ())
 511     throw SSException ("adding already existing item");
 512
 513   PROJECT_ENTRY pe;
 514 // pe.flags = ??;
 515   pe.name = rAction.GetSSName ();
 516   strncpy (pe.phys, rAction.GetPhysical().c_str(), 8);
 517   pe.phys[8] = '\0';
 518   pe.pinnedToVersion = 0;
 519 // pe.type = ??
 520   SSProjectObject pr (pe);
 521   InsertItem (pr);
 522
 523   return true;
 524 }
 525
 526 bool CProjectHistoryHandler::Apply (const SSDestroyedFileAction& rAction)
 527 {
 528   // durch map wahrscheinlich besser zu lösen
 529   if (FindItem (rAction.GetPhysical()) != m_Items.end ())
 530     throw SSException ("adding already existing item");
 531
 532   PROJECT_ENTRY pe;
 533 // pe.flags = ??;
 534   pe.name = rAction.GetSSName ();
 535   strncpy (pe.phys, rAction.GetPhysical().c_str(), 8);
 536   pe.phys[8] = '\0';
 537   pe.pinnedToVersion = 0;
 538 // pe.type = ??
 539   SSProjectObject pr (pe);
 540   InsertItem (pr);
 541
 542   return true;
 543 }
 544
 545 bool CProjectHistoryHandler::Apply (const SSRenamedProjectAction& rAction)
 546 {
 547   iterator itor = FindItem (rAction.GetPhysical());
 548   if (itor == m_Items.end ())
 549     throw SSException ("item not found");
 550
 551   SSProjectObject& po = *itor;
 552   po.Rename (rAction.GetNewSSName (), rAction.GetSSName());
 553   return true;
 554 }
 555
 556 bool CProjectHistoryHandler::Apply (const SSRenamedFileAction& rAction)
 557 {
 558   iterator itor = FindItem (rAction.GetPhysical());
 559   if (itor == m_Items.end ())
 560     throw SSException ("item not found");
 561
 562   SSProjectObject& po = *itor;
 563   po.Rename (rAction.GetNewSSName (), rAction.GetSSName());
 564   return true;
 565 }
 566
 567
 568
 569
 570
 571
 572 void CGetCommand::Execute ()
 573 {
 574   if (m_DestFile.empty ())
 575     throw SSException ("please specify a destination file for the get operation");
 576
 577   if (fexists (m_DestFile.c_str ()) && !m_bForceOverwrite)
 578     throw SSException ("destination file exists. Please use overwrite flag");
 579
 580   SSHistoryFile file(m_PhysFile);
 581   std::auto_ptr<SSItemInfoObject> pItem (file.GetItemInfo());
 582   if (!pItem.get ())
 583     throw SSException ("no information object found");
 584
 585   std::auto_ptr<CHistoryHandler> pVisitor;
 586   std::string lastDataFileName = pItem->GetDataFileName ();
 587
 588   if (pItem->GetType() == SSITEM_FILE)
 589     pVisitor = std::auto_ptr<CHistoryHandler> (new CReverseHistoryHandler (lastDataFileName));
 590   else
 591     pVisitor = std::auto_ptr<CHistoryHandler> (new CProjectHistoryHandler (lastDataFileName));
 592
 593
 594   SSVersionObject version (pItem->GetHistoryLast ());
 595   while (version && version.GetVersionNumber() > m_Version)
 596   {
 597     if (version.GetAction())
 598     {
 599       version.GetAction ()->Accept (*pVisitor.get());
 600       if (m_bBulkGet)
 601       {
 602         char buffer[66];
 603         CFileName fname (m_PhysFile.c_str ());
 604         fname.SetExt (itoa (version.GetVersionNumber (), buffer, 10));
 605
 606         if (!pVisitor->SaveAs (fname.GetFileName ().c_str(), false))
 607           throw SSException ("failed to create target file" + fname.GetFileName ());
 608       }
 609     }
 610
 611     version = version.GetPreviousObject ();
 612   }
 613
 614   if (!pVisitor->SaveAs (m_DestFile.c_str(), m_bForceOverwrite))
 615     throw SSException ("failed to create target file");
 616 }
 617