Home | History | Annotate | Download | only in syncable 
      1 // Copyright 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef SYNC_SYNCABLE_DIRECTORY_BACKING_STORE_H_
      6 #define SYNC_SYNCABLE_DIRECTORY_BACKING_STORE_H_
      7 
      8 #include <string>
      9 
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/threading/non_thread_safe.h"
     12 #include "sql/connection.h"
     13 #include "sql/statement.h"
     14 #include "sync/base/sync_export.h"
     15 #include "sync/internal_api/public/base/model_type.h"
     16 #include "sync/syncable/dir_open_result.h"
     17 #include "sync/syncable/directory.h"
     18 #include "sync/syncable/metahandle_set.h"
     19 
     20 namespace sync_pb {
     21 class EntitySpecifics;
     22 }
     23 
     24 namespace syncer {
     25 namespace syncable {
     26 
     27 SYNC_EXPORT_PRIVATE extern const int32 kCurrentDBVersion;
     28 
     29 struct ColumnSpec;
     30 
     31 // Interface that provides persistence for a syncable::Directory object. You can
     32 // load all the persisted data to prime a syncable::Directory on startup by
     33 // invoking Load.  The only other thing you (or more correctly, a Directory) can
     34 // do here is save any changes that have occurred since calling Load, which can
     35 // be done periodically as often as desired.
     36 //
     37 // The DirectoryBackingStore will own an sqlite lock on its database for most of
     38 // its lifetime.  You must not have two DirectoryBackingStore objects accessing
     39 // the database simultaneously.  Because the lock exists at the database level,
     40 // not even two separate browser instances would be able to acquire it
     41 // simultaneously.
     42 //
     43 // This class is abstract so that we can extend it in interesting ways for use
     44 // in tests.  The concrete class used in non-test scenarios is
     45 // OnDiskDirectoryBackingStore.
     46 class SYNC_EXPORT_PRIVATE DirectoryBackingStore : public base::NonThreadSafe {
     47  public:
     48   explicit DirectoryBackingStore(const std::string& dir_name);
     49   virtual ~DirectoryBackingStore();
     50 
     51   // Loads and drops all currently persisted meta entries into |handles_map|
     52   // and loads appropriate persisted kernel info into |info_bucket|.
     53   //
     54   // This function can perform some cleanup tasks behind the scenes.  It will
     55   // clean up unused entries from the database and migrate to the latest
     56   // database version.  The caller can safely ignore these details.
     57   //
     58   // NOTE: On success (return value of OPENED), the buckets are populated with
     59   // newly allocated items, meaning ownership is bestowed upon the caller.
     60   virtual DirOpenResult Load(Directory::MetahandlesMap* handles_map,
     61                              JournalIndex* delete_journals,
     62                              Directory::KernelLoadInfo* kernel_load_info) = 0;
     63 
     64   // Updates the on-disk store with the input |snapshot| as a database
     65   // transaction.  Does NOT open any syncable transactions as this would cause
     66   // opening transactions elsewhere to block on synchronous I/O.
     67   // DO NOT CALL THIS FROM MORE THAN ONE THREAD EVER.  Also, whichever thread
     68   // calls SaveChanges *must* be the thread that owns/destroys |this|.
     69   virtual bool SaveChanges(const Directory::SaveChangesSnapshot& snapshot);
     70 
     71  protected:
     72   // For test classes.
     73   DirectoryBackingStore(const std::string& dir_name,
     74                         sql::Connection* connection);
     75 
     76   // General Directory initialization and load helpers.
     77   bool InitializeTables();
     78   bool CreateTables();
     79 
     80   // Create 'share_info' or 'temp_share_info' depending on value of
     81   // is_temporary. Returns an sqlite
     82   bool CreateShareInfoTable(bool is_temporary);
     83 
     84   bool CreateShareInfoTableVersion71(bool is_temporary);
     85   // Create 'metas' or 'temp_metas' depending on value of is_temporary. Also
     86   // create a 'deleted_metas' table using same schema.
     87   bool CreateMetasTable(bool is_temporary);
     88   bool CreateModelsTable();
     89   bool CreateV71ModelsTable();
     90   bool CreateV75ModelsTable();
     91   bool CreateV81ModelsTable();
     92 
     93   // We don't need to load any synced and applied deleted entries, we can
     94   // in fact just purge them forever on startup.
     95   bool DropDeletedEntries();
     96   // Drops a table if it exists, harmless if the table did not already exist.
     97   bool SafeDropTable(const char* table_name);
     98 
     99   // Load helpers for entries and attributes.
    100   bool LoadEntries(Directory::MetahandlesMap* handles_map);
    101   bool LoadDeleteJournals(JournalIndex* delete_journals);
    102   bool LoadInfo(Directory::KernelLoadInfo* info);
    103 
    104   // Save/update helpers for entries.  Return false if sqlite commit fails.
    105   static bool SaveEntryToDB(sql::Statement* save_statement,
    106                             const EntryKernel& entry);
    107   bool SaveNewEntryToDB(const EntryKernel& entry);
    108   bool UpdateEntryToDB(const EntryKernel& entry);
    109 
    110   // Close save_dbhandle_.  Broken out for testing.
    111   void EndSave();
    112 
    113   enum EntryTable {
    114     METAS_TABLE,
    115     DELETE_JOURNAL_TABLE,
    116   };
    117   // Removes each entry whose metahandle is in |handles| from the table
    118   // specified by |from| table. Does synchronous I/O.  Returns false on error.
    119   bool DeleteEntries(EntryTable from, const MetahandleSet& handles);
    120 
    121   // Drop all tables in preparation for reinitialization.
    122   void DropAllTables();
    123 
    124   // Serialization helpers for ModelType.  These convert between
    125   // the ModelType enum and the values we persist in the database to identify
    126   // a model.  We persist a default instance of the specifics protobuf as the
    127   // ID, rather than the enum value.
    128   static ModelType ModelIdToModelTypeEnum(const void* data, int length);
    129   static std::string ModelTypeEnumToModelId(ModelType model_type);
    130 
    131   static std::string GenerateCacheGUID();
    132 
    133   // Runs an integrity check on the current database.  If the
    134   // integrity check fails, false is returned and error is populated
    135   // with an error message.
    136   bool CheckIntegrity(sqlite3* handle, std::string* error) const;
    137 
    138   // Checks that the references between sync nodes is consistent.
    139   static bool VerifyReferenceIntegrity(
    140       const Directory::MetahandlesMap* handles_map);
    141 
    142   // Migration utilities.
    143   bool RefreshColumns();
    144   bool SetVersion(int version);
    145   int GetVersion();
    146 
    147   bool MigrateToSpecifics(const char* old_columns,
    148                           const char* specifics_column,
    149                           void(*handler_function) (
    150                               sql::Statement* old_value_query,
    151                               int old_value_column,
    152                               sync_pb::EntitySpecifics* mutable_new_value));
    153 
    154   // Individual version migrations.
    155   bool MigrateVersion67To68();
    156   bool MigrateVersion68To69();
    157   bool MigrateVersion69To70();
    158   bool MigrateVersion70To71();
    159   bool MigrateVersion71To72();
    160   bool MigrateVersion72To73();
    161   bool MigrateVersion73To74();
    162   bool MigrateVersion74To75();
    163   bool MigrateVersion75To76();
    164   bool MigrateVersion76To77();
    165   bool MigrateVersion77To78();
    166   bool MigrateVersion78To79();
    167   bool MigrateVersion79To80();
    168   bool MigrateVersion80To81();
    169   bool MigrateVersion81To82();
    170   bool MigrateVersion82To83();
    171   bool MigrateVersion83To84();
    172   bool MigrateVersion84To85();
    173   bool MigrateVersion85To86();
    174   bool MigrateVersion86To87();
    175   bool MigrateVersion87To88();
    176 
    177   scoped_ptr<sql::Connection> db_;
    178   sql::Statement save_meta_statment_;
    179   sql::Statement save_delete_journal_statment_;
    180   std::string dir_name_;
    181 
    182   // Set to true if migration left some old columns around that need to be
    183   // discarded.
    184   bool needs_column_refresh_;
    185 
    186  private:
    187   // Prepares |save_statement| for saving entries in |table|.
    188   void PrepareSaveEntryStatement(EntryTable table,
    189                                  sql::Statement* save_statement);
    190 
    191   DISALLOW_COPY_AND_ASSIGN(DirectoryBackingStore);
    192 };
    193 
    194 }  // namespace syncable
    195 }  // namespace syncer
    196 
    197 #endif  // SYNC_SYNCABLE_DIRECTORY_BACKING_STORE_H_
    198