Sync with upstream @23860137.
Fix GCC -Wshadow warnings in LevelDB's public header files, reported by Dustin. Add in-memory Env implementation (helpers/memenv/*). This enables users to create LevelDB databases in-memory. Initialize ShardedLRUCache::last_id_ to zero. This fixes a Valgrind warning. (Also delete port/sha1_* which were removed upstream some time ago.)main
parent
7263023651
commit
213a68eb68
@ -0,0 +1,374 @@ |
|||||||
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
||||||
|
// Use of this source code is governed by a BSD-style license that can be
|
||||||
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
||||||
|
|
||||||
|
#include "helpers/memenv/memenv.h" |
||||||
|
|
||||||
|
#include "leveldb/env.h" |
||||||
|
#include "leveldb/status.h" |
||||||
|
#include "port/port.h" |
||||||
|
#include "util/mutexlock.h" |
||||||
|
#include <map> |
||||||
|
#include <string.h> |
||||||
|
#include <string> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
namespace leveldb { |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
class FileState { |
||||||
|
public: |
||||||
|
// FileStates are reference counted. The initial reference count is zero
|
||||||
|
// and the caller must call Ref() at least once.
|
||||||
|
FileState() : refs_(0), size_(0) {} |
||||||
|
|
||||||
|
// Increase the reference count.
|
||||||
|
void Ref() { |
||||||
|
MutexLock lock(&refs_mutex_); |
||||||
|
++refs_; |
||||||
|
} |
||||||
|
|
||||||
|
// Decrease the reference count. Delete if this is the last reference.
|
||||||
|
void Unref() { |
||||||
|
bool do_delete = false; |
||||||
|
|
||||||
|
{ |
||||||
|
MutexLock lock(&refs_mutex_); |
||||||
|
--refs_; |
||||||
|
assert(refs_ >= 0); |
||||||
|
if (refs_ <= 0) { |
||||||
|
do_delete = true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (do_delete) { |
||||||
|
delete this; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
uint64_t Size() const { return size_; } |
||||||
|
|
||||||
|
Status Read(uint64_t offset, size_t n, Slice* result, char* scratch) const { |
||||||
|
if (offset > size_) { |
||||||
|
return Status::IOError("Offset greater than file size."); |
||||||
|
} |
||||||
|
const uint64_t available = size_ - offset; |
||||||
|
if (n > available) { |
||||||
|
n = available; |
||||||
|
} |
||||||
|
if (n == 0) { |
||||||
|
*result = Slice(); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
size_t block = offset / kBlockSize; |
||||||
|
size_t block_offset = offset % kBlockSize; |
||||||
|
|
||||||
|
if (n <= kBlockSize - block_offset) { |
||||||
|
// The requested bytes are all in the first block.
|
||||||
|
*result = Slice(blocks_[block] + block_offset, n); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
size_t bytes_to_copy = n; |
||||||
|
char* dst = scratch; |
||||||
|
|
||||||
|
while (bytes_to_copy > 0) { |
||||||
|
size_t avail = kBlockSize - block_offset; |
||||||
|
if (avail > bytes_to_copy) { |
||||||
|
avail = bytes_to_copy; |
||||||
|
} |
||||||
|
memcpy(dst, blocks_[block] + block_offset, avail); |
||||||
|
|
||||||
|
bytes_to_copy -= avail; |
||||||
|
dst += avail; |
||||||
|
block++; |
||||||
|
block_offset = 0; |
||||||
|
} |
||||||
|
|
||||||
|
*result = Slice(scratch, n); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
Status Append(const Slice& data) { |
||||||
|
const char* src = data.data(); |
||||||
|
size_t src_len = data.size(); |
||||||
|
|
||||||
|
while (src_len > 0) { |
||||||
|
size_t avail; |
||||||
|
size_t offset = size_ % kBlockSize; |
||||||
|
|
||||||
|
if (offset != 0) { |
||||||
|
// There is some room in the last block.
|
||||||
|
avail = kBlockSize - offset; |
||||||
|
} else { |
||||||
|
// No room in the last block; push new one.
|
||||||
|
blocks_.push_back(new char[kBlockSize]); |
||||||
|
avail = kBlockSize; |
||||||
|
} |
||||||
|
|
||||||
|
if (avail > src_len) { |
||||||
|
avail = src_len; |
||||||
|
} |
||||||
|
memcpy(blocks_.back() + offset, src, avail); |
||||||
|
src_len -= avail; |
||||||
|
src += avail; |
||||||
|
size_ += avail; |
||||||
|
} |
||||||
|
|
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
// Private since only Unref() should be used to delete it.
|
||||||
|
~FileState() { |
||||||
|
for (std::vector<char*>::iterator i = blocks_.begin(); i != blocks_.end(); |
||||||
|
++i) { |
||||||
|
delete [] *i; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// No copying allowed.
|
||||||
|
FileState(const FileState&); |
||||||
|
void operator=(const FileState&); |
||||||
|
|
||||||
|
port::Mutex refs_mutex_; |
||||||
|
int refs_; // Protected by refs_mutex_;
|
||||||
|
|
||||||
|
// The following fields are not protected by any mutex. They are only mutable
|
||||||
|
// while the file is being written, and concurrent access is not allowed
|
||||||
|
// to writable files.
|
||||||
|
std::vector<char*> blocks_; |
||||||
|
uint64_t size_; |
||||||
|
|
||||||
|
enum { kBlockSize = 8 * 1024 }; |
||||||
|
}; |
||||||
|
|
||||||
|
class SequentialFileImpl : public SequentialFile { |
||||||
|
public: |
||||||
|
explicit SequentialFileImpl(FileState* file) : file_(file), pos_(0) { |
||||||
|
file_->Ref(); |
||||||
|
} |
||||||
|
|
||||||
|
~SequentialFileImpl() { |
||||||
|
file_->Unref(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status Read(size_t n, Slice* result, char* scratch) { |
||||||
|
Status s = file_->Read(pos_, n, result, scratch); |
||||||
|
if (s.ok()) { |
||||||
|
pos_ += result->size(); |
||||||
|
} |
||||||
|
return s; |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status Skip(uint64_t n) { |
||||||
|
if (pos_ > file_->Size()) { |
||||||
|
return Status::IOError("pos_ > file_->Size()"); |
||||||
|
} |
||||||
|
const size_t available = file_->Size() - pos_; |
||||||
|
if (n > available) { |
||||||
|
n = available; |
||||||
|
} |
||||||
|
pos_ += n; |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
FileState* file_; |
||||||
|
size_t pos_; |
||||||
|
}; |
||||||
|
|
||||||
|
class RandomAccessFileImpl : public RandomAccessFile { |
||||||
|
public: |
||||||
|
explicit RandomAccessFileImpl(FileState* file) : file_(file) { |
||||||
|
file_->Ref(); |
||||||
|
} |
||||||
|
|
||||||
|
~RandomAccessFileImpl() { |
||||||
|
file_->Unref(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status Read(uint64_t offset, size_t n, Slice* result, |
||||||
|
char* scratch) const { |
||||||
|
return file_->Read(offset, n, result, scratch); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
FileState* file_; |
||||||
|
}; |
||||||
|
|
||||||
|
class WritableFileImpl : public WritableFile { |
||||||
|
public: |
||||||
|
WritableFileImpl(FileState* file) : file_(file) { |
||||||
|
file_->Ref(); |
||||||
|
} |
||||||
|
|
||||||
|
~WritableFileImpl() { |
||||||
|
file_->Unref(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status Append(const Slice& data) { |
||||||
|
return file_->Append(data); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status Close() { return Status::OK(); } |
||||||
|
virtual Status Flush() { return Status::OK(); } |
||||||
|
virtual Status Sync() { return Status::OK(); } |
||||||
|
|
||||||
|
private: |
||||||
|
FileState* file_; |
||||||
|
}; |
||||||
|
|
||||||
|
class InMemoryEnv : public EnvWrapper { |
||||||
|
public: |
||||||
|
explicit InMemoryEnv(Env* base_env) : EnvWrapper(base_env) { } |
||||||
|
|
||||||
|
virtual ~InMemoryEnv() { |
||||||
|
for (FileSystem::iterator i = file_map_.begin(); i != file_map_.end(); ++i){ |
||||||
|
i->second->Unref(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Partial implementation of the Env interface.
|
||||||
|
virtual Status NewSequentialFile(const std::string& fname, |
||||||
|
SequentialFile** result) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
if (file_map_.find(fname) == file_map_.end()) { |
||||||
|
*result = NULL; |
||||||
|
return Status::IOError(fname, "File not found"); |
||||||
|
} |
||||||
|
|
||||||
|
*result = new SequentialFileImpl(file_map_[fname]); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status NewRandomAccessFile(const std::string& fname, |
||||||
|
RandomAccessFile** result) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
if (file_map_.find(fname) == file_map_.end()) { |
||||||
|
*result = NULL; |
||||||
|
return Status::IOError(fname, "File not found"); |
||||||
|
} |
||||||
|
|
||||||
|
*result = new RandomAccessFileImpl(file_map_[fname]); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status NewWritableFile(const std::string& fname, |
||||||
|
WritableFile** result) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
if (file_map_.find(fname) != file_map_.end()) { |
||||||
|
DeleteFileInternal(fname); |
||||||
|
} |
||||||
|
|
||||||
|
FileState* file = new FileState(); |
||||||
|
file->Ref(); |
||||||
|
file_map_[fname] = file; |
||||||
|
|
||||||
|
*result = new WritableFileImpl(file); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual bool FileExists(const std::string& fname) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
return file_map_.find(fname) != file_map_.end(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status GetChildren(const std::string& dir, |
||||||
|
std::vector<std::string>* result) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
result->clear(); |
||||||
|
|
||||||
|
for (FileSystem::iterator i = file_map_.begin(); i != file_map_.end(); ++i){ |
||||||
|
const std::string& filename = i->first; |
||||||
|
|
||||||
|
if (filename.size() >= dir.size() + 1 && filename[dir.size()] == '/' && |
||||||
|
Slice(filename).starts_with(Slice(dir))) { |
||||||
|
result->push_back(filename.substr(dir.size() + 1)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
void DeleteFileInternal(const std::string& fname) { |
||||||
|
if (file_map_.find(fname) == file_map_.end()) { |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
file_map_[fname]->Unref(); |
||||||
|
file_map_.erase(fname); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status DeleteFile(const std::string& fname) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
if (file_map_.find(fname) == file_map_.end()) { |
||||||
|
return Status::IOError(fname, "File not found"); |
||||||
|
} |
||||||
|
|
||||||
|
DeleteFileInternal(fname); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status CreateDir(const std::string& dirname) { |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status DeleteDir(const std::string& dirname) { |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status GetFileSize(const std::string& fname, uint64_t* file_size) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
if (file_map_.find(fname) == file_map_.end()) { |
||||||
|
return Status::IOError(fname, "File not found"); |
||||||
|
} |
||||||
|
|
||||||
|
*file_size = file_map_[fname]->Size(); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status RenameFile(const std::string& src, |
||||||
|
const std::string& target) { |
||||||
|
MutexLock lock(&mutex_); |
||||||
|
if (file_map_.find(src) == file_map_.end()) { |
||||||
|
return Status::IOError(src, "File not found"); |
||||||
|
} |
||||||
|
|
||||||
|
DeleteFileInternal(target); |
||||||
|
file_map_[target] = file_map_[src]; |
||||||
|
file_map_.erase(src); |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status LockFile(const std::string& fname, FileLock** lock) { |
||||||
|
*lock = new FileLock; |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status UnlockFile(FileLock* lock) { |
||||||
|
delete lock; |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
virtual Status GetTestDirectory(std::string* path) { |
||||||
|
*path = "/test"; |
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
// Map from filenames to FileState objects, representing a simple file system.
|
||||||
|
typedef std::map<std::string, FileState*> FileSystem; |
||||||
|
port::Mutex mutex_; |
||||||
|
FileSystem file_map_; // Protected by mutex_.
|
||||||
|
}; |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
Env* NewMemEnv(Env* base_env) { |
||||||
|
return new InMemoryEnv(base_env); |
||||||
|
} |
||||||
|
|
||||||
|
} |
@ -0,0 +1,20 @@ |
|||||||
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
||||||
|
// Use of this source code is governed by a BSD-style license that can be
|
||||||
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
||||||
|
|
||||||
|
#ifndef STORAGE_LEVELDB_HELPERS_MEMENV_MEMENV_H_ |
||||||
|
#define STORAGE_LEVELDB_HELPERS_MEMENV_MEMENV_H_ |
||||||
|
|
||||||
|
namespace leveldb { |
||||||
|
|
||||||
|
class Env; |
||||||
|
|
||||||
|
// Returns a new environment that stores its data in memory and delegates
|
||||||
|
// all non-file-storage tasks to base_env. The caller must delete the result
|
||||||
|
// when it is no longer needed.
|
||||||
|
// *base_env must remain live while the result is in use.
|
||||||
|
Env* NewMemEnv(Env* base_env); |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
#endif // STORAGE_LEVELDB_HELPERS_MEMENV_MEMENV_H_
|
@ -0,0 +1,232 @@ |
|||||||
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
||||||
|
// Use of this source code is governed by a BSD-style license that can be
|
||||||
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
||||||
|
|
||||||
|
#include "helpers/memenv/memenv.h" |
||||||
|
|
||||||
|
#include "db/db_impl.h" |
||||||
|
#include "leveldb/db.h" |
||||||
|
#include "leveldb/env.h" |
||||||
|
#include "util/testharness.h" |
||||||
|
#include <string> |
||||||
|
#include <vector> |
||||||
|
|
||||||
|
namespace leveldb { |
||||||
|
|
||||||
|
class MemEnvTest { |
||||||
|
public: |
||||||
|
Env* env_; |
||||||
|
|
||||||
|
MemEnvTest() |
||||||
|
: env_(NewMemEnv(Env::Default())) { |
||||||
|
} |
||||||
|
~MemEnvTest() { |
||||||
|
delete env_; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
TEST(MemEnvTest, Basics) { |
||||||
|
size_t file_size; |
||||||
|
WritableFile* writable_file; |
||||||
|
std::vector<std::string> children; |
||||||
|
|
||||||
|
ASSERT_OK(env_->CreateDir("/dir")); |
||||||
|
|
||||||
|
// Check that the directory is empty.
|
||||||
|
ASSERT_TRUE(!env_->FileExists("/dir/non_existent")); |
||||||
|
ASSERT_TRUE(!env_->GetFileSize("/dir/non_existent", &file_size).ok()); |
||||||
|
ASSERT_OK(env_->GetChildren("/dir", &children)); |
||||||
|
ASSERT_EQ(0, children.size()); |
||||||
|
|
||||||
|
// Create a file.
|
||||||
|
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file)); |
||||||
|
delete writable_file; |
||||||
|
|
||||||
|
// Check that the file exists.
|
||||||
|
ASSERT_TRUE(env_->FileExists("/dir/f")); |
||||||
|
ASSERT_OK(env_->GetFileSize("/dir/f", &file_size)); |
||||||
|
ASSERT_EQ(0, file_size); |
||||||
|
ASSERT_OK(env_->GetChildren("/dir", &children)); |
||||||
|
ASSERT_EQ(1, children.size()); |
||||||
|
ASSERT_EQ("f", children[0]); |
||||||
|
|
||||||
|
// Write to the file.
|
||||||
|
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file)); |
||||||
|
ASSERT_OK(writable_file->Append("abc")); |
||||||
|
delete writable_file; |
||||||
|
|
||||||
|
// Check for expected size.
|
||||||
|
ASSERT_OK(env_->GetFileSize("/dir/f", &file_size)); |
||||||
|
ASSERT_EQ(3, file_size); |
||||||
|
|
||||||
|
// Check that renaming works.
|
||||||
|
ASSERT_TRUE(!env_->RenameFile("/dir/non_existent", "/dir/g").ok()); |
||||||
|
ASSERT_OK(env_->RenameFile("/dir/f", "/dir/g")); |
||||||
|
ASSERT_TRUE(!env_->FileExists("/dir/f")); |
||||||
|
ASSERT_TRUE(env_->FileExists("/dir/g")); |
||||||
|
ASSERT_OK(env_->GetFileSize("/dir/g", &file_size)); |
||||||
|
ASSERT_EQ(3, file_size); |
||||||
|
|
||||||
|
// Check that opening non-existent file fails.
|
||||||
|
SequentialFile* seq_file; |
||||||
|
RandomAccessFile* rand_file; |
||||||
|
ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file).ok()); |
||||||
|
ASSERT_TRUE(!seq_file); |
||||||
|
ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file).ok()); |
||||||
|
ASSERT_TRUE(!rand_file); |
||||||
|
|
||||||
|
// Check that deleting works.
|
||||||
|
ASSERT_TRUE(!env_->DeleteFile("/dir/non_existent").ok()); |
||||||
|
ASSERT_OK(env_->DeleteFile("/dir/g")); |
||||||
|
ASSERT_TRUE(!env_->FileExists("/dir/g")); |
||||||
|
ASSERT_OK(env_->GetChildren("/dir", &children)); |
||||||
|
ASSERT_EQ(0, children.size()); |
||||||
|
ASSERT_OK(env_->DeleteDir("/dir")); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(MemEnvTest, ReadWrite) { |
||||||
|
WritableFile* writable_file; |
||||||
|
SequentialFile* seq_file; |
||||||
|
RandomAccessFile* rand_file; |
||||||
|
Slice result; |
||||||
|
char scratch[100]; |
||||||
|
|
||||||
|
ASSERT_OK(env_->CreateDir("/dir")); |
||||||
|
|
||||||
|
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file)); |
||||||
|
ASSERT_OK(writable_file->Append("hello ")); |
||||||
|
ASSERT_OK(writable_file->Append("world")); |
||||||
|
delete writable_file; |
||||||
|
|
||||||
|
// Read sequentially.
|
||||||
|
ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file)); |
||||||
|
ASSERT_OK(seq_file->Read(5, &result, scratch)); // Read "hello".
|
||||||
|
ASSERT_EQ(0, result.compare("hello")); |
||||||
|
ASSERT_OK(seq_file->Skip(1)); |
||||||
|
ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Read "world".
|
||||||
|
ASSERT_EQ(0, result.compare("world")); |
||||||
|
ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Try reading past EOF.
|
||||||
|
ASSERT_EQ(0, result.size()); |
||||||
|
ASSERT_OK(seq_file->Skip(100)); // Try to skip past end of file.
|
||||||
|
ASSERT_OK(seq_file->Read(1000, &result, scratch)); |
||||||
|
ASSERT_EQ(0, result.size()); |
||||||
|
delete seq_file; |
||||||
|
|
||||||
|
// Random reads.
|
||||||
|
ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file)); |
||||||
|
ASSERT_OK(rand_file->Read(6, 5, &result, scratch)); // Read "world".
|
||||||
|
ASSERT_EQ(0, result.compare("world")); |
||||||
|
ASSERT_OK(rand_file->Read(0, 5, &result, scratch)); // Read "hello".
|
||||||
|
ASSERT_EQ(0, result.compare("hello")); |
||||||
|
ASSERT_OK(rand_file->Read(10, 100, &result, scratch)); // Read "d".
|
||||||
|
ASSERT_EQ(0, result.compare("d")); |
||||||
|
|
||||||
|
// Too high offset.
|
||||||
|
ASSERT_TRUE(!rand_file->Read(1000, 5, &result, scratch).ok()); |
||||||
|
delete rand_file; |
||||||
|
} |
||||||
|
|
||||||
|
TEST(MemEnvTest, Locks) { |
||||||
|
FileLock* lock; |
||||||
|
|
||||||
|
// These are no-ops, but we test they return success.
|
||||||
|
ASSERT_OK(env_->LockFile("some file", &lock)); |
||||||
|
ASSERT_OK(env_->UnlockFile(lock)); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(MemEnvTest, Misc) { |
||||||
|
std::string test_dir; |
||||||
|
ASSERT_OK(env_->GetTestDirectory(&test_dir)); |
||||||
|
ASSERT_TRUE(!test_dir.empty()); |
||||||
|
|
||||||
|
WritableFile* writable_file; |
||||||
|
ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file)); |
||||||
|
|
||||||
|
// These are no-ops, but we test they return success.
|
||||||
|
ASSERT_OK(writable_file->Sync()); |
||||||
|
ASSERT_OK(writable_file->Flush()); |
||||||
|
ASSERT_OK(writable_file->Close()); |
||||||
|
delete writable_file; |
||||||
|
} |
||||||
|
|
||||||
|
TEST(MemEnvTest, LargeWrite) { |
||||||
|
const size_t kWriteSize = 300 * 1024; |
||||||
|
char* scratch = new char[kWriteSize * 2]; |
||||||
|
|
||||||
|
std::string write_data; |
||||||
|
for (size_t i = 0; i < kWriteSize; ++i) { |
||||||
|
write_data.append(1, static_cast<char>(i)); |
||||||
|
} |
||||||
|
|
||||||
|
WritableFile* writable_file; |
||||||
|
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file)); |
||||||
|
ASSERT_OK(writable_file->Append("foo")); |
||||||
|
ASSERT_OK(writable_file->Append(write_data)); |
||||||
|
delete writable_file; |
||||||
|
|
||||||
|
SequentialFile* seq_file; |
||||||
|
Slice result; |
||||||
|
ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file)); |
||||||
|
ASSERT_OK(seq_file->Read(3, &result, scratch)); // Read "foo".
|
||||||
|
ASSERT_EQ(0, result.compare("foo")); |
||||||
|
|
||||||
|
size_t read = 0; |
||||||
|
std::string read_data; |
||||||
|
while (read < kWriteSize) { |
||||||
|
ASSERT_OK(seq_file->Read(kWriteSize - read, &result, scratch)); |
||||||
|
read_data.append(result.data(), result.size()); |
||||||
|
read += result.size(); |
||||||
|
} |
||||||
|
ASSERT_TRUE(write_data == read_data); |
||||||
|
delete seq_file; |
||||||
|
delete [] scratch; |
||||||
|
} |
||||||
|
|
||||||
|
TEST(MemEnvTest, DBTest) { |
||||||
|
Options options; |
||||||
|
options.create_if_missing = true; |
||||||
|
options.env = env_; |
||||||
|
DB* db; |
||||||
|
|
||||||
|
const Slice keys[] = {Slice("aaa"), Slice("bbb"), Slice("ccc")}; |
||||||
|
const Slice vals[] = {Slice("foo"), Slice("bar"), Slice("baz")}; |
||||||
|
|
||||||
|
ASSERT_OK(DB::Open(options, "/dir/db", &db)); |
||||||
|
for (size_t i = 0; i < 3; ++i) { |
||||||
|
ASSERT_OK(db->Put(WriteOptions(), keys[i], vals[i])); |
||||||
|
} |
||||||
|
|
||||||
|
for (size_t i = 0; i < 3; ++i) { |
||||||
|
std::string res; |
||||||
|
ASSERT_OK(db->Get(ReadOptions(), keys[i], &res)); |
||||||
|
ASSERT_TRUE(res == vals[i]); |
||||||
|
} |
||||||
|
|
||||||
|
Iterator* iterator = db->NewIterator(ReadOptions()); |
||||||
|
iterator->SeekToFirst(); |
||||||
|
for (size_t i = 0; i < 3; ++i) { |
||||||
|
ASSERT_TRUE(iterator->Valid()); |
||||||
|
ASSERT_TRUE(keys[i] == iterator->key()); |
||||||
|
ASSERT_TRUE(vals[i] == iterator->value()); |
||||||
|
iterator->Next(); |
||||||
|
} |
||||||
|
ASSERT_TRUE(!iterator->Valid()); |
||||||
|
delete iterator; |
||||||
|
|
||||||
|
DBImpl* dbi = reinterpret_cast<DBImpl*>(db); |
||||||
|
ASSERT_OK(dbi->TEST_CompactMemTable()); |
||||||
|
|
||||||
|
for (size_t i = 0; i < 3; ++i) { |
||||||
|
std::string res; |
||||||
|
ASSERT_OK(db->Get(ReadOptions(), keys[i], &res)); |
||||||
|
ASSERT_TRUE(res == vals[i]); |
||||||
|
} |
||||||
|
|
||||||
|
delete db; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
int main(int argc, char** argv) { |
||||||
|
return leveldb::test::RunAllTests(); |
||||||
|
} |
@ -1,298 +0,0 @@ |
|||||||
// Portions copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style license that can be
|
|
||||||
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
||||||
//
|
|
||||||
// This module provides a slow but portable implementation of
|
|
||||||
// the SHA1 hash function.
|
|
||||||
//
|
|
||||||
// It is adapted from free code written by Paul E. Jones
|
|
||||||
// <paulej@packetizer.com>. See http://www.packetizer.com/security/sha1/
|
|
||||||
//
|
|
||||||
// The license for the original code is:
|
|
||||||
/*
|
|
||||||
Copyright (C) 1998, 2009 |
|
||||||
Paul E. Jones <paulej@packetizer.com> |
|
||||||
|
|
||||||
Freeware Public License (FPL) |
|
||||||
|
|
||||||
This software is licensed as "freeware." Permission to distribute |
|
||||||
this software in source and binary forms, including incorporation |
|
||||||
into other products, is hereby granted without a fee. THIS SOFTWARE |
|
||||||
IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESSED OR IMPLIED WARRANTIES, |
|
||||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY |
|
||||||
AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHOR SHALL NOT BE HELD |
|
||||||
LIABLE FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE, EITHER |
|
||||||
DIRECTLY OR INDIRECTLY, INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA |
|
||||||
OR DATA BEING RENDERED INACCURATE. |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "port/sha1_portable.h" |
|
||||||
#include <stdio.h> |
|
||||||
#include <stdlib.h> |
|
||||||
#include <stdint.h> |
|
||||||
|
|
||||||
namespace leveldb { |
|
||||||
namespace port { |
|
||||||
|
|
||||||
/*
|
|
||||||
* Description: |
|
||||||
* This class implements the Secure Hashing Standard as defined |
|
||||||
* in FIPS PUB 180-1 published April 17, 1995. |
|
||||||
*/ |
|
||||||
|
|
||||||
/*
|
|
||||||
* This structure will hold context information for the hashing |
|
||||||
* operation |
|
||||||
*/ |
|
||||||
typedef struct SHA1Context { |
|
||||||
unsigned Message_Digest[5]; /* Message Digest (output) */ |
|
||||||
|
|
||||||
unsigned Length_Low; /* Message length in bits */ |
|
||||||
unsigned Length_High; /* Message length in bits */ |
|
||||||
|
|
||||||
unsigned char Message_Block[64]; /* 512-bit message blocks */ |
|
||||||
int Message_Block_Index; /* Index into message block array */ |
|
||||||
|
|
||||||
bool Computed; /* Is the digest computed? */ |
|
||||||
bool Corrupted; /* Is the message digest corruped? */ |
|
||||||
} SHA1Context; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Portability Issues: |
|
||||||
* SHA-1 is defined in terms of 32-bit "words". This code was |
|
||||||
* written with the expectation that the processor has at least |
|
||||||
* a 32-bit machine word size. If the machine word size is larger, |
|
||||||
* the code should still function properly. One caveat to that |
|
||||||
* is that the input functions taking characters and character |
|
||||||
* arrays assume that only 8 bits of information are stored in each |
|
||||||
* character. |
|
||||||
*/ |
|
||||||
|
|
||||||
/*
|
|
||||||
* Define the circular shift macro |
|
||||||
*/ |
|
||||||
#define SHA1CircularShift(bits,word) \ |
|
||||||
((((word) << (bits)) & 0xFFFFFFFF) | \
|
|
||||||
((word) >> (32-(bits)))) |
|
||||||
|
|
||||||
/* Function prototypes */ |
|
||||||
static void SHA1ProcessMessageBlock(SHA1Context *); |
|
||||||
static void SHA1PadMessage(SHA1Context *); |
|
||||||
|
|
||||||
// Initialize the SHA1Context in preparation for computing a new
|
|
||||||
// message digest.
|
|
||||||
static void SHA1Reset(SHA1Context* context) { |
|
||||||
context->Length_Low = 0; |
|
||||||
context->Length_High = 0; |
|
||||||
context->Message_Block_Index = 0; |
|
||||||
|
|
||||||
context->Message_Digest[0] = 0x67452301; |
|
||||||
context->Message_Digest[1] = 0xEFCDAB89; |
|
||||||
context->Message_Digest[2] = 0x98BADCFE; |
|
||||||
context->Message_Digest[3] = 0x10325476; |
|
||||||
context->Message_Digest[4] = 0xC3D2E1F0; |
|
||||||
|
|
||||||
context->Computed = false; |
|
||||||
context->Corrupted = false; |
|
||||||
} |
|
||||||
|
|
||||||
// This function will return the 160-bit message digest into the
|
|
||||||
// Message_Digest array within the SHA1Context provided
|
|
||||||
static bool SHA1Result(SHA1Context *context) { |
|
||||||
if (context->Corrupted) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
if (!context->Computed) { |
|
||||||
SHA1PadMessage(context); |
|
||||||
context->Computed = true; |
|
||||||
} |
|
||||||
return true; |
|
||||||
} |
|
||||||
|
|
||||||
// This function accepts an array of bytes as the next portion of
|
|
||||||
// the message.
|
|
||||||
static void SHA1Input(SHA1Context *context, |
|
||||||
const unsigned char *message_array, |
|
||||||
unsigned length) { |
|
||||||
if (!length) return; |
|
||||||
|
|
||||||
if (context->Computed || context->Corrupted) { |
|
||||||
context->Corrupted = true; |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
while(length-- && !context->Corrupted) { |
|
||||||
context->Message_Block[context->Message_Block_Index++] = |
|
||||||
(*message_array & 0xFF); |
|
||||||
|
|
||||||
context->Length_Low += 8; |
|
||||||
/* Force it to 32 bits */ |
|
||||||
context->Length_Low &= 0xFFFFFFFF; |
|
||||||
if (context->Length_Low == 0) { |
|
||||||
context->Length_High++; |
|
||||||
/* Force it to 32 bits */ |
|
||||||
context->Length_High &= 0xFFFFFFFF; |
|
||||||
if (context->Length_High == 0) |
|
||||||
{ |
|
||||||
/* Message is too long */ |
|
||||||
context->Corrupted = true; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if (context->Message_Block_Index == 64) |
|
||||||
{ |
|
||||||
SHA1ProcessMessageBlock(context); |
|
||||||
} |
|
||||||
|
|
||||||
message_array++; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// This function will process the next 512 bits of the message stored
|
|
||||||
// in the Message_Block array.
|
|
||||||
static void SHA1ProcessMessageBlock(SHA1Context *context) { |
|
||||||
const unsigned K[] = // Constants defined in SHA-1
|
|
||||||
{ |
|
||||||
0x5A827999, |
|
||||||
0x6ED9EBA1, |
|
||||||
0x8F1BBCDC, |
|
||||||
0xCA62C1D6 |
|
||||||
}; |
|
||||||
int t; // Loop counter
|
|
||||||
unsigned temp; // Temporary word value
|
|
||||||
unsigned W[80]; // Word sequence
|
|
||||||
unsigned A, B, C, D, E; // Word buffers
|
|
||||||
|
|
||||||
// Initialize the first 16 words in the array W
|
|
||||||
for(t = 0; t < 16; t++) { |
|
||||||
W[t] = ((unsigned) context->Message_Block[t * 4]) << 24; |
|
||||||
W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16; |
|
||||||
W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8; |
|
||||||
W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]); |
|
||||||
} |
|
||||||
|
|
||||||
for(t = 16; t < 80; t++) { |
|
||||||
W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); |
|
||||||
} |
|
||||||
|
|
||||||
A = context->Message_Digest[0]; |
|
||||||
B = context->Message_Digest[1]; |
|
||||||
C = context->Message_Digest[2]; |
|
||||||
D = context->Message_Digest[3]; |
|
||||||
E = context->Message_Digest[4]; |
|
||||||
|
|
||||||
for(t = 0; t < 20; t++) { |
|
||||||
temp = SHA1CircularShift(5,A) + |
|
||||||
((B & C) | ((~B) & D)) + E + W[t] + K[0]; |
|
||||||
temp &= 0xFFFFFFFF; |
|
||||||
E = D; |
|
||||||
D = C; |
|
||||||
C = SHA1CircularShift(30,B); |
|
||||||
B = A; |
|
||||||
A = temp; |
|
||||||
} |
|
||||||
|
|
||||||
for(t = 20; t < 40; t++) { |
|
||||||
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]; |
|
||||||
temp &= 0xFFFFFFFF; |
|
||||||
E = D; |
|
||||||
D = C; |
|
||||||
C = SHA1CircularShift(30,B); |
|
||||||
B = A; |
|
||||||
A = temp; |
|
||||||
} |
|
||||||
|
|
||||||
for(t = 40; t < 60; t++) { |
|
||||||
temp = SHA1CircularShift(5,A) + |
|
||||||
((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]; |
|
||||||
temp &= 0xFFFFFFFF; |
|
||||||
E = D; |
|
||||||
D = C; |
|
||||||
C = SHA1CircularShift(30,B); |
|
||||||
B = A; |
|
||||||
A = temp; |
|
||||||
} |
|
||||||
|
|
||||||
for(t = 60; t < 80; t++) { |
|
||||||
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3]; |
|
||||||
temp &= 0xFFFFFFFF; |
|
||||||
E = D; |
|
||||||
D = C; |
|
||||||
C = SHA1CircularShift(30,B); |
|
||||||
B = A; |
|
||||||
A = temp; |
|
||||||
} |
|
||||||
|
|
||||||
context->Message_Digest[0] = (context->Message_Digest[0] + A) & 0xFFFFFFFF; |
|
||||||
context->Message_Digest[1] = (context->Message_Digest[1] + B) & 0xFFFFFFFF; |
|
||||||
context->Message_Digest[2] = (context->Message_Digest[2] + C) & 0xFFFFFFFF; |
|
||||||
context->Message_Digest[3] = (context->Message_Digest[3] + D) & 0xFFFFFFFF; |
|
||||||
context->Message_Digest[4] = (context->Message_Digest[4] + E) & 0xFFFFFFFF; |
|
||||||
|
|
||||||
context->Message_Block_Index = 0; |
|
||||||
} |
|
||||||
|
|
||||||
// According to the standard, the message must be padded to an even
|
|
||||||
// 512 bits. The first padding bit must be a '1'. The last 64 bits
|
|
||||||
// represent the length of the original message. All bits in between
|
|
||||||
// should be 0. This function will pad the message according to those
|
|
||||||
// rules by filling the Message_Block array accordingly. It will also
|
|
||||||
// call SHA1ProcessMessageBlock() appropriately. When it returns, it
|
|
||||||
// can be assumed that the message digest has been computed.
|
|
||||||
static void SHA1PadMessage(SHA1Context *context) { |
|
||||||
// Check to see if the current message block is too small to hold
|
|
||||||
// the initial padding bits and length. If so, we will pad the
|
|
||||||
// block, process it, and then continue padding into a second block.
|
|
||||||
if (context->Message_Block_Index > 55) { |
|
||||||
context->Message_Block[context->Message_Block_Index++] = 0x80; |
|
||||||
while(context->Message_Block_Index < 64) { |
|
||||||
context->Message_Block[context->Message_Block_Index++] = 0; |
|
||||||
} |
|
||||||
|
|
||||||
SHA1ProcessMessageBlock(context); |
|
||||||
|
|
||||||
while(context->Message_Block_Index < 56) { |
|
||||||
context->Message_Block[context->Message_Block_Index++] = 0; |
|
||||||
} |
|
||||||
} else { |
|
||||||
context->Message_Block[context->Message_Block_Index++] = 0x80; |
|
||||||
while(context->Message_Block_Index < 56) { |
|
||||||
context->Message_Block[context->Message_Block_Index++] = 0; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Store the message length as the last 8 octets
|
|
||||||
context->Message_Block[56] = (context->Length_High >> 24) & 0xFF; |
|
||||||
context->Message_Block[57] = (context->Length_High >> 16) & 0xFF; |
|
||||||
context->Message_Block[58] = (context->Length_High >> 8) & 0xFF; |
|
||||||
context->Message_Block[59] = (context->Length_High) & 0xFF; |
|
||||||
context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF; |
|
||||||
context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF; |
|
||||||
context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF; |
|
||||||
context->Message_Block[63] = (context->Length_Low) & 0xFF; |
|
||||||
|
|
||||||
SHA1ProcessMessageBlock(context); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
void SHA1_Hash_Portable(const char* data, size_t len, char* hash_array) { |
|
||||||
SHA1Context context; |
|
||||||
SHA1Reset(&context); |
|
||||||
SHA1Input(&context, reinterpret_cast<const unsigned char*>(data), len); |
|
||||||
bool ok = SHA1Result(&context); |
|
||||||
if (!ok) { |
|
||||||
fprintf(stderr, "Unexpected error in SHA1_Hash_Portable code\n"); |
|
||||||
exit(1); |
|
||||||
} |
|
||||||
for (int i = 0; i < 5; i++) { |
|
||||||
uint32_t value = context.Message_Digest[i]; |
|
||||||
hash_array[i*4 + 0] = (value >> 24) & 0xff; |
|
||||||
hash_array[i*4 + 1] = (value >> 16) & 0xff; |
|
||||||
hash_array[i*4 + 2] = (value >> 8) & 0xff; |
|
||||||
hash_array[i*4 + 3] = value & 0xff; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
@ -1,25 +0,0 @@ |
|||||||
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style license that can be
|
|
||||||
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
||||||
|
|
||||||
#ifndef STORAGE_LEVELDB_PORT_SHA1_PORTABLE_H_ |
|
||||||
#define STORAGE_LEVELDB_PORT_SHA1_PORTABLE_H_ |
|
||||||
|
|
||||||
#include <stddef.h> |
|
||||||
|
|
||||||
namespace leveldb { |
|
||||||
namespace port { |
|
||||||
|
|
||||||
// Compute the SHA1 hash value of "data[0..len-1]" and store it in
|
|
||||||
// "hash_array[0..19]". hash_array must have 20 bytes of space available.
|
|
||||||
//
|
|
||||||
// This function is portable but may not be as fast as a version
|
|
||||||
// optimized for your platform. It is provided as a default method
|
|
||||||
// that can be used when porting leveldb to a new platform if no
|
|
||||||
// better SHA1 hash implementation is available.
|
|
||||||
void SHA1_Hash_Portable(const char* data, size_t len, char* hash_array); |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#endif // STORAGE_LEVELDB_PORT_SHA1_PORTABLE_H_
|
|
@ -1,39 +0,0 @@ |
|||||||
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a BSD-style license that can be
|
|
||||||
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
||||||
|
|
||||||
#include "port/port.h" |
|
||||||
#include "util/testharness.h" |
|
||||||
|
|
||||||
namespace leveldb { |
|
||||||
namespace port { |
|
||||||
|
|
||||||
class SHA1 { }; |
|
||||||
|
|
||||||
static std::string TestSHA1(const char* data, size_t len) { |
|
||||||
char hash_val[20]; |
|
||||||
SHA1_Hash(data, len, hash_val); |
|
||||||
char buf[41]; |
|
||||||
for (int i = 0; i < 20; i++) { |
|
||||||
snprintf(buf + i * 2, 41 - i * 2, |
|
||||||
"%02x", |
|
||||||
static_cast<unsigned int>(static_cast<unsigned char>( |
|
||||||
hash_val[i]))); |
|
||||||
} |
|
||||||
return std::string(buf, 40); |
|
||||||
} |
|
||||||
|
|
||||||
TEST(SHA1, Simple) { |
|
||||||
ASSERT_EQ("da39a3ee5e6b4b0d3255bfef95601890afd80709", TestSHA1("", 0)); |
|
||||||
ASSERT_EQ("aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d", TestSHA1("hello", 5)); |
|
||||||
std::string x(10000, 'x'); |
|
||||||
ASSERT_EQ("f8c5cde791c5056cf515881e701c8a9ecb439a75", |
|
||||||
TestSHA1(x.data(), x.size())); |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
int main(int argc, char** argv) { |
|
||||||
return leveldb::test::RunAllTests(); |
|
||||||
} |
|
Loading…
Reference in new issue