src/sql/test_vfs.cc - cobalt - Git at Google

 // Copyright 2016 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // Adapted from cobalt/storage.

 #include "sql/test_vfs.h"

 #include <string.h>

 #include <algorithm>
 #include <map>

 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "third_party/sqlite/sqlite3.h"

 namespace sql {

 namespace {

 // A "subclass" of sqlite3_file with our required data structures added.
 struct virtual_file {
   sqlite3_file sql_internal_file;
   std::string* data;
   base::Lock* lock;
   int current_lock;
   int shared;
 };

 // A very simple in-memory virtual file system.
 class TestVfs {
  public:
   typedef std::map<std::string, std::string> FileMap;

  public:
   TestVfs() {}
   ~TestVfs() {}

   void Register();
   void Unregister();

   std::string* Open(const char* path) {
     return &file_map_[path];
   }

   void Delete(const char* path) {
     file_map_.erase(path);
   }

  private:
   sqlite3_vfs vfs_;
   FileMap file_map_;
 };

 base::LazyInstance<TestVfs>::DestructorAtExit g_vfs = LAZY_INSTANCE_INITIALIZER;

 int VfsClose(sqlite3_file* file) {
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   delete vfile->lock;
   return SQLITE_OK;
 }

 int VfsRead(sqlite3_file* file, void* out, int bytes, sqlite_int64 offset) {
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   base::AutoLock lock(*vfile->lock);
   if (offset >= static_cast<sqlite_int64>(vfile->data->length())) {
     return SQLITE_OK;
   }

   size_t available =
       std::max(static_cast<sqlite_int64>(vfile->data->length()) - offset,
                static_cast<sqlite_int64>(0));
   size_t to_read = std::min(available, static_cast<size_t>(bytes));
   if (to_read == 0) {
     return SQLITE_OK;
   }

   memcpy(out, &(vfile->data->c_str()[offset]), to_read);
   return SQLITE_OK;
 }

 int VfsWrite(sqlite3_file* file,
              const void* data,
              int bytes,
              sqlite3_int64 offset) {
   size_t max = offset + bytes;

   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   base::AutoLock lock(*vfile->lock);
   if (vfile->data->length() < max) {
     vfile->data->resize(max);
   }

   vfile->data->replace(offset, bytes, reinterpret_cast<const char*>(data),
                        bytes);

   return SQLITE_OK;
 }

 int VfsSync(sqlite3_file* pFile, int flags) {
   return SQLITE_OK;
 }

 int VfsFileControl(sqlite3_file* pFile, int op, void* pArg) {
   return SQLITE_OK;
 }

 int VfsSectorSize(sqlite3_file* file) {
   // The number of bytes that can be read without disturbing other bytes in the
   // file.
   return 1;
 }

 int VfsLock(sqlite3_file* file, const int mode) {
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   base::AutoLock lock(*vfile->lock);

   // If there is already a lock of this type or more restrictive, do nothing
   if (vfile->current_lock >= mode) {
     return SQLITE_OK;
   }

   if (mode == SQLITE_LOCK_SHARED) {
     DCHECK_EQ(vfile->current_lock, SQLITE_LOCK_NONE);
     vfile->shared++;
     vfile->current_lock = SQLITE_LOCK_SHARED;
   }

   if (mode == SQLITE_LOCK_RESERVED) {
     DCHECK_EQ(vfile->current_lock, SQLITE_LOCK_SHARED);
     vfile->current_lock = SQLITE_LOCK_RESERVED;
   }

   if (mode == SQLITE_LOCK_EXCLUSIVE) {
     if (vfile->current_lock >= SQLITE_LOCK_PENDING) {
       return SQLITE_BUSY;
     }
     vfile->current_lock = SQLITE_LOCK_PENDING;
     if (vfile->shared > 1) {
       // There are some outstanding shared locks (greater than one because the
       // pending lock is an "upgraded" shared lock)
       return SQLITE_BUSY;
     }
     // Acquire the exclusive lock
     vfile->current_lock = SQLITE_LOCK_EXCLUSIVE;
   }

   return SQLITE_OK;
 }

 int VfsUnlock(sqlite3_file* file, int mode) {
   DCHECK_LE(mode, SQLITE_LOCK_SHARED);
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   base::AutoLock lock(*vfile->lock);

 #ifdef STARBOARD
 #undef COMPILE_ASSERT
 #define COMPILE_ASSERT static_assert
 #define sqlite_lock_constants_order_has_changed \
   "sqlite lock constants order has changed!"
 #endif
   COMPILE_ASSERT(SQLITE_LOCK_NONE < SQLITE_LOCK_SHARED,
                  sqlite_lock_constants_order_has_changed);
   COMPILE_ASSERT(SQLITE_LOCK_SHARED < SQLITE_LOCK_RESERVED,
                  sqlite_lock_constants_order_has_changed);
   COMPILE_ASSERT(SQLITE_LOCK_RESERVED < SQLITE_LOCK_PENDING,
                  sqlite_lock_constants_order_has_changed);
   COMPILE_ASSERT(SQLITE_LOCK_PENDING < SQLITE_LOCK_EXCLUSIVE,
                  sqlite_lock_constants_order_has_changed);

   if (mode == SQLITE_LOCK_NONE && vfile->current_lock >= SQLITE_LOCK_SHARED) {
     vfile->shared--;
   }

   vfile->current_lock = mode;
   return SQLITE_OK;
 }

 int VfsCheckReservedLock(sqlite3_file* file, int* result) {
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   base::AutoLock lock(*vfile->lock);

   // The function expects a result is 1 if the lock is reserved, pending, or
   // exclusive; 0 otherwise.
   *result = vfile->current_lock >= SQLITE_LOCK_RESERVED ? 1 : 0;
   return SQLITE_OK;
 }

 int VfsFileSize(sqlite3_file* file, sqlite3_int64* out_size) {
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   *out_size = vfile->data->length();
   return SQLITE_OK;
 }

 int VfsTruncate(sqlite3_file* file, sqlite3_int64 size) {
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   base::AutoLock lock(*vfile->lock);
   vfile->data->resize(size);
   return SQLITE_OK;
 }

 int VfsDeviceCharacteristics(sqlite3_file* file) {
   return 0;
 }

 const sqlite3_io_methods s_cobalt_vfs_io = {
     1,                        // Structure version number
     VfsClose,                 // xClose
     VfsRead,                  // xRead
     VfsWrite,                 // xWrite
     VfsTruncate,              // xTruncate
     VfsSync,                  // xSync
     VfsFileSize,              // xFileSize
     VfsLock,                  // xLock
     VfsUnlock,                // xUnlock
     VfsCheckReservedLock,     // xCheckReservedLock
     VfsFileControl,           // xFileControl
     VfsSectorSize,            // xSectorSize
     VfsDeviceCharacteristics  // xDeviceCharacteristics
 };

 int VfsOpen(sqlite3_vfs* sql_vfs,
             const char* path,
             sqlite3_file* file,
             int flags,
             int* out_flags) {
   DCHECK(path) << "NULL filename not supported.";
   virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
   vfile->lock = new base::Lock;
   TestVfs* vfs = reinterpret_cast<TestVfs*>(sql_vfs->pAppData);
   vfile->data = vfs->Open(path);
   file->pMethods = &s_cobalt_vfs_io;
   return SQLITE_OK;
 }

 int VfsDelete(sqlite3_vfs* sql_vfs, const char* path, int sync_dir) {
   TestVfs* vfs = reinterpret_cast<TestVfs*>(sql_vfs->pAppData);
   vfs->Delete(path);
   return SQLITE_OK;
 }

 int VfsFullPathname(sqlite3_vfs* sql_vfs,
                     const char* path,
                     int out_size,
                     char* out_path) {
   size_t path_size = static_cast<size_t>(out_size);
   if (base::strlcpy(out_path, path, path_size) < path_size) {
     return SQLITE_OK;
   }
   return SQLITE_ERROR;
 }

 int VfsAccess(sqlite3_vfs* sql_vfs, const char* name, int flags, int* result) {
   // We should always have a valid, readable/writable file.
   *result |= SQLITE_ACCESS_EXISTS | SQLITE_ACCESS_READWRITE;
   return SQLITE_OK;
 }

 int VfsRandomness(sqlite3_vfs* sql_vfs, int bytes, char* out) {
   base::RandBytes(out, static_cast<size_t>(bytes));
   return SQLITE_OK;
 }

 void TestVfs::Register() {
   memset(&vfs_, 0, sizeof(vfs_));
   vfs_.iVersion = 1;
   vfs_.szOsFile = sizeof(virtual_file);
   vfs_.mxPathname = 512;
   vfs_.pNext = NULL;
   vfs_.zName = "test_vfs";
   vfs_.pAppData = this;
   vfs_.xOpen = VfsOpen;
   vfs_.xDelete = VfsDelete;
   vfs_.xAccess = VfsAccess;
   vfs_.xFullPathname = VfsFullPathname;
   vfs_.xRandomness = VfsRandomness;

   // Ensure we are not registering multiple of these with the same name.
   // Behavior is undefined in that case.
   DCHECK(sqlite3_vfs_find(vfs_.zName) == NULL);

   int ret = sqlite3_vfs_register(&vfs_, 1 /* make_default */);
   DCHECK_EQ(ret, SQLITE_OK);
 }

 void TestVfs::Unregister() {
   int ret = sqlite3_vfs_unregister(&vfs_);
   file_map_.clear();
   DCHECK_EQ(ret, SQLITE_OK);
 }

 }  // namespace

 void RegisterTestVfs() {
   g_vfs.Get().Register();
 }

 void UnregisterTestVfs() {
   g_vfs.Get().Unregister();
 }

 }  // namespace sql
	// Copyright 2016 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// Adapted from cobalt/storage.

	#include "sql/test_vfs.h"

	#include <string.h>

	#include <algorithm>
	#include <map>

	#include "base/compiler_specific.h"
	#include "base/lazy_instance.h"
	#include "base/logging.h"
	#include "base/rand_util.h"
	#include "base/strings/string_util.h"
	#include "base/synchronization/lock.h"
	#include "third_party/sqlite/sqlite3.h"

	namespace sql {

	namespace {

	// A "subclass" of sqlite3_file with our required data structures added.
	struct virtual_file {
	sqlite3_file sql_internal_file;
	std::string* data;
	base::Lock* lock;
	int current_lock;
	int shared;
	};

	// A very simple in-memory virtual file system.
	class TestVfs {
	public:
	typedef std::map<std::string, std::string> FileMap;

	public:
	TestVfs() {}
	~TestVfs() {}

	void Register();
	void Unregister();

	std::string* Open(const char* path) {
	return &file_map_[path];
	}

	void Delete(const char* path) {
	file_map_.erase(path);
	}

	private:
	sqlite3_vfs vfs_;
	FileMap file_map_;
	};

	base::LazyInstance<TestVfs>::DestructorAtExit g_vfs = LAZY_INSTANCE_INITIALIZER;

	int VfsClose(sqlite3_file* file) {
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	delete vfile->lock;
	return SQLITE_OK;
	}

	int VfsRead(sqlite3_file* file, void* out, int bytes, sqlite_int64 offset) {
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	base::AutoLock lock(*vfile->lock);
	if (offset >= static_cast<sqlite_int64>(vfile->data->length())) {
	return SQLITE_OK;
	}

	size_t available =
	std::max(static_cast<sqlite_int64>(vfile->data->length()) - offset,
	static_cast<sqlite_int64>(0));
	size_t to_read = std::min(available, static_cast<size_t>(bytes));
	if (to_read == 0) {
	return SQLITE_OK;
	}

	memcpy(out, &(vfile->data->c_str()[offset]), to_read);
	return SQLITE_OK;
	}

	int VfsWrite(sqlite3_file* file,
	const void* data,
	int bytes,
	sqlite3_int64 offset) {
	size_t max = offset + bytes;

	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	base::AutoLock lock(*vfile->lock);
	if (vfile->data->length() < max) {
	vfile->data->resize(max);
	}

	vfile->data->replace(offset, bytes, reinterpret_cast<const char*>(data),
	bytes);

	return SQLITE_OK;
	}

	int VfsSync(sqlite3_file* pFile, int flags) {
	return SQLITE_OK;
	}

	int VfsFileControl(sqlite3_file* pFile, int op, void* pArg) {
	return SQLITE_OK;
	}

	int VfsSectorSize(sqlite3_file* file) {
	// The number of bytes that can be read without disturbing other bytes in the
	// file.
	return 1;
	}

	int VfsLock(sqlite3_file* file, const int mode) {
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	base::AutoLock lock(*vfile->lock);

	// If there is already a lock of this type or more restrictive, do nothing
	if (vfile->current_lock >= mode) {
	return SQLITE_OK;
	}

	if (mode == SQLITE_LOCK_SHARED) {
	DCHECK_EQ(vfile->current_lock, SQLITE_LOCK_NONE);
	vfile->shared++;
	vfile->current_lock = SQLITE_LOCK_SHARED;
	}

	if (mode == SQLITE_LOCK_RESERVED) {
	DCHECK_EQ(vfile->current_lock, SQLITE_LOCK_SHARED);
	vfile->current_lock = SQLITE_LOCK_RESERVED;
	}

	if (mode == SQLITE_LOCK_EXCLUSIVE) {
	if (vfile->current_lock >= SQLITE_LOCK_PENDING) {
	return SQLITE_BUSY;
	}
	vfile->current_lock = SQLITE_LOCK_PENDING;
	if (vfile->shared > 1) {
	// There are some outstanding shared locks (greater than one because the
	// pending lock is an "upgraded" shared lock)
	return SQLITE_BUSY;
	}
	// Acquire the exclusive lock
	vfile->current_lock = SQLITE_LOCK_EXCLUSIVE;
	}

	return SQLITE_OK;
	}

	int VfsUnlock(sqlite3_file* file, int mode) {
	DCHECK_LE(mode, SQLITE_LOCK_SHARED);
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	base::AutoLock lock(*vfile->lock);

	#ifdef STARBOARD
	#undef COMPILE_ASSERT
	#define COMPILE_ASSERT static_assert
	#define sqlite_lock_constants_order_has_changed \
	"sqlite lock constants order has changed!"
	#endif
	COMPILE_ASSERT(SQLITE_LOCK_NONE < SQLITE_LOCK_SHARED,
	sqlite_lock_constants_order_has_changed);
	COMPILE_ASSERT(SQLITE_LOCK_SHARED < SQLITE_LOCK_RESERVED,
	sqlite_lock_constants_order_has_changed);
	COMPILE_ASSERT(SQLITE_LOCK_RESERVED < SQLITE_LOCK_PENDING,
	sqlite_lock_constants_order_has_changed);
	COMPILE_ASSERT(SQLITE_LOCK_PENDING < SQLITE_LOCK_EXCLUSIVE,
	sqlite_lock_constants_order_has_changed);

	if (mode == SQLITE_LOCK_NONE && vfile->current_lock >= SQLITE_LOCK_SHARED) {
	vfile->shared--;
	}

	vfile->current_lock = mode;
	return SQLITE_OK;
	}

	int VfsCheckReservedLock(sqlite3_file* file, int* result) {
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	base::AutoLock lock(*vfile->lock);

	// The function expects a result is 1 if the lock is reserved, pending, or
	// exclusive; 0 otherwise.
	*result = vfile->current_lock >= SQLITE_LOCK_RESERVED ? 1 : 0;
	return SQLITE_OK;
	}

	int VfsFileSize(sqlite3_file* file, sqlite3_int64* out_size) {
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	*out_size = vfile->data->length();
	return SQLITE_OK;
	}

	int VfsTruncate(sqlite3_file* file, sqlite3_int64 size) {
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	base::AutoLock lock(*vfile->lock);
	vfile->data->resize(size);
	return SQLITE_OK;
	}

	int VfsDeviceCharacteristics(sqlite3_file* file) {
	return 0;
	}

	const sqlite3_io_methods s_cobalt_vfs_io = {
	1, // Structure version number
	VfsClose, // xClose
	VfsRead, // xRead
	VfsWrite, // xWrite
	VfsTruncate, // xTruncate
	VfsSync, // xSync
	VfsFileSize, // xFileSize
	VfsLock, // xLock
	VfsUnlock, // xUnlock
	VfsCheckReservedLock, // xCheckReservedLock
	VfsFileControl, // xFileControl
	VfsSectorSize, // xSectorSize
	VfsDeviceCharacteristics // xDeviceCharacteristics
	};

	int VfsOpen(sqlite3_vfs* sql_vfs,
	const char* path,
	sqlite3_file* file,
	int flags,
	int* out_flags) {
	DCHECK(path) << "NULL filename not supported.";
	virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
	vfile->lock = new base::Lock;
	TestVfs* vfs = reinterpret_cast<TestVfs*>(sql_vfs->pAppData);
	vfile->data = vfs->Open(path);
	file->pMethods = &s_cobalt_vfs_io;
	return SQLITE_OK;
	}

	int VfsDelete(sqlite3_vfs* sql_vfs, const char* path, int sync_dir) {
	TestVfs* vfs = reinterpret_cast<TestVfs*>(sql_vfs->pAppData);
	vfs->Delete(path);
	return SQLITE_OK;
	}

	int VfsFullPathname(sqlite3_vfs* sql_vfs,
	const char* path,
	int out_size,
	char* out_path) {
	size_t path_size = static_cast<size_t>(out_size);
	if (base::strlcpy(out_path, path, path_size) < path_size) {
	return SQLITE_OK;
	}
	return SQLITE_ERROR;
	}

	int VfsAccess(sqlite3_vfs* sql_vfs, const char* name, int flags, int* result) {
	// We should always have a valid, readable/writable file.
	*result \|= SQLITE_ACCESS_EXISTS \| SQLITE_ACCESS_READWRITE;
	return SQLITE_OK;
	}

	int VfsRandomness(sqlite3_vfs* sql_vfs, int bytes, char* out) {
	base::RandBytes(out, static_cast<size_t>(bytes));
	return SQLITE_OK;
	}

	void TestVfs::Register() {
	memset(&vfs_, 0, sizeof(vfs_));
	vfs_.iVersion = 1;
	vfs_.szOsFile = sizeof(virtual_file);
	vfs_.mxPathname = 512;
	vfs_.pNext = NULL;
	vfs_.zName = "test_vfs";
	vfs_.pAppData = this;
	vfs_.xOpen = VfsOpen;
	vfs_.xDelete = VfsDelete;
	vfs_.xAccess = VfsAccess;
	vfs_.xFullPathname = VfsFullPathname;
	vfs_.xRandomness = VfsRandomness;

	// Ensure we are not registering multiple of these with the same name.
	// Behavior is undefined in that case.
	DCHECK(sqlite3_vfs_find(vfs_.zName) == NULL);

	int ret = sqlite3_vfs_register(&vfs_, 1 /* make_default */);
	DCHECK_EQ(ret, SQLITE_OK);
	}

	void TestVfs::Unregister() {
	int ret = sqlite3_vfs_unregister(&vfs_);
	file_map_.clear();
	DCHECK_EQ(ret, SQLITE_OK);
	}

	} // namespace

	void RegisterTestVfs() {
	g_vfs.Get().Register();
	}

	void UnregisterTestVfs() {
	g_vfs.Get().Unregister();
	}

	} // namespace sql