blob: fde1ffce112e31cb1922f40225aac700234073d7 [file] [log] [blame]
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <iostream>
#include <memory>
#include "base/at_exit.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "net/base/io_buffer.h"
#include "net/base/test_completion_callback.h"
#include "net/disk_cache/disk_cache.h"
#include "net/http/http_cache.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_util.h"
using disk_cache::Backend;
using disk_cache::Entry;
namespace {
int kResponseInfoIndex = 0;
// Get the cache's size.
bool GetSize(Backend* cache_backend) {
net::TestCompletionCallback cb;
int rv = cache_backend->CalculateSizeOfAllEntries(cb.callback());
rv = cb.GetResult(rv);
if (rv < 0) {
std::cerr << "Couldn't get cache size." << std::endl;
return false;
}
std::cout << rv << std::endl;
return true;
}
// Print all of a cache's keys to stdout.
bool ListKeys(Backend* cache_backend) {
std::unique_ptr<Backend::Iterator> entry_iterator =
cache_backend->CreateIterator();
Entry* entry = nullptr;
net::TestCompletionCallback cb;
int rv = entry_iterator->OpenNextEntry(&entry, cb.callback());
while (cb.GetResult(rv) == net::OK) {
std::string url = entry->GetKey();
std::cout << url << std::endl;
entry->Close();
entry = nullptr;
rv = entry_iterator->OpenNextEntry(&entry, cb.callback());
}
return true;
}
// Get a key's stream to a buffer.
scoped_refptr<net::GrowableIOBuffer> GetStreamForKeyBuffer(
Backend* cache_backend,
const std::string& key,
int index) {
Entry* cache_entry;
net::TestCompletionCallback cb;
int rv = cache_backend->OpenEntry(key, &cache_entry, cb.callback());
if (cb.GetResult(rv) != net::OK) {
std::cerr << "Couldn't find key's entry." << std::endl;
return nullptr;
}
const int kInitBufferSize = 8192;
scoped_refptr<net::GrowableIOBuffer> buffer(new net::GrowableIOBuffer());
buffer->SetCapacity(kInitBufferSize);
while (true) {
rv = cache_entry->ReadData(index, buffer->offset(), buffer.get(),
buffer->capacity() - buffer->offset(),
cb.callback());
rv = cb.GetResult(rv);
if (rv < 0) {
cache_entry->Close();
std::cerr << "Stream read error." << std::endl;
return nullptr;
}
buffer->set_offset(buffer->offset() + rv);
if (rv == 0)
break;
buffer->SetCapacity(buffer->offset() * 2);
}
cache_entry->Close();
return buffer;
}
// Print a key's stream to stdout.
bool GetStreamForKey(Backend* cache_backend,
const std::string& key,
int index) {
scoped_refptr<net::GrowableIOBuffer> buffer(
GetStreamForKeyBuffer(cache_backend, key, index));
if (!buffer)
return false;
if (index == kResponseInfoIndex) {
net::HttpResponseInfo response_info;
bool truncated_response_info = false;
net::HttpCache::ParseResponseInfo(buffer->StartOfBuffer(), buffer->offset(),
&response_info, &truncated_response_info);
if (truncated_response_info) {
std::cerr << "Truncated HTTP response." << std::endl;
return false;
}
std::cout << net::HttpUtil::ConvertHeadersBackToHTTPResponse(
response_info.headers->raw_headers());
} else {
std::cout.write(buffer->StartOfBuffer(), buffer->offset());
}
return true;
}
// Set stdin as the key's raw response headers.
bool UpdateRawResponseHeaders(Backend* cache_backend, const std::string& key) {
scoped_refptr<net::GrowableIOBuffer> buffer(
GetStreamForKeyBuffer(cache_backend, key, kResponseInfoIndex));
if (!buffer)
return false;
net::HttpResponseInfo response_info;
bool truncated_response_info = false;
net::HttpCache::ParseResponseInfo(buffer->StartOfBuffer(), buffer->offset(),
&response_info, &truncated_response_info);
if (truncated_response_info) {
std::cerr << "Truncated HTTP response." << std::endl;
return false;
}
std::ostringstream raw_headers_stream;
for (std::string line; std::getline(std::cin, line);)
raw_headers_stream << line << std::endl;
response_info.headers =
new net::HttpResponseHeaders(raw_headers_stream.str());
scoped_refptr<net::PickledIOBuffer> data(new net::PickledIOBuffer());
response_info.Persist(data->pickle(), false, false);
data->Done();
Entry* cache_entry;
net::TestCompletionCallback cb;
int rv = cache_backend->OpenEntry(key, &cache_entry, cb.callback());
CHECK(cb.GetResult(rv) == net::OK);
int data_len = data->pickle()->size();
rv = cache_entry->WriteData(kResponseInfoIndex, 0, data.get(), data_len,
cb.callback(), true);
if (cb.GetResult(rv) != data_len) {
std::cerr << "Couldn't write headers." << std::endl;
return false;
}
cache_entry->Close();
return true;
}
// Delete a specified key stream from the cache.
bool DeleteStreamForKey(Backend* cache_backend,
const std::string& key,
int index) {
Entry* cache_entry;
net::TestCompletionCallback cb;
int rv = cache_backend->OpenEntry(key, &cache_entry, cb.callback());
if (cb.GetResult(rv) != net::OK) {
std::cerr << "Couldn't find key's entry." << std::endl;
return false;
}
scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer(""));
rv = cache_entry->WriteData(index, 0, buffer.get(), 0, cb.callback(), true);
if (cb.GetResult(rv) != 0) {
std::cerr << "Couldn't delete key stream." << std::endl;
return false;
}
cache_entry->Close();
return true;
}
// Delete a specified key from the cache.
bool DeleteKey(Backend* cache_backend, const std::string& key) {
net::TestCompletionCallback cb;
int rv = cache_backend->DoomEntry(key, cb.callback());
if (cb.GetResult(rv) != net::OK) {
std::cerr << "Couldn't delete key." << std::endl;
return false;
}
return true;
}
// Parse stream index from command line argument string.
int ParseStreamIndex(const std::string& index_arg) {
int index = -1;
if (!base::StringToInt(index_arg, &index)) {
std::cerr << "<index> must be an integer." << std::endl;
return -1;
} else if (index < 0 || index > 2) {
std::cerr << "Invalid stream index." << std::endl;
return -1;
}
return index;
}
// Print the command line help.
void PrintHelp() {
std::cout << "cachetool <cache_path> <cache_backend_type> <subcommand> ..."
<< std::endl
<< std::endl;
std::cout << "Available cache backend types: simple, blockfile" << std::endl;
std::cout << "Available subcommands:" << std::endl;
std::cout << " delete_key <key>: Delete key from cache." << std::endl;
std::cout << " delete_stream <key> <index>: Delete a particular stream of a"
<< " given key." << std::endl;
std::cout << " get_size: Calculate the total size of the cache in bytes."
<< std::endl;
std::cout << " get_stream <key> <index>: Print a particular stream for a"
<< " given key." << std::endl;
std::cout << " list_keys: List all keys in the cache." << std::endl;
std::cout << " update_raw_headers <key>: Update stdin as the key's raw "
<< "response headers." << std::endl;
std::cout << " validate: Verify that the cache can be opened and return, "
<< "confirming the cache exists and is of the right type."
<< std::endl;
std::cout << "Expected values of <index> are:" << std::endl;
std::cout << " 0 (HTTP response headers)" << std::endl;
std::cout << " 1 (transport encoded content)" << std::endl;
std::cout << " 2 (compiled content)" << std::endl;
}
} // namespace
int main(int argc, char* argv[]) {
base::AtExitManager at_exit_manager;
base::MessageLoopForIO message_loop;
base::CommandLine::Init(argc, argv);
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
base::CommandLine::StringVector args = command_line.GetArgs();
if (args.size() < 3U) {
PrintHelp();
return 1;
}
base::FilePath cache_path(args[0]);
std::string cache_backend_type(args[1]);
std::string subcommand(args[2]);
net::BackendType backend_type;
if (cache_backend_type == "simple") {
backend_type = net::CACHE_BACKEND_SIMPLE;
} else if (cache_backend_type == "blockfile") {
backend_type = net::CACHE_BACKEND_BLOCKFILE;
} else {
std::cerr << "Unknown cache type." << std::endl;
PrintHelp();
return 1;
}
std::unique_ptr<Backend> cache_backend;
net::TestCompletionCallback cb;
int rv = disk_cache::CreateCacheBackend(
net::DISK_CACHE, backend_type, cache_path, INT_MAX, false,
message_loop.task_runner(), nullptr, &cache_backend, cb.callback());
if (cb.GetResult(rv) != net::OK) {
std::cerr << "Invalid cache." << std::endl;
return 1;
}
bool successful_command;
if (subcommand == "delete_key" && args.size() == 4) {
successful_command = DeleteKey(cache_backend.get(), args[3]);
} else if (subcommand == "delete_stream" && args.size() == 5) {
int index = ParseStreamIndex(args[4]);
if (index < 0)
return 1;
successful_command =
DeleteStreamForKey(cache_backend.get(), args[3], index);
} else if (subcommand == "get_size" && args.size() == 3) {
successful_command = GetSize(cache_backend.get());
} else if (subcommand == "get_stream" && args.size() == 5) {
int index = ParseStreamIndex(args[4]);
if (index < 0)
return 1;
successful_command = GetStreamForKey(cache_backend.get(), args[3], index);
} else if (subcommand == "list_keys" && args.size() == 3) {
successful_command = ListKeys(cache_backend.get());
} else if (subcommand == "update_raw_headers" && args.size() == 4) {
successful_command = UpdateRawResponseHeaders(cache_backend.get(), args[3]);
} else if (subcommand == "validate" && args.size() == 3) {
successful_command = true;
} else {
successful_command = false;
PrintHelp();
}
base::RunLoop().RunUntilIdle();
cache_backend = nullptr;
base::RunLoop().RunUntilIdle();
return !successful_command;
}