Changeset 2983 for box/trunk/test


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.

Location:
box/trunk/test
Files:
7 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); 

  • box/trunk/test/backupstorepatch/testbackupstorepatch.cpp

    r2646 r2983  
    1414#include <signal.h> 
    1515 
    16 #include "autogen_BackupProtocolClient.h" 
     16#include "autogen_BackupProtocol.h" 
    1717#include "BackupClientCryptoKeys.h" 
    1818#include "BackupClientFileAttributes.h" 
    … …  
    355355                        { 
    356356                                // Check the version 
    357                                 std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     357                                std::auto_ptr<BackupProtocolVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    358358                                TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    359359         
    … …  
    368368                        { 
    369369                                std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile("testfiles/0.test", 
    370                                                 BackupProtocolClientListDirectory::RootDirectory, storeFilename)); 
    371                                 std::auto_ptr<BackupProtocolClientSuccess> stored(protocol.QueryStoreFile( 
    372                                                 BackupProtocolClientListDirectory::RootDirectory, ModificationTime, 
     370                                                BackupProtocolListDirectory::RootDirectory, storeFilename)); 
     371                                std::auto_ptr<BackupProtocolSuccess> stored(protocol.QueryStoreFile( 
     372                                                BackupProtocolListDirectory::RootDirectory, ModificationTime, 
    373373                                                ModificationTime, 0 /* no diff from file ID */, storeFilename, *upload)); 
    374374                                test_files[0].IDOnServer = stored->GetObjectID(); 
    … …  
    381381                        { 
    382382                                // Get an index for the previous version 
    383                                 std::auto_ptr<BackupProtocolClientSuccess> getBlockIndex(protocol.QueryGetBlockIndexByName( 
    384                                                 BackupProtocolClientListDirectory::RootDirectory, storeFilename)); 
     383                                std::auto_ptr<BackupProtocolSuccess> getBlockIndex(protocol.QueryGetBlockIndexByName( 
     384                                                BackupProtocolListDirectory::RootDirectory, storeFilename)); 
    385385                                int64_t diffFromID = getBlockIndex->GetObjectID(); 
    386386                                TEST_THAT(diffFromID != 0); 
    … …  
    398398                                                BackupStoreFile::EncodeFileDiff( 
    399399                                                        filename, 
    400                                                         BackupProtocolClientListDirectory::RootDirectory,       /* containing directory */ 
     400                                                        BackupProtocolListDirectory::RootDirectory,     /* containing directory */ 
    401401                                                        storeFilename,  
    402402                                                        diffFromID,  
    … …  
    408408                 
    409409                                        // Upload the patch to the store 
    410                                         std::auto_ptr<BackupProtocolClientSuccess> stored(protocol.QueryStoreFile( 
    411                                                         BackupProtocolClientListDirectory::RootDirectory, ModificationTime, 
     410                                        std::auto_ptr<BackupProtocolSuccess> stored(protocol.QueryStoreFile( 
     411                                                        BackupProtocolListDirectory::RootDirectory, ModificationTime, 
    412412                                                        ModificationTime, isCompletelyDifferent?(0):(diffFromID), storeFilename, *patchStream)); 
    413413                                        ModificationTime += MODIFICATION_TIME_INC; 
    … …  
    433433                        // List the directory from the server, and check that no dependency info is sent -- waste of bytes 
    434434                        { 
    435                                 std::auto_ptr<BackupProtocolClientSuccess> dirreply(protocol.QueryListDirectory( 
    436                                                 BackupProtocolClientListDirectory::RootDirectory, 
    437                                                 BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING, 
    438                                                 BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
     435                                std::auto_ptr<BackupProtocolSuccess> dirreply(protocol.QueryListDirectory( 
     436                                                BackupProtocolListDirectory::RootDirectory, 
     437                                                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING, 
     438                                                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, false /* no attributes */)); 
    439439                                // Stream 
    440440                                BackupStoreDirectory dir; 
    … …  
    532532                        BackupProtocolClient protocol(conn); 
    533533                        { 
    534                                 std::auto_ptr<BackupProtocolClientVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
     534                                std::auto_ptr<BackupProtocolVersion> serverVersion(protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION)); 
    535535                                TEST_THAT(serverVersion->GetVersion() == BACKUP_STORE_SERVER_VERSION); 
    536536                                protocol.QueryLogin(0x01234567, 0); 
    … …  
    556556                                // Fetch the file 
    557557                                { 
    558                                         std::auto_ptr<BackupProtocolClientSuccess> getobj(protocol.QueryGetFile( 
    559                                                 BackupProtocolClientListDirectory::RootDirectory, 
     558                                        std::auto_ptr<BackupProtocolSuccess> getobj(protocol.QueryGetFile( 
     559                                                BackupProtocolListDirectory::RootDirectory, 
    560560                                                test_files[f].IDOnServer)); 
    561561                                        TEST_THAT(getobj->GetObjectID() == test_files[f].IDOnServer); 
    … …  
    573573                                // Download the index, and check it looks OK 
    574574                                { 
    575                                         std::auto_ptr<BackupProtocolClientSuccess> getblockindex(protocol.QueryGetBlockIndexByID(test_files[f].IDOnServer)); 
     575                                        std::auto_ptr<BackupProtocolSuccess> getblockindex(protocol.QueryGetBlockIndexByID(test_files[f].IDOnServer)); 
    576576                                        TEST_THAT(getblockindex->GetObjectID() == test_files[f].IDOnServer); 
    577577                                        std::auto_ptr<IOStream> blockIndexStream(protocol.ReceiveStream()); 

  • box/trunk/test/basicserver/Makefile.extra

    r2598 r2983  
    22MAKEPROTOCOL = ../../lib/server/makeprotocol.pl 
    33 
    4 GEN_CMD_SRV = $(MAKEPROTOCOL) Server testprotocol.txt 
    5 GEN_CMD_CLI = $(MAKEPROTOCOL) Client testprotocol.txt 
     4GEN_CMD = $(MAKEPROTOCOL) testprotocol.txt 
    65 
    76# AUTOGEN SEEDING 
    8 autogen_TestProtocolServer.cpp: $(MAKEPROTOCOL) testprotocol.txt 
    9         $(_PERL) $(GEN_CMD_SRV) 
     7autogen_TestProtocol.cpp:       $(MAKEPROTOCOL) testprotocol.txt 
     8        $(_PERL) $(GEN_CMD) 
    109 
    1110autogen_TestProtocolServer.h:   $(MAKEPROTOCOL) testprotocol.txt 
    12         $(_PERL) $(GEN_CMD_SRV) 
     11        $(_PERL) $(GEN_CMD) 
    1312 
    14  
    15 # AUTOGEN SEEDING 
    16 autogen_TestProtocolClient.cpp: $(MAKEPROTOCOL) testprotocol.txt 
    17         $(_PERL) $(GEN_CMD_CLI) 
    18  
    19 autogen_TestProtocolClient.h:   $(MAKEPROTOCOL) testprotocol.txt 
    20         $(_PERL) $(GEN_CMD_CLI) 
    21  

  • box/trunk/test/basicserver/TestCommands.cpp

    r710 r2983  
    66#endif 
    77 
    8 #include "autogen_TestProtocolServer.h" 
     8#include "autogen_TestProtocol.h" 
    99#include "CollectInBufferStream.h" 
    1010 
    … …  
    1212 
    1313 
    14 std::auto_ptr<ProtocolObject> TestProtocolServerHello::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     14std::auto_ptr<TestProtocolMessage> TestProtocolHello::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    1515{ 
    1616        if(mNumber32 != 41 || mNumber16 != 87 || mNumber8 != 11 || mText != "pingu") 
    1717        { 
    18                 return std::auto_ptr<ProtocolObject>(new TestProtocolServerError(0, 0)); 
     18                return std::auto_ptr<TestProtocolMessage>(new TestProtocolError(0, 0)); 
    1919        } 
    20         return std::auto_ptr<ProtocolObject>(new TestProtocolServerHello(12,89,22,std::string("Hello world!"))); 
     20        return std::auto_ptr<TestProtocolMessage>(new TestProtocolHello(12,89,22,std::string("Hello world!"))); 
    2121} 
    2222 
    23 std::auto_ptr<ProtocolObject> TestProtocolServerLists::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     23std::auto_ptr<TestProtocolMessage> TestProtocolLists::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    2424{ 
    25         return std::auto_ptr<ProtocolObject>(new TestProtocolServerListsReply(mLotsOfText.size())); 
     25        return std::auto_ptr<TestProtocolMessage>(new TestProtocolListsReply(mLotsOfText.size())); 
    2626} 
    2727 
    28 std::auto_ptr<ProtocolObject> TestProtocolServerQuit::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     28std::auto_ptr<TestProtocolMessage> TestProtocolQuit::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    2929{ 
    30         return std::auto_ptr<ProtocolObject>(new TestProtocolServerQuit); 
     30        return std::auto_ptr<TestProtocolMessage>(new TestProtocolQuit); 
    3131} 
    3232 
    33 std::auto_ptr<ProtocolObject> TestProtocolServerSimple::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     33std::auto_ptr<TestProtocolMessage> TestProtocolSimple::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    3434{ 
    35         return std::auto_ptr<ProtocolObject>(new TestProtocolServerSimpleReply(mValue+1)); 
     35        return std::auto_ptr<TestProtocolMessage>(new TestProtocolSimpleReply(mValue+1)); 
    3636} 
    3737 
    … …  
    4646}; 
    4747 
    48 std::auto_ptr<ProtocolObject> TestProtocolServerGetStream::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     48std::auto_ptr<TestProtocolMessage> TestProtocolGetStream::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    4949{ 
    5050        // make a new stream object 
    … …  
    6969        rProtocol.SendStreamAfterCommand(pstream); 
    7070 
    71         return std::auto_ptr<ProtocolObject>(new TestProtocolServerGetStream(mStartingValue, mUncertainSize)); 
     71        return std::auto_ptr<TestProtocolMessage>(new TestProtocolGetStream(mStartingValue, mUncertainSize)); 
    7272} 
    7373 
    74 std::auto_ptr<ProtocolObject> TestProtocolServerSendStream::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     74std::auto_ptr<TestProtocolMessage> TestProtocolSendStream::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    7575{ 
    7676        if(mValue != 0x73654353298ffLL) 
    7777        { 
    78                 return std::auto_ptr<ProtocolObject>(new TestProtocolServerError(0, 0)); 
     78                return std::auto_ptr<TestProtocolMessage>(new TestProtocolError(0, 0)); 
    7979        } 
    8080         
    … …  
    9292 
    9393        // tell the caller how many bytes there were 
    94         return std::auto_ptr<ProtocolObject>(new TestProtocolServerGetStream(bytes, uncertain)); 
     94        return std::auto_ptr<TestProtocolMessage>(new TestProtocolGetStream(bytes, uncertain)); 
    9595} 
    9696 
    97 std::auto_ptr<ProtocolObject> TestProtocolServerString::DoCommand(TestProtocolServer &rProtocol, TestContext &rContext) 
     97std::auto_ptr<TestProtocolMessage> TestProtocolString::DoCommand(TestProtocolReplyable &rProtocol, TestContext &rContext) const 
    9898{ 
    99         return std::auto_ptr<ProtocolObject>(new TestProtocolServerString(mTest)); 
     99        return std::auto_ptr<TestProtocolMessage>(new TestProtocolString(mTest)); 
    100100} 
    101101 

  • box/trunk/test/basicserver/testbasicserver.cpp

    r2942 r2983  
    2727 
    2828#include "TestContext.h" 
    29 #include "autogen_TestProtocolClient.h" 
    30 #include "autogen_TestProtocolServer.h" 
     29#include "autogen_TestProtocol.h" 
    3130#include "ServerControl.h" 
    3231 
    … …  
    394393void TestStreamReceive(TestProtocolClient &protocol, int value, bool uncertainstream) 
    395394{ 
    396         std::auto_ptr<TestProtocolClientGetStream> reply(protocol.QueryGetStream(value, uncertainstream)); 
     395        std::auto_ptr<TestProtocolGetStream> reply(protocol.QueryGetStream(value, uncertainstream)); 
    397396        TEST_THAT(reply->GetStartingValue() == value); 
    398397         
    … …  
    705704                        // Simple query 
    706705                        { 
    707                                 std::auto_ptr<TestProtocolClientSimpleReply> reply(protocol.QuerySimple(41)); 
     706                                std::auto_ptr<TestProtocolSimpleReply> reply(protocol.QuerySimple(41)); 
    708707                                TEST_THAT(reply->GetValuePlusOne() == 42); 
    709708                        } 
    710709                        { 
    711                                 std::auto_ptr<TestProtocolClientSimpleReply> reply(protocol.QuerySimple(809)); 
     710                                std::auto_ptr<TestProtocolSimpleReply> reply(protocol.QuerySimple(809)); 
    712711                                TEST_THAT(reply->GetValuePlusOne() == 810); 
    713712                        } 
    … …  
    725724                                s.Write(buf, sizeof(buf)); 
    726725                                s.SetForReading(); 
    727                                 std::auto_ptr<TestProtocolClientGetStream> reply(protocol.QuerySendStream(0x73654353298ffLL, s)); 
     726                                std::auto_ptr<TestProtocolGetStream> reply(protocol.QuerySendStream(0x73654353298ffLL, s)); 
    728727                                TEST_THAT(reply->GetStartingValue() == sizeof(buf)); 
    729728                        } 
    … …  
    732731                        for(int q = 0; q < 514; q++) 
    733732                        { 
    734                                 std::auto_ptr<TestProtocolClientSimpleReply> reply(protocol.QuerySimple(q)); 
     733                                std::auto_ptr<TestProtocolSimpleReply> reply(protocol.QuerySimple(q)); 
    735734                                TEST_THAT(reply->GetValuePlusOne() == (q+1)); 
    736735                        } 
    … …  
    741740                                strings.push_back(std::string("test2")); 
    742741                                strings.push_back(std::string("test3")); 
    743                                 std::auto_ptr<TestProtocolClientListsReply> reply(protocol.QueryLists(strings)); 
     742                                std::auto_ptr<TestProtocolListsReply> reply(protocol.QueryLists(strings)); 
    744743                                TEST_THAT(reply->GetNumberOfStrings() == 3); 
    745744                        } 
    … …  
    747746                        // And another 
    748747                        { 
    749                                 std::auto_ptr<TestProtocolClientHello> reply(protocol.QueryHello(41,87,11,std::string("pingu"))); 
     748                                std::auto_ptr<TestProtocolHello> reply(protocol.QueryHello(41,87,11,std::string("pingu"))); 
    750749                                TEST_THAT(reply->GetNumber32() == 12); 
    751750                                TEST_THAT(reply->GetNumber16() == 89); 

  • box/trunk/test/bbackupd/Makefile.extra

    r2973 r2983  
    99        ../../bin/bbstored/BBStoreDHousekeeping.o \ 
    1010        ../../bin/bbstored/HousekeepStoreAccount.o \ 
    11         ../../lib/backupstore/autogen_BackupProtocolServer.o \ 
     11        ../../lib/backupstore/autogen_BackupProtocol.o \ 
    1212        ../../lib/backupstore/BackupStoreContext.o \ 
    1313        ../../lib/backupstore/BackupCommands.o \ 

  • box/trunk/test/bbackupd/testbbackupd.cpp

    r2944 r2983  
    4343#endif 
    4444 
    45 #include "autogen_BackupProtocolServer.h" 
     45#include "autogen_BackupProtocol.h" 
    4646#include "BackupClientCryptoKeys.h" 
    4747#include "BackupClientFileAttributes.h" 
    … …  
    7474#include "Utils.h" 
    7575 
    76 #include "autogen_BackupProtocolClient.h" 
    7776#include "intercept.h" 
    7877#include "ServerControl.h" 
    … …  
    476475        protocol.QueryListDirectory( 
    477476                        InDirectory, 
    478                         BackupProtocolClientListDirectory::Flags_Dir, 
    479                         BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING, 
     477                        BackupProtocolListDirectory::Flags_Dir, 
     478                        BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING, 
    480479                        true /* want attributes */); 
    481480         
    … …  
    519518                        BackupProtocolClient protocol(conn); 
    520519                        protocol.QueryVersion(BACKUP_STORE_SERVER_VERSION); 
    521                         std::auto_ptr<BackupProtocolClientLoginConfirmed> 
     520                        std::auto_ptr<BackupProtocolLoginConfirmed> 
    522521                                loginConf(protocol.QueryLogin(0x01234567, 
    523                                         BackupProtocolClientLogin::Flags_ReadOnly)); 
     522                                        BackupProtocolLogin::Flags_ReadOnly)); 
    524523                         
    525524                        // Test the restoration 
    … …  
    605604        int64_t id = en->GetObjectID(); 
    606605        TEST_THAT(id > 0); 
    607         TEST_THAT(id != BackupProtocolClientListDirectory::RootDirectory); 
     606        TEST_THAT(id != BackupProtocolListDirectory::RootDirectory); 
    608607        return id; 
    609608} 
    … …  
    618617        connection.reset(new BackupProtocolClient(sSocket)); 
    619618        connection->Handshake(); 
    620         std::auto_ptr<BackupProtocolClientVersion>  
     619        std::auto_ptr<BackupProtocolVersion>  
    621620                serverVersion(connection->QueryVersion( 
    622621                        BACKUP_STORE_SERVER_VERSION)); 
    … …  
    641640( 
    642641        BackupProtocolClient& rClient, 
    643         int64_t id 
     642        int64_t id = BackupProtocolListDirectory::RootDirectory 
    644643) 
    645644{ 
    646         std::auto_ptr<BackupProtocolClientSuccess> dirreply( 
     645        std::auto_ptr<BackupProtocolSuccess> dirreply( 
    647646                rClient.QueryListDirectory(id, false, 0, false)); 
    648647        std::auto_ptr<IOStream> dirstream(rClient.ReceiveStream()); 
    … …  
    767766        else 
    768767        { 
    769                 BOX_INFO("readdir hook still active at " << time_now << ", " 
     768                BOX_TRACE("readdir hook still active at " << time_now << ", " 
    770769                        "waiting for " << readdir_stop_time); 
    771770        } 
    … …  
    781780                sizeof(readdir_test_dirent.d_name), 
    782781                "test.%d", readdir_test_counter); 
    783         BOX_INFO("readdir hook returning " << readdir_test_dirent.d_name); 
     782        BOX_TRACE("readdir hook returning " << readdir_test_dirent.d_name); 
    784783 
    785784        // ensure that when bbackupd stats the file, it gets the  
    … …  
    792791        intercept_setup_lstat_hook(stat_hook_filename, lstat_test_hook); 
    793792#endif 
     793 
     794        // sleep a bit to reduce the number of dirents returned 
     795        ::safe_sleep(1); 
    794796 
    795797        return &readdir_test_dirent; 
    … …  
    11311133                        TEST_LINE(comp2 != sub, line); 
    11321134                } 
     1135 
     1136                // Check that no read error has been reported yet 
     1137                TEST_THAT(!TestFileExists("testfiles/notifyran.read-error.1")); 
    11331138 
    11341139                if (failures > 0) 
    … …  
    13391344                                ConnectAndLogin(context, 0 /* read-write */); 
    13401345                 
    1341                         std::auto_ptr<BackupProtocolClientAccountUsage> usage( 
     1346                        std::auto_ptr<BackupProtocolAccountUsage> usage( 
    13421347                                client->QueryGetAccountUsage()); 
    13431348                        TEST_EQUAL_LINE(24, usage->GetBlocksUsed(), 
    … …  
    14221427                 
    14231428                        std::auto_ptr<BackupStoreDirectory> rootDir =  
    1424                                 ReadDirectory(*client, 
    1425                                 BackupProtocolClientListDirectory::RootDirectory); 
     1429                                ReadDirectory(*client); 
    14261430 
    14271431                        int64_t testDirId = SearchDir(*rootDir, "Test1"); 
    … …  
    14651469                        TEST_THAT(test_entry_deleted(*d4_dir, "f5")); 
    14661470 
    1467                         std::auto_ptr<BackupProtocolClientAccountUsage> usage( 
     1471                        std::auto_ptr<BackupProtocolAccountUsage> usage( 
    14681472                                client->QueryGetAccountUsage()); 
    14691473                        TEST_EQUAL_LINE(24, usage->GetBlocksUsed(), 
    … …  
    14991503                         
    15001504                        std::auto_ptr<BackupStoreDirectory> rootDir =  
    1501                                 ReadDirectory(*client, 
    1502                                 BackupProtocolClientListDirectory::RootDirectory); 
     1505                                ReadDirectory(*client); 
    15031506 
    15041507                        int64_t testDirId = SearchDir(*rootDir, "Test1"); 
    … …  
    15201523                        TEST_THAT(SearchDir(*spacetest_dir, "d7") == 0); 
    15211524 
    1522                         std::auto_ptr<BackupProtocolClientAccountUsage> usage( 
     1525                        std::auto_ptr<BackupProtocolAccountUsage> usage( 
    15231526                                client->QueryGetAccountUsage()); 
    15241527                        TEST_EQUAL_LINE(16, usage->GetBlocksUsed(), 
    … …  
    15751578                                ConnectAndLogin(context, 0 /* read-write */); 
    15761579 
    1577                         std::auto_ptr<BackupProtocolClientAccountUsage> usage( 
     1580                        std::auto_ptr<BackupProtocolAccountUsage> usage( 
    15781581                                client->QueryGetAccountUsage()); 
    15791582                        TEST_EQUAL_LINE(22, usage->GetBlocksUsed(), 
    … …  
    16861689                class MyHook : public BackupStoreContext::TestHook 
    16871690                { 
    1688                         virtual std::auto_ptr<ProtocolObject> StartCommand( 
    1689                                 BackupProtocolObject& rCommand) 
     1691                        virtual std::auto_ptr<BackupProtocolMessage> StartCommand( 
     1692                                const BackupProtocolMessage& rCommand) 
    16901693                        { 
    16911694                                if (rCommand.GetType() == 
    1692                                         BackupProtocolServerStoreFile::TypeID) 
     1695                                        BackupProtocolStoreFile::TypeID) 
    16931696                                { 
    16941697                                        // terminate badly 
    … …  
    16961699                                                Internal); 
    16971700                                } 
    1698                                 return std::auto_ptr<ProtocolObject>(); 
     1701                                return std::auto_ptr<BackupProtocolMessage>(); 
    16991702                        } 
    17001703                }; 
    … …  
    19601963                        std::auto_ptr<BackupProtocolClient> client = 
    19611964                                ConnectAndLogin(context, 
    1962                                 BackupProtocolClientLogin::Flags_ReadOnly); 
     1965                                BackupProtocolLogin::Flags_ReadOnly); 
    19631966                         
    19641967                        std::auto_ptr<BackupStoreDirectory> dir =  
    1965                                 ReadDirectory(*client, 
    1966                                 BackupProtocolClientListDirectory::RootDirectory); 
     1968                                ReadDirectory(*client); 
    19671969                        int64_t testDirId = SearchDir(*dir, "Test2"); 
    19681970                        TEST_THAT(testDirId != 0); 
    … …  
    19992001                        std::auto_ptr<BackupProtocolClient> client = 
    20002002                                ConnectAndLogin(context, 
    2001                                 BackupProtocolClientLogin::Flags_ReadOnly); 
     2003                                BackupProtocolLogin::Flags_ReadOnly); 
    20022004                         
    20032005                        std::auto_ptr<BackupStoreDirectory> dir =  
    2004                                 ReadDirectory(*client, 
    2005                                 BackupProtocolClientListDirectory::RootDirectory); 
     2006                                ReadDirectory(*client); 
    20062007                        int64_t testDirId = SearchDir(*dir, "Test2"); 
    20072008                        TEST_THAT(testDirId != 0); 
    … …  
    20182019                        std::auto_ptr<BackupProtocolClient> client = 
    20192020                                ConnectAndLogin(context, 
    2020                                 BackupProtocolClientLogin::Flags_ReadOnly); 
     2021                                BackupProtocolLogin::Flags_ReadOnly); 
    20212022                         
    20222023                        std::auto_ptr<BackupStoreDirectory> root_dir =  
    2023                                 ReadDirectory(*client, 
    2024                                 BackupProtocolClientListDirectory::RootDirectory); 
     2024                                ReadDirectory(*client); 
    20252025 
    20262026                        TEST_THAT(test_entry_deleted(*root_dir, "Test2")); 
    … …  
    22642264 
    22652265                        std::auto_ptr<BackupStoreDirectory> dir = ReadDirectory( 
    2266                                 *client,  
    2267                                 BackupProtocolClientListDirectory::RootDirectory); 
     2266                                *client); 
    22682267 
    22692268                        int64_t baseDirId = SearchDir(*dir, "Test1"); 
    … …  
    32583257                        std::auto_ptr<BackupProtocolClient> client =  
    32593258                                ConnectAndLogin(context, 
    3260                                 BackupProtocolClientLogin::Flags_ReadOnly); 
     3259                                BackupProtocolLogin::Flags_ReadOnly); 
    32613260                         
    32623261                        std::auto_ptr<BackupStoreDirectory> dir = ReadDirectory( 
    3263                                 *client, 
    3264                                 BackupProtocolClientListDirectory::RootDirectory); 
     3262                                *client); 
    32653263 
    32663264                        int64_t testDirId = SearchDir(*dir, "Test1"); 
    … …  
    34393437                        std::auto_ptr<BackupProtocolClient> client =  
    34403438                                ConnectAndLogin(context, 
    3441                                 BackupProtocolClientLogin::Flags_ReadOnly); 
     3439                                BackupProtocolLogin::Flags_ReadOnly); 
    34423440 
    34433441                        // Find the ID of the Test1 directory 
    34443442                        restoredirid = GetDirID(*client, "Test1",  
    3445                                 BackupProtocolClientListDirectory::RootDirectory); 
     3443                                BackupProtocolListDirectory::RootDirectory); 
    34463444                        TEST_THAT(restoredirid != 0); 
    34473445 
    … …  
    37463744                                        // because that's the default, and 
    37473745                                        // it should have changed 
    3748                                         std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(protocol->QueryLogin(0x01234567, 0)); 
     3746                                        std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(protocol->QueryLogin(0x01234567, 0)); 
    37493747                                        TEST_THAT(loginConf->GetClientStoreMarker() != 0); 
    37503748                                         
    … …  
    38243822                        std::auto_ptr<BackupProtocolClient> client =  
    38253823                                ConnectAndLogin(context, 
    3826                                 BackupProtocolClientLogin::Flags_ReadOnly); 
     3824                                BackupProtocolLogin::Flags_ReadOnly); 
    38273825 
    38283826                        // Check that the restore fn returns resume possible, 
Note: See TracChangeset for help on using the changeset viewer.