Changeset 2157

Show
Ignore:
Timestamp:
05/05/2008 14:44:38 (2 years ago)
Author:
chris
Message:

Add restore -f option to force restore to continue after an error.

Location:
box/trunk
Files:
4 modified

Legend:

Unmodified
Added
Removed

  • box/trunk/bin/bbackupquery/BackupQueries.cpp

    r2142 r2157  
    218218                { "get",  "i" }, 
    219219                { "compare", "alcqAEQ" }, 
    220                 { "restore", "dri" }, 
     220                { "restore", "drif" }, 
    221221                { "help", "" }, 
    222222                { "usage", "" }, 
    … …  
    19671967        if(args.size() != 2) 
    19681968        { 
    1969                 BOX_ERROR("Incorrect usage. restore [-d] [-r] [-i] <remote-name> <local-name>"); 
     1969                BOX_ERROR("Incorrect usage. restore [-drif] <remote-name> <local-name>"); 
    19701970                return; 
    19711971        } 
    … …  
    20302030                        true /* print progress dots */, restoreDeleted,  
    20312031                        false /* don't undelete after restore! */,  
    2032                         opts['r'] /* resume? */); 
     2032                        opts['r'] /* resume? */, 
     2033                        opts['f'] /* force continue after errors */); 
    20332034        } 
    20342035        catch(std::exception &e) 
    … …  
    20512052                break; 
    20522053         
     2054        case Restore_CompleteWithErrors: 
     2055                BOX_WARNING("Restore complete, but some files could not be " 
     2056                        "restored."); 
     2057                break; 
     2058         
    20532059        case Restore_ResumePossible: 
    2054                 BOX_ERROR("Resume possible -- repeat command with -r flag to resume"); 
     2060                BOX_ERROR("Resume possible -- repeat command with -r flag " 
     2061                        "to resume."); 
    20552062                SetReturnCode(COMMAND_RETURN_ERROR); 
    20562063                break; 
    20572064         
    20582065        case Restore_TargetExists: 
    2059                 BOX_ERROR("The target directory exists. You cannot restore over an existing directory."); 
     2066                BOX_ERROR("The target directory exists. You cannot restore " 
     2067                        "over an existing directory."); 
    20602068                SetReturnCode(COMMAND_RETURN_ERROR); 
    20612069                break; 

  • box/trunk/bin/bbackupquery/documentation.txt

    r1188 r2157  
    117117< 
    118118 
    119 > restore [-d] [-r] [-i] <directory-name> <local-directory-name> 
     119> restore [-drif] <directory-name> <local-directory-name> 
    120120 
    121121        Restores a directory to the local disc. The local directory specified 
    … …  
    127127        -r -- resume an interrupted restoration 
    128128        -i -- directory name is actually an ID 
     129        -f -- force restore to continue if errors are encountered 
    129130 
    130131        If a restore operation is interrupted for any reason, it can be restarted 

  • box/trunk/lib/backupclient/BackupClientRestore.cpp

    r2144 r2157  
    194194        bool PrintDots; 
    195195        bool RestoreDeleted; 
     196        bool ContinueAfterErrors; 
     197        bool ContinuedAfterError; 
    196198        std::string mRestoreResumeInfoFilename; 
    197199        RestoreResumeInfo mResumeInfo; 
    … …  
    388390                BOX_LOG_SYS_ERROR("Failed to create directory '" << 
    389391                        rLocalDirectoryName << "'"); 
    390                 return Restore_UnknownError; 
     392 
     393                if (Params.ContinueAfterErrors) 
     394                { 
     395                        Params.ContinuedAfterError = true; 
     396                } 
     397                else 
     398                { 
     399                        return Restore_UnknownError; 
     400                } 
    391401        } 
    392402 
    … …  
    401411                        Params.mRestoreResumeInfoFilename << "': " << 
    402412                        e.what()); 
    403                 return Restore_UnknownError; 
     413 
     414                if (Params.ContinueAfterErrors) 
     415                { 
     416                        Params.ContinuedAfterError = true; 
     417                } 
     418                else 
     419                { 
     420                        return Restore_UnknownError; 
     421                } 
    404422        } 
    405423        catch(...) 
    … …  
    408426                        Params.mRestoreResumeInfoFilename << 
    409427                        "': unknown error"); 
    410                 return Restore_UnknownError; 
     428 
     429                if (Params.ContinueAfterErrors) 
     430                { 
     431                        Params.ContinuedAfterError = true; 
     432                } 
     433                else 
     434                { 
     435                        return Restore_UnknownError; 
     436                } 
    411437        } 
    412438 
    … …  
    436462                BOX_ERROR("Failed to restore attributes for '" << 
    437463                        rLocalDirectoryName << "': " << e.what()); 
    438                 return Restore_UnknownError; 
     464 
     465                if (Params.ContinueAfterErrors) 
     466                { 
     467                        Params.ContinuedAfterError = true; 
     468                } 
     469                else 
     470                { 
     471                        return Restore_UnknownError; 
     472                } 
    439473        } 
    440474        catch(...) 
    … …  
    442476                BOX_ERROR("Failed to restore attributes for '" << 
    443477                        rLocalDirectoryName << "': unknown error"); 
    444                 return Restore_UnknownError; 
     478 
     479                if (Params.ContinueAfterErrors) 
     480                { 
     481                        Params.ContinuedAfterError = true; 
     482                } 
     483                else 
     484                { 
     485                        return Restore_UnknownError; 
     486                } 
    445487        } 
    446488 
    … …  
    474516                                                "file '" << localFilename <<  
    475517                                                "'"); 
    476                                         return Restore_UnknownError; 
     518 
     519                                        if (Params.ContinueAfterErrors) 
     520                                        { 
     521                                                Params.ContinuedAfterError = true; 
     522                                        } 
     523                                        else 
     524                                        { 
     525                                                return Restore_UnknownError; 
     526                                        } 
    477527                                } 
    478528                                 
    … …  
    508558                                                localFilename << "': " << 
    509559                                                e.what()); 
    510                                         return Restore_UnknownError; 
     560 
     561                                        if (Params.ContinueAfterErrors) 
     562                                        { 
     563                                                Params.ContinuedAfterError = true; 
     564                                        } 
     565                                        else 
     566                                        { 
     567                                                return Restore_UnknownError; 
     568                                        } 
    511569                                } 
    512570                                catch(...) 
    … …  
    515573                                                localFilename << 
    516574                                                "': unknown error"); 
    517                                         return Restore_UnknownError; 
     575 
     576                                        if (Params.ContinueAfterErrors) 
     577                                        { 
     578                                                Params.ContinuedAfterError = true; 
     579                                        } 
     580                                        else 
     581                                        { 
     582                                                return Restore_UnknownError; 
     583                                        } 
    518584                                } 
    519585                                 
    … …  
    546612                                                localFilename << "': " << 
    547613                                                e.what()); 
    548                                         return Restore_UnknownError; 
     614 
     615                                        if (Params.ContinueAfterErrors) 
     616                                        { 
     617                                                Params.ContinuedAfterError = true; 
     618                                        } 
     619                                        else 
     620                                        { 
     621                                                return Restore_UnknownError; 
     622                                        } 
    549623                                } 
    550624                                catch(...) 
    … …  
    554628                                                localFilename << "': " 
    555629                                                "unknown error"); 
    556                                         return Restore_UnknownError; 
     630 
     631                                        if (Params.ContinueAfterErrors) 
     632                                        { 
     633                                                Params.ContinuedAfterError = true; 
     634                                        } 
     635                                        else 
     636                                        { 
     637                                                return Restore_UnknownError; 
     638                                        } 
    557639                                } 
    558640 
    … …  
    607689                                Params.mRestoreResumeInfoFilename << "': " << 
    608690                                e.what()); 
    609                         return Restore_UnknownError; 
     691                        if (Params.ContinueAfterErrors) 
     692                        { 
     693                                Params.ContinuedAfterError = true; 
     694                        } 
     695                        else 
     696                        { 
     697                                return Restore_UnknownError; 
     698                        } 
    610699                } 
    611700                catch(...) 
    … …  
    614703                                Params.mRestoreResumeInfoFilename << 
    615704                                "': unknown error"); 
    616                         return Restore_UnknownError; 
     705                        if (Params.ContinueAfterErrors) 
     706                        { 
     707                                Params.ContinuedAfterError = true; 
     708                        } 
     709                        else 
     710                        { 
     711                                return Restore_UnknownError; 
     712                        } 
    617713                } 
    618714                 
    … …  
    671767                BOX_ERROR("Failed to restore attributes for '" << 
    672768                        rLocalDirectoryName << "': " << e.what()); 
    673                 return Restore_UnknownError; 
     769                if (Params.ContinueAfterErrors) 
     770                { 
     771                        Params.ContinuedAfterError = true; 
     772                } 
     773                else 
     774                { 
     775                        return Restore_UnknownError; 
     776                } 
    674777        } 
    675778        catch(...) 
    … …  
    677780                BOX_ERROR("Failed to restore attributes for '" << 
    678781                        rLocalDirectoryName << "': unknown error"); 
    679                 return Restore_UnknownError; 
     782                if (Params.ContinueAfterErrors) 
     783                { 
     784                        Params.ContinuedAfterError = true; 
     785                } 
     786                else 
     787                { 
     788                        return Restore_UnknownError; 
     789                } 
    680790        } 
    681791 
    … …  
    688798// Function 
    689799//              Name:    BackupClientRestore(BackupProtocolClient &, int64_t, 
    690 //                       const char *, bool, bool) 
     800//                       const char *, bool, bool, bool, bool, bool) 
    691801//              Purpose: Restore a directory on the server to a local 
    692802//                       directory on the disc. The local directory must not 
    … …  
    708818// 
    709819//                       Returns Restore_Complete on success. (Exceptions 
    710 //                       on error.) 
     820//                       on error, unless ContinueAfterError is true and 
     821//                       the error is recoverable, in which case it returns 
     822//                       Restore_CompleteWithErrors) 
    711823//              Created: 23/11/03 
    712824// 
    … …  
    715827        int64_t DirectoryID, const char *LocalDirectoryName, 
    716828        bool PrintDots, bool RestoreDeleted, 
    717         bool UndeleteAfterRestoreDeleted, bool Resume) 
     829        bool UndeleteAfterRestoreDeleted, bool Resume, 
     830        bool ContinueAfterErrors) 
    718831{ 
    719832        // Parameter block 
    … …  
    721834        params.PrintDots = PrintDots; 
    722835        params.RestoreDeleted = RestoreDeleted; 
     836        params.ContinueAfterErrors = ContinueAfterErrors; 
     837        params.ContinuedAfterError = false; 
    723838        params.mRestoreResumeInfoFilename = LocalDirectoryName; 
    724839        params.mRestoreResumeInfoFilename += ".boxbackupresume"; 
    … …  
    783898        ::unlink(params.mRestoreResumeInfoFilename.c_str()); 
    784899 
    785         return Restore_Complete; 
     900        return params.ContinuedAfterError ? Restore_CompleteWithErrors 
     901                : Restore_Complete; 
    786902} 
    787903 

  • box/trunk/lib/backupclient/BackupClientRestore.h

    r1082 r2157  
    1616{ 
    1717        Restore_Complete = 0, 
    18         Restore_ResumePossible = 1, 
    19         Restore_TargetExists = 2, 
    20         Restore_TargetPathNotFound = 3, 
    21         Restore_UnknownError = 4, 
     18        Restore_ResumePossible, 
     19        Restore_TargetExists, 
     20        Restore_TargetPathNotFound, 
     21        Restore_UnknownError, 
     22        Restore_CompleteWithErrors, 
    2223}; 
    2324 
    24 int BackupClientRestore(BackupProtocolClient &rConnection, int64_t DirectoryID, const char *LocalDirectoryName, 
    25         bool PrintDots = false, bool RestoreDeleted = false, bool UndeleteAfterRestoreDeleted = false, bool Resume = false); 
     25int BackupClientRestore(BackupProtocolClient &rConnection, 
     26        int64_t DirectoryID, 
     27        const char *LocalDirectoryName, 
     28        bool PrintDots = false, 
     29        bool RestoreDeleted = false, 
     30        bool UndeleteAfterRestoreDeleted = false, 
     31        bool Resume = false, 
     32        bool ContinueAfterErrors = false); 
    2633 
    2734#endif // BACKUPSCLIENTRESTORE__H