Ignore:
Timestamp:
27/08/2011 15:06:46 (9 months ago)
Author:
chris
Message:

Combine client and server protocols to make way for an offline/local protocol.

Rename ProtocolObject? to Message.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • box/trunk/test/backupstore/testbackupstore.cpp

    r2841 r2983  
    1414 
    1515#include "Test.h" 
    16 #include "autogen_BackupProtocolClient.h" 
     16#include "autogen_BackupProtocol.h" 
    1717#include "SSLLib.h" 
    1818#include "TLSContext.h" 
    … …  
    441441         
    442442        // Command 
    443         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocol.QueryListDirectory( 
     443        std::auto_ptr<BackupProtocolSuccess> dirreply(protocol.QueryListDirectory( 
    444444                        DirID, 
    445                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    446                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     445                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     446                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    447447        // Stream 
    448448        BackupStoreDirectory dir; 
    … …  
    456456        while((en = i.Next()) != 0) 
    457457        { 
    458                 if(en->GetFlags() & BackupProtocolClientListDirectory::Flags_Dir) 
     458                if(en->GetFlags() & BackupProtocolListDirectory::Flags_Dir) 
    459459                { 
    460460                        dirs++; 
    … …  
    467467                } 
    468468                // Check it's deleted 
    469                 TEST_THAT(en->GetFlags() & BackupProtocolClientListDirectory::Flags_Deleted); 
     469                TEST_THAT(en->GetFlags() & BackupProtocolListDirectory::Flags_Deleted); 
    470470        } 
    471471         
    … …  
    492492        std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile( 
    493493                source.c_str(), parentId, name_encoded)); 
    494         std::auto_ptr<BackupProtocolClientSuccess> stored( 
     494        std::auto_ptr<BackupProtocolSuccess> stored( 
    495495                protocol.QueryStoreFile( 
    496496                        parentId, 
    … …  
    516516                int attrS = 0; 
    517517                MemBlockStream attr(&attrS, sizeof(attrS)); 
    518                 std::auto_ptr<BackupProtocolClientSuccess> dirCreate(protocol.QueryCreateDirectory( 
     518                std::auto_ptr<BackupProtocolSuccess> dirCreate(protocol.QueryCreateDirectory( 
    519519                        indir, 
    520520                        9837429842987984LL, dirname, attr)); 
    … …  
    551551{ 
    552552        // Command 
    553         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocol.QueryListDirectory( 
    554                         BackupProtocolClientListDirectory::RootDirectory, 
    555                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    556                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    557         TEST_THAT(dirreply->GetObjectID() == BackupProtocolClientListDirectory::RootDirectory); 
     553        std::auto_ptr<BackupProtocolSuccess> dirreply(protocol.QueryListDirectory( 
     554                        BackupProtocolListDirectory::RootDirectory, 
     555                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     556                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     557        TEST_THAT(dirreply->GetObjectID() == BackupProtocolListDirectory::RootDirectory); 
    558558        // Stream 
    559559        BackupStoreDirectory dir; 
    … …  
    576576                TEST_THAT(en->GetObjectID() == uploads[t].allocated_objid); 
    577577                TEST_THAT(en->GetModificationTime() == uploads[t].mod_time); 
    578                 int correct_flags = BackupProtocolClientListDirectory::Flags_File; 
    579                 if(uploads[t].should_be_old_version) correct_flags |= BackupProtocolClientListDirectory::Flags_OldVersion; 
    580                 if(uploads[t].delete_file) correct_flags |= BackupProtocolClientListDirectory::Flags_Deleted; 
     578                int correct_flags = BackupProtocolListDirectory::Flags_File; 
     579                if(uploads[t].should_be_old_version) correct_flags |= BackupProtocolListDirectory::Flags_OldVersion; 
     580                if(uploads[t].delete_file) correct_flags |= BackupProtocolListDirectory::Flags_Deleted; 
    581581                TEST_THAT(en->GetFlags() == correct_flags); 
    582582                if(t == UPLOAD_ATTRS_EN) 
    … …  
    607607{ 
    608608        // Command 
    609         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocol.QueryListDirectory( 
     609        std::auto_ptr<BackupProtocolSuccess> dirreply(protocol.QueryListDirectory( 
    610610                        id, 
    611                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    612                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     611                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     612                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    613613        // Stream 
    614614        BackupStoreDirectory dir; 
    … …  
    650650 
    651651        { 
    652                 std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocolReadOnly.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     652                std::auto_ptr<BackupProtocolVersion> serverVersion(protocolReadOnly.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    653653                TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    654                 std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(protocolReadOnly.QueryLogin(0x01234567, BackupProtocolClientLogin::Flags_ReadOnly)); 
     654                std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(protocolReadOnly.QueryLogin(0x01234567, BackupProtocolLogin::Flags_ReadOnly)); 
    655655        } 
    656656         
    … …  
    759759        { 
    760760                // Command 
    761                 std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocol.QueryListDirectory( 
    762                                 BackupProtocolClientListDirectory::RootDirectory, 
    763                                 BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    764                                 BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     761                std::auto_ptr<BackupProtocolSuccess> dirreply(protocol.QueryListDirectory( 
     762                                BackupProtocolListDirectory::RootDirectory, 
     763                                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     764                                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    765765                // Stream 
    766766                BackupStoreDirectory dir; 
    … …  
    773773        { 
    774774                // Command 
    775                 std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    776                                 BackupProtocolClientListDirectory::RootDirectory, 
    777                                 BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    778                                 BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     775                std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     776                                BackupProtocolListDirectory::RootDirectory, 
     777                                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     778                                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    779779                // Stream 
    780780                BackupStoreDirectory dir; 
    … …  
    788788        { 
    789789                FileStream out("testfiles/file1_upload1", O_WRONLY | O_CREAT | O_EXCL); 
    790                 std::auto_ptr<IOStream> encoded(BackupStoreFile::EncodeFile("testfiles/file1", BackupProtocolClientListDirectory::RootDirectory, store1name)); 
     790                std::auto_ptr<IOStream> encoded(BackupStoreFile::EncodeFile("testfiles/file1", BackupProtocolListDirectory::RootDirectory, store1name)); 
    791791                encoded->CopyStreamTo(out); 
    792792        } 
    … …  
    798798        { 
    799799                FileStream upload("testfiles/file1_upload1"); 
    800                 std::auto_ptr<BackupProtocolClientSuccess> stored(protocol.QueryStoreFile( 
    801                         BackupProtocolClientListDirectory::RootDirectory, 
     800                std::auto_ptr<BackupProtocolSuccess> stored(protocol.QueryStoreFile( 
     801                        BackupProtocolListDirectory::RootDirectory, 
    802802                        0x123456789abcdefLL,            /* modification time */ 
    803803                        0x7362383249872dfLL,            /* attr hash */ 
    … …  
    812812        { 
    813813                // Retrieve as object 
    814                 std::auto_ptr<BackupProtocolClientSuccess> getfile(protocol.QueryGetObject(store1objid)); 
     814                std::auto_ptr<BackupProtocolSuccess> getfile(protocol.QueryGetObject(store1objid)); 
    815815                TEST_THAT(getfile->GetObjectID() == store1objid); 
    816816                // BLOCK 
    … …  
    827827 
    828828                // Retrieve as file 
    829                 std::auto_ptr<BackupProtocolClientSuccess> getobj(protocol.QueryGetFile(BackupProtocolClientListDirectory::RootDirectory, store1objid)); 
     829                std::auto_ptr<BackupProtocolSuccess> getobj(protocol.QueryGetFile(BackupProtocolListDirectory::RootDirectory, store1objid)); 
    830830                TEST_THAT(getobj->GetObjectID() == store1objid); 
    831831                // BLOCK 
    … …  
    853853                // Retrieve the block index, by ID 
    854854                { 
    855                         std::auto_ptr<BackupProtocolClientSuccess> getblockindex(protocol.QueryGetBlockIndexByID(store1objid)); 
     855                        std::auto_ptr<BackupProtocolSuccess> getblockindex(protocol.QueryGetBlockIndexByID(store1objid)); 
    856856                        TEST_THAT(getblockindex->GetObjectID() == store1objid); 
    857857                        std::auto_ptr<IOStream> blockIndexStream(protocol.ReceiveStream()); 
    … …  
    861861                // and again, by name 
    862862                { 
    863                         std::auto_ptr<BackupProtocolClientSuccess> getblockindex(protocol.QueryGetBlockIndexByName(BackupProtocolClientListDirectory::RootDirectory, store1name)); 
     863                        std::auto_ptr<BackupProtocolSuccess> getblockindex(protocol.QueryGetBlockIndexByName(BackupProtocolListDirectory::RootDirectory, store1name)); 
    864864                        TEST_THAT(getblockindex->GetObjectID() == store1objid); 
    865865                        std::auto_ptr<IOStream> blockIndexStream(protocol.ReceiveStream()); 
    … …  
    871871        { 
    872872                // Command 
    873                 std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocol.QueryListDirectory( 
    874                                 BackupProtocolClientListDirectory::RootDirectory, 
    875                                 BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    876                                 BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     873                std::auto_ptr<BackupProtocolSuccess> dirreply(protocol.QueryListDirectory( 
     874                                BackupProtocolListDirectory::RootDirectory, 
     875                                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     876                                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    877877                // Stream 
    878878                BackupStoreDirectory dir; 
    … …  
    897897        // Try using GetFile on a directory 
    898898        { 
    899                 TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolClientSuccess> getFile(protocol.QueryGetFile(BackupProtocolClientListDirectory::RootDirectory, BackupProtocolClientListDirectory::RootDirectory)), 
     899                TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolSuccess> getFile(protocol.QueryGetFile(BackupProtocolListDirectory::RootDirectory, BackupProtocolListDirectory::RootDirectory)), 
    900900                        ConnectionException, Conn_Protocol_UnexpectedReply); 
    901901        } 
    … …  
    930930         
    931931        // Check the version 
    932         std::auto_ptr<BackupProtocolClientVersion> serverVersion( 
     932        std::auto_ptr<BackupProtocolVersion> serverVersion( 
    933933                protocol->QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    934934        TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    935935 
    936936        // Login 
    937         std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf( 
     937        std::auto_ptr<BackupProtocolLoginConfirmed> loginConf( 
    938938                protocol->QueryLogin(0x01234567, 0)); 
    939939 
    … …  
    10101010                                BOX_PORT_BBSTORED_TEST); 
    10111011                        BackupProtocolClient protocol(conn); 
    1012                         std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     1012                        std::auto_ptr<BackupProtocolVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    10131013                        TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    1014                         TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(protocol.QueryLogin(0x01234567, 0)), 
     1014                        TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(protocol.QueryLogin(0x01234567, 0)), 
    10151015                                ConnectionException, Conn_Protocol_UnexpectedReply); 
    10161016                        protocol.QueryFinished(); 
    … …  
    10341034 
    10351035                { 
    1036                         std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocolReadOnly.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     1036                        std::auto_ptr<BackupProtocolVersion> serverVersion(protocolReadOnly.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    10371037                        TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    1038                         std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(protocolReadOnly.QueryLogin(0x01234567, BackupProtocolClientLogin::Flags_ReadOnly)); 
     1038                        std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(protocolReadOnly.QueryLogin(0x01234567, BackupProtocolLogin::Flags_ReadOnly)); 
    10391039                         
    10401040                        // Check client store marker 
    … …  
    10801080                        int64_t modtime = 0; 
    10811081 
    1082                         std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile(filename.c_str(), BackupProtocolClientListDirectory::RootDirectory, uploads[t].name, &modtime)); 
     1082                        std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile(filename.c_str(), BackupProtocolListDirectory::RootDirectory, uploads[t].name, &modtime)); 
    10831083                        TEST_THAT(modtime != 0); 
    10841084                         
    1085                         std::auto_ptr<BackupProtocolClientSuccess> stored(apProtocol->QueryStoreFile( 
    1086                                 BackupProtocolClientListDirectory::RootDirectory, 
     1085                        std::auto_ptr<BackupProtocolSuccess> stored(apProtocol->QueryStoreFile( 
     1086                                BackupProtocolListDirectory::RootDirectory, 
    10871087                                modtime, 
    10881088                                modtime, /* use it for attr hash too */ 
    … …  
    11081108                        TEST_NUM_FILES(UPLOAD_NUM + 1, 0, 0, 1); 
    11091109                        MemBlockStream attrnew(attr3, sizeof(attr3)); 
    1110                         std::auto_ptr<BackupProtocolClientSuccess> set(apProtocol->QuerySetReplacementFileAttributes( 
    1111                                 BackupProtocolClientListDirectory::RootDirectory, 
     1110                        std::auto_ptr<BackupProtocolSuccess> set(apProtocol->QuerySetReplacementFileAttributes( 
     1111                                BackupProtocolListDirectory::RootDirectory, 
    11121112                                32498749832475LL, 
    11131113                                uploads[UPLOAD_ATTRS_EN].name, 
    … …  
    11191119                // Delete one of them (will implicitly delete an old version) 
    11201120                { 
    1121                         std::auto_ptr<BackupProtocolClientSuccess> del(apProtocol->QueryDeleteFile( 
    1122                                 BackupProtocolClientListDirectory::RootDirectory, 
     1121                        std::auto_ptr<BackupProtocolSuccess> del(apProtocol->QueryDeleteFile( 
     1122                                BackupProtocolListDirectory::RootDirectory, 
    11231123                                uploads[UPLOAD_DELETE_EN].name)); 
    11241124                        TEST_THAT(del->GetObjectID() == uploads[UPLOAD_DELETE_EN].allocated_objid); 
    … …  
    11311131                        { 
    11321132                                FileStream out("testfiles/downloaddelobj", O_WRONLY | O_CREAT); 
    1133                                 std::auto_ptr<BackupProtocolClientSuccess> getobj(apProtocol->QueryGetObject(uploads[UPLOAD_DELETE_EN].allocated_objid)); 
     1133                                std::auto_ptr<BackupProtocolSuccess> getobj(apProtocol->QueryGetObject(uploads[UPLOAD_DELETE_EN].allocated_objid)); 
    11341134                                std::auto_ptr<IOStream> objstream(apProtocol->ReceiveStream()); 
    11351135                                objstream->CopyStreamTo(out); 
    11361136                        } 
    11371137                        // query index and test 
    1138                         std::auto_ptr<BackupProtocolClientSuccess> getblockindex(apProtocol->QueryGetBlockIndexByName( 
    1139                                 BackupProtocolClientListDirectory::RootDirectory, uploads[UPLOAD_DELETE_EN].name)); 
     1138                        std::auto_ptr<BackupProtocolSuccess> getblockindex(apProtocol->QueryGetBlockIndexByName( 
     1139                                BackupProtocolListDirectory::RootDirectory, uploads[UPLOAD_DELETE_EN].name)); 
    11401140                        TEST_THAT(getblockindex->GetObjectID() == uploads[UPLOAD_DELETE_EN].allocated_objid); 
    11411141                        std::auto_ptr<IOStream> blockIndexStream(apProtocol->ReceiveStream()); 
    … …  
    11471147                { 
    11481148                        printf("%d\n", t); 
    1149                         std::auto_ptr<BackupProtocolClientSuccess> getFile(apProtocol->QueryGetFile(BackupProtocolClientListDirectory::RootDirectory, uploads[t].allocated_objid)); 
     1149                        std::auto_ptr<BackupProtocolSuccess> getFile(apProtocol->QueryGetFile(BackupProtocolListDirectory::RootDirectory, uploads[t].allocated_objid)); 
    11501150                        TEST_THAT(getFile->GetObjectID() == uploads[t].allocated_objid); 
    11511151                        std::auto_ptr<IOStream> filestream(apProtocol->ReceiveStream()); 
    … …  
    12071207                { 
    12081208                        // Fetch the block index for this one 
    1209                         std::auto_ptr<BackupProtocolClientSuccess> getblockindex(apProtocol->QueryGetBlockIndexByName( 
    1210                                 BackupProtocolClientListDirectory::RootDirectory, uploads[UPLOAD_PATCH_EN].name)); 
     1209                        std::auto_ptr<BackupProtocolSuccess> getblockindex(apProtocol->QueryGetBlockIndexByName( 
     1210                                BackupProtocolListDirectory::RootDirectory, uploads[UPLOAD_PATCH_EN].name)); 
    12111211                        TEST_THAT(getblockindex->GetObjectID() == uploads[UPLOAD_PATCH_EN].allocated_objid); 
    12121212                        std::auto_ptr<IOStream> blockIndexStream(apProtocol->ReceiveStream()); 
    … …  
    12181218                                BackupStoreFile::EncodeFileDiff( 
    12191219                                        TEST_FILE_FOR_PATCHING ".mod",  
    1220                                         BackupProtocolClientListDirectory::RootDirectory, 
     1220                                        BackupProtocolListDirectory::RootDirectory, 
    12211221                                        uploads[UPLOAD_PATCH_EN].name,  
    12221222                                        uploads[UPLOAD_PATCH_EN].allocated_objid,  
    … …  
    12371237                        { 
    12381238                                FileStream uploadpatch(TEST_FILE_FOR_PATCHING ".patch"); 
    1239                                 std::auto_ptr<BackupProtocolClientSuccess> stored(apProtocol->QueryStoreFile( 
    1240                                         BackupProtocolClientListDirectory::RootDirectory, 
     1239                                std::auto_ptr<BackupProtocolSuccess> stored(apProtocol->QueryStoreFile( 
     1240                                        BackupProtocolListDirectory::RootDirectory, 
    12411241                                        modtime, 
    12421242                                        modtime, /* use it for attr hash too */ 
    … …  
    12521252 
    12531253                        // Then download it to check it's OK 
    1254                         std::auto_ptr<BackupProtocolClientSuccess> getFile(apProtocol->QueryGetFile(BackupProtocolClientListDirectory::RootDirectory, patchedID)); 
     1254                        std::auto_ptr<BackupProtocolSuccess> getFile(apProtocol->QueryGetFile(BackupProtocolListDirectory::RootDirectory, patchedID)); 
    12551255                        TEST_THAT(getFile->GetObjectID() == patchedID); 
    12561256                        std::auto_ptr<IOStream> filestream(apProtocol->ReceiveStream()); 
    … …  
    12681268                        // Attributes 
    12691269                        MemBlockStream attr(attr1, sizeof(attr1)); 
    1270                         std::auto_ptr<BackupProtocolClientSuccess> dirCreate(apProtocol->QueryCreateDirectory( 
    1271                                 BackupProtocolClientListDirectory::RootDirectory, 
     1270                        std::auto_ptr<BackupProtocolSuccess> dirCreate(apProtocol->QueryCreateDirectory( 
     1271                                BackupProtocolListDirectory::RootDirectory, 
    12721272                                9837429842987984LL, dirname, attr)); 
    12731273                        subdirid = dirCreate->GetObjectID();  
    … …  
    12861286                        std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile(filename.c_str(), subdirid, uploads[0].name, &modtime)); 
    12871287 
    1288                         std::auto_ptr<BackupProtocolClientSuccess> stored(apProtocol->QueryStoreFile( 
     1288                        std::auto_ptr<BackupProtocolSuccess> stored(apProtocol->QueryStoreFile( 
    12891289                                subdirid, 
    12901290                                modtime, 
    … …  
    13041304                { 
    13051305                        // Command 
    1306                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    1307                                         BackupProtocolClientListDirectory::RootDirectory, 
    1308                                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    1309                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes! */)); // Stream 
     1306                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1307                                        BackupProtocolListDirectory::RootDirectory, 
     1308                                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     1309                                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes! */)); // Stream 
    13101310                        BackupStoreDirectory dir; 
    13111311                        std::auto_ptr<IOStream> dirstream(protocolReadOnly.ReceiveStream()); 
    … …  
    13291329                        // Does it look right? 
    13301330                        TEST_THAT(en->GetName() == dirname); 
    1331                         TEST_THAT(en->GetFlags() == BackupProtocolClientListDirectory::Flags_Dir); 
     1331                        TEST_THAT(en->GetFlags() == BackupProtocolListDirectory::Flags_Dir); 
    13321332                        TEST_THAT(en->GetObjectID() == subdirid); 
    13331333                        TEST_THAT(en->GetModificationTime() == 0);      // dirs don't have modification times. 
    … …  
    13361336                { 
    13371337                        // Command 
    1338                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1338                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    13391339                                        subdirid, 
    1340                                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    1341                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, true /* get attributes */)); 
     1340                                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     1341                                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, true /* get attributes */)); 
    13421342                        TEST_THAT(dirreply->GetObjectID() == subdirid); 
    13431343                        // Stream 
    … …  
    13541354                        // Does it look right? 
    13551355                        TEST_THAT(en->GetName() == uploads[0].name); 
    1356                         TEST_THAT(en->GetFlags() == BackupProtocolClientListDirectory::Flags_File); 
     1356                        TEST_THAT(en->GetFlags() == BackupProtocolListDirectory::Flags_File); 
    13571357                        TEST_THAT(en->GetObjectID() == subdirfileid); 
    13581358                        TEST_THAT(en->GetModificationTime() != 0); 
    … …  
    13691369                { 
    13701370                        // Command 
    1371                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1371                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    13721372                                        subdirid, 
    1373                                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    1374                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes! */)); 
     1373                                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     1374                                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes! */)); 
    13751375                        // Stream 
    13761376                        BackupStoreDirectory dir; 
    … …  
    13861386                { 
    13871387                        MemBlockStream attrnew(attr2, sizeof(attr2)); 
    1388                         std::auto_ptr<BackupProtocolClientSuccess> changereply(apProtocol->QueryChangeDirAttributes( 
     1388                        std::auto_ptr<BackupProtocolSuccess> changereply(apProtocol->QueryChangeDirAttributes( 
    13891389                                        subdirid, 
    13901390                                        329483209443598LL, 
    … …  
    13951395                { 
    13961396                        // Command 
    1397                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1397                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    13981398                                        subdirid, 
    13991399                                        0,      // no flags 
    1400                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_EVERYTHING, true /* get attributes */)); 
     1400                                        BackupProtocolListDirectory::Flags_EXCLUDE_EVERYTHING, true /* get attributes */)); 
    14011401                        // Stream 
    14021402                        BackupStoreDirectory dir; 
    … …  
    14191419                        BackupStoreFilenameClear newName("moved-files"); 
    14201420                 
    1421                         std::auto_ptr<BackupProtocolClientSuccess> rep(apProtocol->QueryMoveObject(uploads[UPLOAD_FILE_TO_MOVE].allocated_objid, 
    1422                                 BackupProtocolClientListDirectory::RootDirectory, 
    1423                                 subdirid, BackupProtocolClientMoveObject::Flags_MoveAllWithSameName, newName)); 
     1421                        std::auto_ptr<BackupProtocolSuccess> rep(apProtocol->QueryMoveObject(uploads[UPLOAD_FILE_TO_MOVE].allocated_objid, 
     1422                                BackupProtocolListDirectory::RootDirectory, 
     1423                                subdirid, BackupProtocolMoveObject::Flags_MoveAllWithSameName, newName)); 
    14241424                        TEST_THAT(rep->GetObjectID() == uploads[UPLOAD_FILE_TO_MOVE].allocated_objid); 
    14251425                } 
    … …  
    14291429                        BackupStoreFilenameClear newName("moved-files"); 
    14301430                        TEST_CHECK_THROWS(apProtocol->QueryMoveObject(uploads[UPLOAD_FILE_TO_MOVE].allocated_objid, 
    1431                                         BackupProtocolClientListDirectory::RootDirectory, 
    1432                                         subdirid, BackupProtocolClientMoveObject::Flags_MoveAllWithSameName, newName), 
     1431                                        BackupProtocolListDirectory::RootDirectory, 
     1432                                        subdirid, BackupProtocolMoveObject::Flags_MoveAllWithSameName, newName), 
    14331433                                ConnectionException, Conn_Protocol_UnexpectedReply); 
    14341434                        TEST_CHECK_THROWS(apProtocol->QueryMoveObject(uploads[UPLOAD_FILE_TO_MOVE].allocated_objid, 
    14351435                                        subdirid, 
    1436                                         subdirid, BackupProtocolClientMoveObject::Flags_MoveAllWithSameName, newName), 
     1436                                        subdirid, BackupProtocolMoveObject::Flags_MoveAllWithSameName, newName), 
    14371437                                ConnectionException, Conn_Protocol_UnexpectedReply); 
    14381438                } 
    … …  
    14431443                        apProtocol->QueryMoveObject(uploads[UPLOAD_FILE_TO_MOVE].allocated_objid, 
    14441444                                subdirid, 
    1445                                 subdirid, BackupProtocolClientMoveObject::Flags_MoveAllWithSameName, newName); 
     1445                                subdirid, BackupProtocolMoveObject::Flags_MoveAllWithSameName, newName); 
    14461446                } 
    14471447 
    … …  
    14491449                { 
    14501450                        // Command 
    1451                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    1452                                         BackupProtocolClientListDirectory::RootDirectory, 
    1453                                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    1454                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     1451                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1452                                        BackupProtocolListDirectory::RootDirectory, 
     1453                                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     1454                                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    14551455                        // Stream 
    14561456                        BackupStoreDirectory dir; 
    … …  
    14711471 
    14721472                        // Command 
    1473                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1473                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    14741474                                        subdirid, 
    1475                                         BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    1476                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     1475                                        BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     1476                                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    14771477                        // Stream 
    14781478                        BackupStoreDirectory dir; 
    … …  
    15061506                        // Attributes 
    15071507                        MemBlockStream attr(attr1, sizeof(attr1)); 
    1508                         std::auto_ptr<BackupProtocolClientSuccess> dirCreate(apProtocol->QueryCreateDirectory( 
     1508                        std::auto_ptr<BackupProtocolSuccess> dirCreate(apProtocol->QueryCreateDirectory( 
    15091509                                subdirid, 
    15101510                                9837429842987984LL, nd, attr)); 
    … …  
    15131513                        FileStream upload("testfiles/file1_upload1"); 
    15141514                        BackupStoreFilenameClear nf("file2"); 
    1515                         std::auto_ptr<BackupProtocolClientSuccess> stored(apProtocol->QueryStoreFile( 
     1515                        std::auto_ptr<BackupProtocolSuccess> stored(apProtocol->QueryStoreFile( 
    15161516                                subsubdirid, 
    15171517                                0x123456789abcdefLL,            /* modification time */ 
    … …  
    15281528                // Query names -- test that invalid stuff returns not found OK 
    15291529                { 
    1530                         std::auto_ptr<BackupProtocolClientObjectName> nameRep(apProtocol->QueryGetObjectName(3248972347823478927LL, subsubdirid)); 
     1530                        std::auto_ptr<BackupProtocolObjectName> nameRep(apProtocol->QueryGetObjectName(3248972347823478927LL, subsubdirid)); 
    15311531                        TEST_THAT(nameRep->GetNumNameElements() == 0);           
    15321532                } 
    15331533                { 
    1534                         std::auto_ptr<BackupProtocolClientObjectName> nameRep(apProtocol->QueryGetObjectName(subsubfileid, 2342378424LL)); 
     1534                        std::auto_ptr<BackupProtocolObjectName> nameRep(apProtocol->QueryGetObjectName(subsubfileid, 2342378424LL)); 
    15351535                        TEST_THAT(nameRep->GetNumNameElements() == 0);           
    15361536                } 
    15371537                { 
    1538                         std::auto_ptr<BackupProtocolClientObjectName> nameRep(apProtocol->QueryGetObjectName(38947234789LL, 2342378424LL)); 
     1538                        std::auto_ptr<BackupProtocolObjectName> nameRep(apProtocol->QueryGetObjectName(38947234789LL, 2342378424LL)); 
    15391539                        TEST_THAT(nameRep->GetNumNameElements() == 0);           
    15401540                } 
    15411541                { 
    1542                         std::auto_ptr<BackupProtocolClientObjectName> nameRep(apProtocol->QueryGetObjectName(BackupProtocolClientGetObjectName::ObjectID_DirectoryOnly, 2234342378424LL)); 
     1542                        std::auto_ptr<BackupProtocolObjectName> nameRep(apProtocol->QueryGetObjectName(BackupProtocolGetObjectName::ObjectID_DirectoryOnly, 2234342378424LL)); 
    15431543                        TEST_THAT(nameRep->GetNumNameElements() == 0);           
    15441544                } 
    … …  
    15461546                // Query names... first, get info for the file 
    15471547                { 
    1548                         std::auto_ptr<BackupProtocolClientObjectName> nameRep(apProtocol->QueryGetObjectName(subsubfileid, subsubdirid)); 
     1548                        std::auto_ptr<BackupProtocolObjectName> nameRep(apProtocol->QueryGetObjectName(subsubfileid, subsubdirid)); 
    15491549                        std::auto_ptr<IOStream> namestream(apProtocol->ReceiveStream()); 
    15501550                 
    15511551                        TEST_THAT(nameRep->GetNumNameElements() == 3); 
    1552                         TEST_THAT(nameRep->GetFlags() == BackupProtocolClientListDirectory::Flags_File); 
     1552                        TEST_THAT(nameRep->GetFlags() == BackupProtocolListDirectory::Flags_File); 
    15531553                        TEST_THAT(nameRep->GetModificationTime() == 0x123456789abcdefLL); 
    15541554                        TEST_THAT(nameRep->GetAttributesHash() == 0x7362383249872dfLL); 
    … …  
    15641564                // Query names... secondly, for the directory 
    15651565                { 
    1566                         std::auto_ptr<BackupProtocolClientObjectName> nameRep(apProtocol->QueryGetObjectName(BackupProtocolClientGetObjectName::ObjectID_DirectoryOnly, subsubdirid)); 
     1566                        std::auto_ptr<BackupProtocolObjectName> nameRep(apProtocol->QueryGetObjectName(BackupProtocolGetObjectName::ObjectID_DirectoryOnly, subsubdirid)); 
    15671567                        std::auto_ptr<IOStream> namestream(apProtocol->ReceiveStream()); 
    15681568                 
    15691569                        TEST_THAT(nameRep->GetNumNameElements() == 2); 
    1570                         TEST_THAT(nameRep->GetFlags() == BackupProtocolClientListDirectory::Flags_Dir); 
     1570                        TEST_THAT(nameRep->GetFlags() == BackupProtocolListDirectory::Flags_Dir); 
    15711571                        static const char *testnames[] = {"sub2","lovely_directory"}; 
    15721572                        for(int l = 0; l < nameRep->GetNumNameElements(); ++l) 
    … …  
    15861586                // Create some nice recursive directories 
    15871587                int64_t dirtodelete = create_test_data_subdirs(*apProtocol, 
    1588                         BackupProtocolClientListDirectory::RootDirectory, 
     1588                        BackupProtocolListDirectory::RootDirectory, 
    15891589                        "test_delete", 6 /* depth */, *apRefCount); 
    15901590                 
    15911591                // And delete them 
    15921592                { 
    1593                         std::auto_ptr<BackupProtocolClientSuccess> dirdel(apProtocol->QueryDeleteDirectory( 
     1593                        std::auto_ptr<BackupProtocolSuccess> dirdel(apProtocol->QueryDeleteDirectory( 
    15941594                                        dirtodelete)); 
    15951595                        TEST_THAT(dirdel->GetObjectID() == dirtodelete); 
    … …  
    15991599                { 
    16001600                        // Command 
    1601                         std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
    1602                                         BackupProtocolClientListDirectory::RootDirectory, 
    1603                                         BackupProtocolClientListDirectory::Flags_Dir | BackupProtocolClientListDirectory::Flags_Deleted, 
    1604                                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     1601                        std::auto_ptr<BackupProtocolSuccess> dirreply(protocolReadOnly.QueryListDirectory( 
     1602                                        BackupProtocolListDirectory::RootDirectory, 
     1603                                        BackupProtocolListDirectory::Flags_Dir | BackupProtocolListDirectory::Flags_Deleted, 
     1604                                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    16051605                        // Stream 
    16061606                        BackupStoreDirectory dir; 
    … …  
    18901890 
    18911891                        // Check the version 
    1892                         std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     1892                        std::auto_ptr<BackupProtocolVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    18931893                        TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    18941894 
    18951895                        // Login 
    1896                         TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(protocol.QueryLogin(0x01234567, 0)), 
     1896                        TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(protocol.QueryLogin(0x01234567, 0)), 
    18971897                                ConnectionException, Conn_Protocol_UnexpectedReply); 
    18981898                         
    … …  
    19891989                recursive_count_objects_results before = {0,0,0}; 
    19901990 
    1991                 recursive_count_objects("localhost", BackupProtocolClientListDirectory::RootDirectory, before); 
     1991                recursive_count_objects("localhost", BackupProtocolListDirectory::RootDirectory, before); 
    19921992                 
    19931993                TEST_THAT(before.objectsNotDel != 0); 
    … …  
    20342034                recursive_count_objects_results after = {0,0,0}; 
    20352035                recursive_count_objects("localhost",  
    2036                         BackupProtocolClientListDirectory::RootDirectory,  
     2036                        BackupProtocolListDirectory::RootDirectory,  
    20372037                        after); 
    20382038 
    … …  
    20592059 
    20602060                        // Check the version 
    2061                         std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     2061                        std::auto_ptr<BackupProtocolVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    20622062                        TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    20632063 
    20642064                        // Login 
    2065                         std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(protocol.QueryLogin(0x01234567, 0)); 
     2065                        std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(protocol.QueryLogin(0x01234567, 0)); 
    20662066                         
    20672067                        int64_t modtime = 0; 
    20682068                         
    20692069                        BackupStoreFilenameClear fnx("exceed-limit"); 
    2070                         std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile("testfiles/test3", BackupProtocolClientListDirectory::RootDirectory, fnx, &modtime)); 
     2070                        std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile("testfiles/test3", BackupProtocolListDirectory::RootDirectory, fnx, &modtime)); 
    20712071                        TEST_THAT(modtime != 0); 
    20722072 
    2073                         TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolClientSuccess> stored(protocol.QueryStoreFile( 
    2074                                         BackupProtocolClientListDirectory::RootDirectory, 
     2073                        TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolSuccess> stored(protocol.QueryStoreFile( 
     2074                                        BackupProtocolListDirectory::RootDirectory, 
    20752075                                        modtime, 
    20762076                                        modtime, /* use it for attr hash too */ 
    … …  
    20822082                        MemBlockStream attr(&modtime, sizeof(modtime)); 
    20832083                        BackupStoreFilenameClear fnxd("exceed-limit-dir"); 
    2084                         TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolClientSuccess> dirCreate(protocol.QueryCreateDirectory( 
    2085                                         BackupProtocolClientListDirectory::RootDirectory, 
     2084                        TEST_CHECK_THROWS(std::auto_ptr<BackupProtocolSuccess> dirCreate(protocol.QueryCreateDirectory( 
     2085                                        BackupProtocolListDirectory::RootDirectory, 
    20862086                                        9837429842987984LL, fnxd, attr)), 
    20872087                                ConnectionException, Conn_Protocol_UnexpectedReply); 
    … …  
    22412241                int64_t modtime = 0; 
    22422242                std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile("/Users/ben/temp/large.tar", 
    2243                         BackupProtocolClientListDirectory::RootDirectory, uploads[0].name, &modtime)); 
     2243                        BackupProtocolListDirectory::RootDirectory, uploads[0].name, &modtime)); 
    22442244                TEST_THAT(modtime != 0); 
    22452245                FileStream write("testfiles/large.enc", O_WRONLY | O_CREAT); 
Note: See TracChangeset for help on using the changeset viewer.