Ignore:
Timestamp:
01/08/2007 00:18:50 (5 years ago)
Author:
chris
Message:

Replace almost all calls to syslog() with logging framework. (merges [1783])

File:
1 edited

Legend:

Unmodified
Added
Removed

  • box/chris/general/lib/backupclient/BackupClientRestore.cpp

    r1661 r1784  
    236236        catch (BoxException &e) 
    237237        { 
    238                 ::syslog(LOG_ERR, "Failed to check existence for %s: %s",  
    239                         rLocalDirectoryName.c_str(), e.what()); 
     238                BOX_ERROR("Failed to check existence for " << 
     239                        rLocalDirectoryName << ": " << e.what()); 
    240240                return Restore_UnknownError; 
    241241        } 
    242242        catch(std::exception &e) 
    243243        { 
    244                 ::syslog(LOG_ERR, "Failed to check existence for %s: %s",  
    245                         rLocalDirectoryName.c_str(), e.what()); 
     244                BOX_ERROR("Failed to check existence for " << 
     245                        rLocalDirectoryName << ": " << e.what()); 
    246246                return Restore_UnknownError; 
    247247        } 
    248248        catch(...) 
    249249        { 
    250                 ::syslog(LOG_ERR, "Failed to check existence for %s: " 
    251                         "unknown error", rLocalDirectoryName.c_str()); 
     250                BOX_ERROR("Failed to check existence for " << 
     251                        rLocalDirectoryName << ": unknown error"); 
    252252                return Restore_UnknownError; 
    253253        } 
    … …  
    264264                                if(::unlink(rLocalDirectoryName.c_str()) != 0) 
    265265                                { 
    266                                         ::syslog(LOG_ERR, "Failed to delete " 
    267                                                 "file %s: %s", 
    268                                                 rLocalDirectoryName.c_str(), 
     266                                        BOX_ERROR("Failed to delete file " << 
     267                                                rLocalDirectoryName << ": " << 
    269268                                                strerror(errno)); 
    270269                                        return Restore_UnknownError; 
    271270                                } 
    272                                 TRACE1("In restore, directory name collision with file %s", rLocalDirectoryName.c_str()); 
     271                                BOX_TRACE("In restore, directory name "  
     272                                        "collision with file " << 
     273                                        rLocalDirectoryName); 
    273274                        } 
    274275                        break; 
    … …  
    326327                catch (BoxException &e) 
    327328                { 
    328                         ::syslog(LOG_ERR, "Failed to check existence for %s: " 
    329                                 "%s", parentDirectoryName.c_str(), e.what()); 
     329                        BOX_ERROR("Failed to check existence for " << 
     330                                parentDirectoryName << ": " << e.what()); 
    330331                        return Restore_UnknownError; 
    331332                } 
    332333                catch(std::exception &e) 
    333334                { 
    334                         ::syslog(LOG_ERR, "Failed to check existence for %s: " 
    335                                 "%s", parentDirectoryName.c_str(), e.what()); 
     335                        BOX_ERROR("Failed to check existence for " << 
     336                                parentDirectoryName << ": " << e.what()); 
    336337                        return Restore_UnknownError; 
    337338                } 
    338339                catch(...) 
    339340                { 
    340                         ::syslog(LOG_ERR, "Failed to check existence for %s: " 
    341                                 "unknown error", parentDirectoryName.c_str()); 
     341                        BOX_ERROR("Failed to check existence for " << 
     342                                parentDirectoryName << ": unknown error"); 
    342343                        return Restore_UnknownError; 
    343344                } 
    … …  
    350351 
    351352                        case ObjectExists_File: 
    352                                 fprintf(stderr, "Failed to restore: '%s' " 
     353                                BOX_ERROR("Failed to restore: '" << 
     354                                        parentDirectoryName << "' " 
    353355                                        "is a file, but should be a " 
    354                                         "directory.\n",  
    355                                         parentDirectoryName.c_str()); 
     356                                        "directory."); 
    356357                                return Restore_TargetPathNotFound; 
    357358 
    358359                        case ObjectExists_NoObject: 
    359                                 fprintf(stderr, "Failed to restore: " 
    360                                         "parent '%s' of target directory " 
    361                                         "does not exist.\n", 
    362                                         parentDirectoryName.c_str()); 
     360                                BOX_ERROR("Failed to restore: parent '" << 
     361                                        parentDirectoryName << "' of target " 
     362                                        "directory does not exist."); 
    363363                                return Restore_TargetPathNotFound; 
    364364 
    365365                        default: 
    366                                 fprintf(stderr, "Failed to restore: " 
    367                                         "unknown result from " 
    368                                         "ObjectExists('%s').\n", 
    369                                         parentDirectoryName.c_str()); 
     366                                BOX_ERROR("Failed to restore: unknown " 
     367                                        "result from ObjectExists('" << 
     368                                        parentDirectoryName << "')"); 
    370369                                return Restore_UnknownError; 
    371370                } 
    … …  
    376375                ::mkdir(rLocalDirectoryName.c_str(), S_IRWXU) != 0) 
    377376        { 
    378                 ::syslog(LOG_ERR, "Failed to create directory %s: %s", 
    379                         rLocalDirectoryName.c_str(), 
     377                BOX_ERROR("Failed to create directory '" << 
     378                        rLocalDirectoryName << "': " <<  
    380379                        strerror(errno)); 
    381380                return Restore_UnknownError; 
    … …  
    387386                Params.mResumeInfo.Save(Params.mRestoreResumeInfoFilename); 
    388387        } 
    389         catch (BoxException &e) 
    390         { 
    391                 ::syslog(LOG_ERR, "Failed to save resume info file %s: %s",  
    392                         Params.mRestoreResumeInfoFilename.c_str(), e.what()); 
    393                 return Restore_UnknownError; 
    394         } 
    395388        catch(std::exception &e) 
    396389        { 
    397                 ::syslog(LOG_ERR, "Failed to save resume info file %s: %s",  
    398                         Params.mRestoreResumeInfoFilename.c_str(), e.what()); 
     390                BOX_ERROR("Failed to save resume info file '" << 
     391                        Params.mRestoreResumeInfoFilename << "': " << 
     392                        e.what()); 
    399393                return Restore_UnknownError; 
    400394        } 
    401395        catch(...) 
    402396        { 
    403                 ::syslog(LOG_ERR, "Failed to save resume info file %s: " 
    404                         "unknown error",  
    405                         Params.mRestoreResumeInfoFilename.c_str()); 
     397                BOX_ERROR("Failed to save resume info file '" << 
     398                        Params.mRestoreResumeInfoFilename << 
     399                        "': unknown error"); 
    406400                return Restore_UnknownError; 
    407401        } 
    … …  
    428422                dirAttr.WriteAttributes(rLocalDirectoryName.c_str(), true); 
    429423        } 
    430         catch (BoxException &e) 
    431         { 
    432                 ::syslog(LOG_ERR, "Failed to restore attributes for %s: %s",  
    433                         rLocalDirectoryName.c_str(), e.what()); 
    434                 return Restore_UnknownError; 
    435         } 
    436424        catch(std::exception &e) 
    437425        { 
    438                 ::syslog(LOG_ERR, "Failed to restore attributes for %s: %s",  
    439                         rLocalDirectoryName.c_str(), e.what()); 
     426                BOX_ERROR("Failed to restore attributes for '" << 
     427                        rLocalDirectoryName << "': " << e.what()); 
    440428                return Restore_UnknownError; 
    441429        } 
    442430        catch(...) 
    443431        { 
    444                 ::syslog(LOG_ERR, "Failed to restore attributes for %s: " 
    445                         "unknown error", rLocalDirectoryName.c_str()); 
     432                BOX_ERROR("Failed to restore attributes for '" << 
     433                        rLocalDirectoryName << "': unknown error"); 
    446434                return Restore_UnknownError; 
    447435        } 
    … …  
    465453                                if(::unlink(localFilename.c_str()) == 0) 
    466454                                { 
    467                                         ::syslog(LOG_ERR, "Failed to delete " 
    468                                                 "file %s: %s", 
    469                                                 localFilename.c_str(), 
     455                                        BOX_ERROR("Failed to delete file '" << 
     456                                                localFilename << "': " << 
    470457                                                strerror(errno)); 
    471458                                        return Restore_UnknownError; 
    … …  
    495482                                        } 
    496483                                } 
    497                                 catch (BoxException &e) 
    498                                 { 
    499                                         ::syslog(LOG_ERR, "Failed to restore " 
    500                                                 "file %s: %s",  
    501                                                 localFilename.c_str(),  
     484                                catch(std::exception &e) 
     485                                { 
     486                                        BOX_ERROR("Failed to restore file '" << 
     487                                                localFilename << "': " << 
    502488                                                e.what()); 
    503489                                        return Restore_UnknownError; 
    504490                                } 
    505                                 catch(std::exception &e) 
    506                                 { 
    507                                         ::syslog(LOG_ERR, "Failed to restore " 
    508                                                 "file %s: %s",  
    509                                                 localFilename.c_str(),  
    510                                                 e.what()); 
    511                                         return Restore_UnknownError; 
    512                                 } 
    513491                                catch(...) 
    514492                                { 
    515                                         ::syslog(LOG_ERR, "Failed to restore " 
    516                                                 "file %s: unknown error",  
    517                                                 localFilename.c_str()); 
     493                                        BOX_ERROR("Failed to restore file '" << 
     494                                                localFilename << 
     495                                                "': unknown error"); 
    518496                                        return Restore_UnknownError; 
    519497                                } 
    … …  
    541519                                                        existing */); 
    542520                                } 
    543                                 catch (BoxException &e) 
    544                                 { 
    545                                         ::syslog(LOG_ERR, "Failed to determine " 
    546                                                 "whether file exists: %s: %s",  
    547                                                 localFilename.c_str(),  
     521                                catch(std::exception &e) 
     522                                { 
     523                                        BOX_ERROR("Failed to determine " 
     524                                                "whether file exists: '" << 
     525                                                localFilename << "': " << 
    548526                                                e.what()); 
    549527                                        return Restore_UnknownError; 
    550528                                } 
    551                                 catch(std::exception &e) 
    552                                 { 
    553                                         ::syslog(LOG_ERR, "Failed to determine " 
    554                                                 "whether file exists: %s: %s",  
    555                                                 localFilename.c_str(),  
    556                                                 e.what()); 
    557                                         return Restore_UnknownError; 
    558                                 } 
    559529                                catch(...) 
    560530                                { 
    561                                         ::syslog(LOG_ERR, "Failed to determine " 
    562                                                 "whether file exists: %s: " 
    563                                                 "unknown error",  
    564                                                 localFilename.c_str()); 
     531                                        BOX_ERROR("Failed to determine " 
     532                                                "whether file exists: '" << 
     533                                                localFilename << "': " 
     534                                                "unknown error"); 
    565535                                        return Restore_UnknownError; 
    566536                                } 
    … …  
    578548                                                        Params.mResumeInfo.Save(Params.mRestoreResumeInfoFilename); 
    579549                                                } 
    580                                                 catch (BoxException &e) 
    581                                                 { 
    582                                                         ::syslog(LOG_ERR, "Failed to save resume info file %s: %s",  
    583                                                                 Params.mRestoreResumeInfoFilename.c_str(), e.what()); 
    584                                                         return Restore_UnknownError; 
    585                                                 } 
    586550                                                catch(std::exception &e) 
    587551                                                { 
    588                                                         ::syslog(LOG_ERR, "Failed to save resume info file %s: %s",  
    589                                                                 Params.mRestoreResumeInfoFilename.c_str(), e.what()); 
     552                                                        BOX_ERROR("Failed to save resume info file '" << 
     553                                                                Params.mRestoreResumeInfoFilename << 
     554                                                                "': " << e.what()); 
    590555                                                        return Restore_UnknownError; 
    591556                                                } 
    592557                                                catch(...) 
    593558                                                { 
    594                                                         ::syslog(LOG_ERR, "Failed to save resume info file %s: " 
    595                                                                 "unknown error",  
    596                                                                 Params.mRestoreResumeInfoFilename.c_str()); 
     559                                                        BOX_ERROR("Failed to save resume info file '" << 
     560                                                                Params.mRestoreResumeInfoFilename << 
     561                                                                "': unknown error"); 
    597562                                                        return Restore_UnknownError; 
    598563                                                } 
    … …  
    614579                                Params.mRestoreResumeInfoFilename); 
    615580                } 
    616                 catch (BoxException &e) 
    617                 { 
    618                         ::syslog(LOG_ERR, "Failed to save resume info file " 
    619                                 "%s: %s",  
    620                                 Params.mRestoreResumeInfoFilename.c_str(), 
     581                catch(std::exception &e) 
     582                { 
     583                        BOX_ERROR("Failed to save resume info file '" << 
     584                                Params.mRestoreResumeInfoFilename << "': " << 
    621585                                e.what()); 
    622586                        return Restore_UnknownError; 
    623587                } 
    624                 catch(std::exception &e) 
    625                 { 
    626                         ::syslog(LOG_ERR, "Failed to save resume info file " 
    627                                 "%s: %s",  
    628                                 Params.mRestoreResumeInfoFilename.c_str(), 
    629                                 e.what()); 
    630                         return Restore_UnknownError; 
    631                 } 
    632588                catch(...) 
    633589                { 
    634                         ::syslog(LOG_ERR, "Failed to save resume info file " 
    635                                 "%s: unknown error",  
    636                                 Params.mRestoreResumeInfoFilename.c_str()); 
     590                        BOX_ERROR("Failed to save resume info file '" << 
     591                                Params.mRestoreResumeInfoFilename << 
     592                                "': unknown error"); 
    637593                        return Restore_UnknownError; 
    638594                } 
    … …  
    682638                dirAttr.WriteAttributes(rLocalDirectoryName.c_str(), false); 
    683639        } 
    684         catch (BoxException &e) 
    685         { 
    686                 ::syslog(LOG_ERR, "Failed to restore attributes for %s: %s",  
    687                         rLocalDirectoryName.c_str(), e.what()); 
    688                 return Restore_UnknownError; 
    689         } 
    690640        catch(std::exception &e) 
    691641        { 
    692                 ::syslog(LOG_ERR, "Failed to restore attributes for %s: %s",  
    693                         rLocalDirectoryName.c_str(), e.what()); 
     642                BOX_ERROR("Failed to restore attributes for '" << 
     643                        rLocalDirectoryName << "': " << e.what()); 
    694644                return Restore_UnknownError; 
    695645        } 
    696646        catch(...) 
    697647        { 
    698                 ::syslog(LOG_ERR, "Failed to restore attributes for %s: " 
    699                         "unknown error", rLocalDirectoryName.c_str()); 
     648                BOX_ERROR("Failed to restore attributes for '" << 
     649                        rLocalDirectoryName << "': unknown error"); 
    700650                return Restore_UnknownError; 
    701651        } 
Note: See TracChangeset for help on using the changeset viewer.