cafs::link cafs::import( const fc::path& p ) {
if( !fc::exists(p) ) {
FC_THROW_MSG( "Path does not exist %s", p.string() );
}
if( fc::is_regular_file( p ) ) {
if( fc::file_size(p) > IMBED_THRESHOLD ) {
auto file_head = import_file(p);
fc::vector<char> data(MAX_CHUNK_SIZE);
fc::datastream<char*> ds(data.data()+1, data.size()-1);
fc::raw::pack( ds, file_head );
data[0] = cafs::file_header_type;
//fc::datastream<const char*> ds2(data.data()+1, data.size()-1);
//file_header tmp;
//fc::raw::unpack( ds2, tmp );
//slog( "test unpack %s", fc::json::to_string( tmp ).c_str() );
data.resize( ds.tellp() );
//slog( "pre randomized... '%s'", fc::to_hex( data.data(), 16 ).c_str() );
size_t seed = randomize(data, *((uint64_t*)fc::sha1::hash(data.data(),data.size()).data()) );
auto chunk_head = slice_chunk( data );
//slog( "slice chunk %s", fc::json::to_string( chunk_head ).c_str() );
store_chunk( chunk_head, data );
return link( chunk_head.calculate_id(), seed );
} else { // no header, just raw data from the file stored in the chunk
fc::vector<char> data( fc::file_size(p)+1 );
data[0] = file_data_type;
fc::ifstream ifile( p.string(), fc::ifstream::binary );
ifile.read( data.data()+1, data.size()-1 );
size_t seed = randomize(data, *((uint64_t*)fc::sha1::hash(data.data(),data.size()).data()) );
auto chunk_head = slice_chunk( data );
store_chunk( chunk_head, data );
return link( chunk_head.calculate_id(), seed );
}
}
else if( fc::is_directory(p) ) {
auto dir = import_directory(p);
fc::vector<char> data(MAX_CHUNK_SIZE);
fc::datastream<char*> ds(data.data()+1, data.size()-1);
fc::raw::pack( ds, dir );
data[0] = directory_type;
data.resize( ds.tellp()+1 );
size_t seed = randomize(data, *((uint64_t*)fc::sha1::hash(data.data(),data.size()).data()) );
auto chunk_head = slice_chunk( data );
link l( chunk_head.calculate_id(), seed );
store_chunk( chunk_head, data );
return l;
}
FC_THROW_MSG( "Unsupported file type while importing '%s'", p.string() );
return cafs::link();
}
fc::string detail::process_impl::windows_shell_escape_command(const fc::path& exe, const vector<string>& args) {
fc::stringstream command_line;
command_line << windows_shell_escape(exe.string());
for (unsigned i = 0; i < args.size(); ++i)
command_line << " " << windows_shell_escape(args[i]);
return command_line.str();
}
std::vector<fc::ecc::private_key> import_bitcoin_wallet( const fc::path& wallet_dat, const std::string& passphrase )
{ try {
wallet_db db( wallet_dat.to_native_ansi_path().c_str() );
return collect_keys( db, passphrase );
} FC_RETHROW_EXCEPTIONS( warn, "" ) }
signed_transaction load_genesis( const fc::path& csv, uint64_t& total_coins )
{
total_coins = 0;
signed_transaction coinbase;
coinbase.version = 0;
// coinbase.valid_after = 0;
// coinbase.valid_blocks = 0;
std::ifstream in(csv.generic_string().c_str(), std::ios::binary);
std::string line;
std::getline( in, line );
while( in.good() )
{
std::stringstream ss(line);
std::string addr;
uint64_t amnt;
ss >> addr >> amnt;
total_coins += amnt;
coinbase.outputs.push_back(
trx_output( claim_by_pts_output( bts::pts_address(addr) ), amnt, asset::bts) );
std::getline( in, line );
}
return coinbase;
}
bool test_file::compare_files()
{
//first check if files are equal size, if not, files are different
size_t result_file_size = boost::filesystem::file_size(_result_file.string());
size_t expected_result_file_size = boost::filesystem::file_size(_expected_result_file.string());
bool file_sizes_equal = (result_file_size == expected_result_file_size);
if (!file_sizes_equal)
return false;
//files may be equal since they have the same size, so check further
std::ifstream lhs(_result_file.string().c_str());
std::ifstream rhs(_expected_result_file.string().c_str());
typedef std::istreambuf_iterator<char> istreambuf_iterator;
return std::equal( istreambuf_iterator(lhs), istreambuf_iterator(), istreambuf_iterator(rhs));
}
void compile_json_to_source(
const fc::path& source_file_name,
const fc::path& prologue_file_name,
const fc::path& json_file_name,
const fc::path& epilogue_file_name
)
{
fc::mutable_variant_object template_context;
template_context[ "source_file_name"] = source_file_name.string();
template_context["prologue_file_name"] = prologue_file_name.string();
template_context[ "json_file_name"] = json_file_name.string();
template_context["epilogue_file_name"] = epilogue_file_name.string();
std::ofstream source_file(source_file_name.string());
if (prologue_file_name.string() != "")
{
std::ifstream prologue_file(prologue_file_name.string());
std::stringstream ss_prologue_file;
ss_prologue_file << prologue_file.rdbuf();
source_file << format_string(ss_prologue_file.str(), template_context);
}
std::ifstream json_file(json_file_name.string());
std::string line;
bool first = true;
while (std::getline(json_file, line))
{
if (first)
first = false;
else
source_file << ",\n";
source_file << " " << bts::utilities::escape_string_for_c_source_code(line);
}
if (epilogue_file_name.string() != "")
{
std::ifstream epilogue_file(epilogue_file_name.string());
std::stringstream ss_epilogue_file;
ss_epilogue_file << epilogue_file.rdbuf();
source_file << format_string(ss_epilogue_file.str(), template_context);
}
return;
}
std::vector<fc::ecc::private_key> import_electrum_wallet( const fc::path& wallet_dat, const std::string& passphrase )
{ try {
std::vector<fc::ecc::private_key> keys;
electrumwallet wallet( wallet_dat.to_native_ansi_path());
if( !wallet.ok() ) FC_THROW_EXCEPTION( fc::invalid_arg_exception, "invalid electrum wallet");
wallet.derivekeys( passphrase );
return wallet.keys();
} FC_RETHROW_EXCEPTIONS( warn, "" ) }
void create_genesis_block(fc::path genesis_json_file)
{
vector<fc::ecc::private_key> delegate_private_keys;
genesis_block_config config;
config.precision = BTS_BLOCKCHAIN_PRECISION;
config.timestamp = bts::blockchain::now();
config.base_symbol = BTS_BLOCKCHAIN_SYMBOL;
config.base_name = BTS_BLOCKCHAIN_NAME;
config.base_description = BTS_BLOCKCHAIN_DESCRIPTION;
config.supply = BTS_BLOCKCHAIN_INITIAL_SHARES;
// set our fake random number generator to generate deterministic keys
set_random_seed_for_testing(fc::sha512());
std::ofstream key_stream( genesis_json_file.string() + ".keypairs" );
//create a script for importing the delegate keys
std::ofstream delegate_key_import_stream(genesis_json_file.string() + ".log");
delegate_key_import_stream << CLI_PROMPT_SUFFIX " enable_output false" << std::endl;
std::cout << "*** creating delegate public/private key pairs ***" << std::endl;
for( uint32_t i = 0; i < BTS_BLOCKCHAIN_NUM_DELEGATES; ++i )
{
name_config delegate_account;
delegate_account.name = "delegate" + fc::to_string(i);
fc::ecc::private_key delegate_private_key = fc::ecc::private_key::generate();
delegate_private_keys.push_back( delegate_private_key );
auto delegate_public_key =delegate_private_key.get_public_key();
delegate_account.owner = delegate_public_key;
delegate_account.is_delegate = true;
config.names.push_back(delegate_account);
config.balances.push_back( std::make_pair( pts_address(fc::ecc::public_key_data(delegate_account.owner)), BTS_BLOCKCHAIN_INITIAL_SHARES/BTS_BLOCKCHAIN_NUM_DELEGATES) );
//output public/private key pair for each delegate to a file
string wif_key = bts::utilities::key_to_wif( delegate_private_key );
key_stream << std::string(delegate_account.owner) << " " << wif_key << std::endl;
//add command to import the delegate keys into a client
delegate_key_import_stream << CLI_PROMPT_SUFFIX " wallet_import_private_key " << wif_key << " " << delegate_account.name << " false" << std::endl;
}
delegate_key_import_stream << CLI_PROMPT_SUFFIX " enable_output true" << std::endl;
fc::json::save_to_file( config, genesis_json_file);
}
bts_xt_client_test_config()
{
// parse command-line options
boost::program_options::options_description option_config("Allowed options");
option_config.add_options()("bts-client-exe", boost::program_options::value<std::string>(), "full path to the executable to test")
("bts-server-exe", boost::program_options::value<std::string>(), "full path to the server executable for testing client-server mode")
("extra-help", "display this help message");
boost::program_options::variables_map option_variables;
try
{
boost::program_options::store(boost::program_options::command_line_parser(boost::unit_test::framework::master_test_suite().argc,
boost::unit_test::framework::master_test_suite().argv).
options(option_config).run(), option_variables);
boost::program_options::notify(option_variables);
}
catch (boost::program_options::error&)
{
std::cerr << "Error parsing command-line options\n\n";
std::cerr << option_config << "\n";
exit(1);
}
if (option_variables.count("extra-help"))
{
std::cout << option_config << "\n";
exit(0);
}
if (option_variables.count("bts-client-exe"))
bts_client_exe = option_variables["bts-client-exe"].as<std::string>().c_str();
if (option_variables.count("bts-server-exe"))
bts_server_exe = option_variables["bts-server-exe"].as<std::string>().c_str();
std::cout << "Testing " << bts_client_exe.string() << "\n";
std::cout << "Using config directory " << config_directory.string() << "\n";
fc::create_directories(config_directory);
boost::unit_test::unit_test_log.set_threshold_level(boost::unit_test::log_messages);
}
void profile::open( const fc::path& profile_dir, const std::string& password )
{ try {
ilog("opening profile: ${profile_dir}",("profile_dir",profile_dir));
my->_profile_name = profile_dir.filename().generic_wstring();
fc::create_directories( profile_dir );
fc::create_directories( profile_dir / "addressbook" );
fc::create_directories( profile_dir / "idents" );
fc::create_directories( profile_dir / "mail" );
fc::create_directories( profile_dir / "mail" / "inbox" );
fc::create_directories( profile_dir / "mail" / "draft" );
fc::create_directories( profile_dir / "mail" / "pending" );
fc::create_directories( profile_dir / "mail" / "sent" );
fc::create_directories( profile_dir / "chat" );
fc::create_directories( profile_dir / "request" );
fc::create_directories( profile_dir / "authorization" );
ilog("loading master key file:" KEYHOTEE_MASTER_KEY_FILE);
auto profile_cfg_key = fc::sha512::hash( password.c_str(), password.size() );
std::vector<char> stretched_seed_data;
try {
stretched_seed_data = fc::aes_load( profile_dir / KEYHOTEE_MASTER_KEY_FILE, profile_cfg_key );
}
catch (fc::exception& /* e */)
{ //try to open legacy name for key file
wlog("Could not open " KEYHOTEE_MASTER_KEY_FILE ", trying to open legacy key file (.strecthed_seed).");
stretched_seed_data = fc::aes_load( profile_dir / ".stretched_seed", profile_cfg_key );
}
ilog("opening profile databases");
my->_keychain.set_seed( fc::raw::unpack<fc::sha512>(stretched_seed_data) );
my->_addressbook->open( profile_dir / "addressbook", profile_cfg_key );
my->_idents.open( profile_dir / "idents" );
my->_inbox_db->open( profile_dir / "mail" / "inbox", profile_cfg_key );
my->_draft_db->open( profile_dir / "mail" / "draft", profile_cfg_key );
my->_pending_db->open( profile_dir / "mail" / "pending", profile_cfg_key );
my->_sent_db->open( profile_dir / "mail" / "sent", profile_cfg_key );
my->_chat_db->open( profile_dir / "chat", profile_cfg_key );
my->_request_db->open( profile_dir / "request", profile_cfg_key );
my->_auth_db->open( profile_dir / "authorization", profile_cfg_key );
my->_last_sync_time.open( profile_dir / "mail" / "last_recv", true );
if( *my->_last_sync_time == fc::time_point())
{
*my->_last_sync_time = fc::time_point::now() - fc::days(5);
ilog("set last_sync_time to ${t}",("t",*my->_last_sync_time));
}
else
ilog("loaded last_sync_time = ${t}",("t",*my->_last_sync_time));
ilog("finished opening profile");
} FC_RETHROW_EXCEPTIONS( warn, "", ("profile_dir",profile_dir) ) }
void open( const fc::path& dir, bool create = true, size_t cache_size = 0 )
{ try {
FC_ASSERT( !is_open(), "Database is already open!" );
ldb::Options opts;
opts.comparator = &_comparer;
opts.create_if_missing = create;
opts.max_open_files = 64;
opts.compression = leveldb::kNoCompression;
if( cache_size > 0 )
{
opts.write_buffer_size = cache_size / 4; // up to two write buffers may be held in memory simultaneously
_cache.reset( leveldb::NewLRUCache( cache_size / 2 ) );
opts.block_cache = _cache.get();
}
if( ldb::kMajorVersion > 1 || ( leveldb::kMajorVersion == 1 && leveldb::kMinorVersion >= 16 ) )
{
// LevelDB versions before 1.16 consider short writes to be corruption. Only trigger error
// on corruption in later versions.
opts.paranoid_checks = true;
}
_read_options.verify_checksums = true;
_iter_options.verify_checksums = true;
_iter_options.fill_cache = false;
_sync_options.sync = true;
// Given path must exist to succeed toNativeAnsiPath
fc::create_directories( dir );
std::string ldbPath = dir.to_native_ansi_path();
ldb::DB* ndb = nullptr;
const auto ntrxstat = ldb::DB::Open( opts, ldbPath.c_str(), &ndb );
if( !ntrxstat.ok() )
{
elog( "Failure opening database: ${db}\nStatus: ${msg}", ("db",dir)("msg",ntrxstat.ToString()) );
FC_THROW_EXCEPTION( level_pod_map_open_failure, "Failure opening database: ${db}\nStatus: ${msg}",
("db",dir)("msg",ntrxstat.ToString()) );
}
_db.reset( ndb );
try_upgrade_db( dir, ndb, fc::get_typename<Value>::name(), sizeof( Value ) );
} FC_CAPTURE_AND_RETHROW( (dir)(create)(cache_size) ) }
void peer_database_impl::close() {
std::vector<potential_peer_record> peer_records;
peer_records.reserve(_potential_peer_set.size());
std::copy(_potential_peer_set.begin(), _potential_peer_set.end(), std::back_inserter(peer_records));
try {
fc::path peer_database_filename_dir = _peer_database_filename.parent_path();
if (!fc::exists(peer_database_filename_dir)) {
fc::create_directories(peer_database_filename_dir);
}
fc::json::save_to_file(peer_records, _peer_database_filename);
}
catch (const fc::exception &e) {
elog("error saving peer database to file ${peer_database_filename}",
("peer_database_filename", _peer_database_filename));
}
_potential_peer_set.clear();
}
void open( const fc::path& dir, bool create = true, size_t cache_size = 0 )
{ try {
ldb::Options opts;
opts.comparator = &_comparer;
opts.create_if_missing = create;
if (cache_size) {
_cache.reset(leveldb::NewLRUCache(cache_size));
opts.block_cache = _cache.get();
}
/*
if( ldb::kMajorVersion > 1 || ( leveldb::kMajorVersion == 1 && leveldb::kMinorVersion >= 16 ) )
{
// LevelDB versions before 1.16 consider short writes to be corruption. Only trigger error
// on corruption in later versions.
opts.paranoid_checks = true;
}
opts.max_open_files = 64;
_read_options.verify_checksums = true;
_iter_options.verify_checksums = true;
_iter_options.fill_cache = false;
_sync_options.sync = true;
*/
/// \warning Given path must exist to succeed toNativeAnsiPath
fc::create_directories(dir);
std::string ldbPath = dir.to_native_ansi_path();
ldb::DB* ndb = nullptr;
auto ntrxstat = ldb::DB::Open( opts, ldbPath.c_str(), &ndb );
if( !ntrxstat.ok() )
{
FC_THROW_EXCEPTION( db_in_use_exception, "Unable to open database ${db}\n\t${msg}",
("db",dir)
("msg",ntrxstat.ToString())
);
}
_db.reset(ndb);
try_upgrade_db( dir,ndb, fc::get_typename<Value>::name(),sizeof(Value) );
} FC_RETHROW_EXCEPTIONS( warn, "" ) }
void mmap_struct_base::open( const fc::path& file, size_t s, bool create )
{
if( !fc::exists( file ) || fc::file_size(file) != s )
{
fc::ofstream out( file );
char buffer[1024];
memset( buffer, 0, sizeof(buffer) );
size_t bytes_left = s;
while( bytes_left > 0 )
{
size_t to_write = std::min<size_t>(bytes_left, sizeof(buffer) );
out.write( buffer, to_write );
bytes_left -= to_write;
}
}
std::string filePath = file.to_native_ansi_path();
_file_mapping.reset( new fc::file_mapping( filePath.c_str(), fc::read_write ) );
_mapped_region.reset( new fc::mapped_region( *_file_mapping, fc::read_write, 0, s ) );
}
void open( const fc::path& dir, bool create = true )
{
ldb::Options opts;
opts.create_if_missing = create;
opts.comparator = & _comparer;
/// \waring Given path must exist to succeed toNativeAnsiPath
fc::create_directories(dir);
std::string ldbPath = dir.to_native_ansi_path();
ldb::DB* ndb = nullptr;
auto ntrxstat = ldb::DB::Open( opts, ldbPath.c_str(), &ndb );
if( !ntrxstat.ok() )
{
FC_THROW_EXCEPTION( db_in_use_exception, "Unable to open database ${db}\n\t${msg}",
("db",dir)
("msg",ntrxstat.ToString())
);
}
_db.reset(ndb);
UpgradeDbIfNecessary(dir,ndb, fc::get_typename<Value>::name(),sizeof(Value));
}
/**
* Imports the file chunks into the database, but does not
* import the file_header itself as a chunk, as it may be
* imbedded within another chunk.
*
* @pre is_regular_file(p)
*/
cafs::file_header cafs::import_file( const fc::path& p ) {
file_header head;
head.file_size = fc::file_size(p);
fc::vector<char> chunk( MAX_CHUNK_SIZE );
// divide file up into chunks and slices
fc::ifstream in( p.string(), fc::ifstream::binary );
uint32_t r = 0;
while( r < head.file_size ) {
size_t some = fc::min( size_t(chunk.size()), size_t(head.file_size-r) );
in.read( chunk.data(), some );
size_t seed = randomize(chunk, *((uint64_t*)fc::sha1::hash(chunk.data(),chunk.size()).data()) );
chunk.resize(some);
auto chunk_head = slice_chunk(chunk);
auto chunk_id = store_chunk( chunk_head, chunk );
head.add_chunk( chunk_id, seed, chunk_head );
r += some;
}
return head;
}
void run_regression_test(fc::path test_dir, bool with_network)
{
set_random_seed_for_testing(fc::sha512());
// open testconfig file
// for each line in testconfig file
// add a verify_file object that knows the name of the input command file and the generated log file
// start a process with that command line
// wait for all processes to shutdown
// for each verify_file object,
// compare generated log files in datadirs to golden reference file (i.e. input command files)
// caller of this routine should have made sure we are already in bitshares_toolkit/test dir.
// so we pop dirs to create regression_tests_results as sibling to bitshares_toolkit source directory
// (because we don't want the test results to be inadvertantly added to git repo).
fc::path original_working_directory = boost::filesystem::current_path();
fc::path regression_test_output_directory = original_working_directory.parent_path().parent_path();
regression_test_output_directory /= "regression_tests_output";
// Create an expected output file in the test subdir for the test output.
fc::path test_output_dir = regression_test_output_directory / test_dir;
boost::filesystem::create_directories(test_output_dir);
fc::path expected_output_file = test_output_dir / "expected_output.log";
std::ofstream expected_output_stream(expected_output_file.string());
try
{
std::cout << "*** Executing " << test_dir.string() << std::endl;
boost::filesystem::current_path(test_dir.string());
//create a small genesis block to reduce test startup time
//fc::temp_directory temp_dir;
//fc::path genesis_json_file = temp_dir.path() / "genesis.json";
//create_genesis_block(genesis_json_file);
//DLN: now we just used the genesis file already committed to repo, update it
// using "-t make_genesis_block" if desired.
fc::path genesis_json_file = "../../test_genesis.json";
//open test configuration file (contains one line per client to create)
fc::path test_config_file_name = "test.config";
std::ifstream test_config_file(test_config_file_name.string());
//create one client per line and run each client's input commands
auto sim_network = std::make_shared<bts::net::simulated_network>();
vector<test_file> tests;
string line = " --min-delegate-connection-count=0 ";
fc::future<void> client_done;
while (std::getline(test_config_file,line))
{
//append genesis_file to load to command-line for now (later should be pre-created in test dir I think)
line += " --genesis-config " + genesis_json_file.string();
//if no data-dir specified, put in ../bitshares_toolkit/regression_tests/${test dir}/${client_name}
string client_name = line.substr(0, line.find(' '));
size_t data_dir_position = line.find("--data-dir");
if (data_dir_position == string::npos)
{
fc::path default_data_dir = regression_test_output_directory / test_dir / client_name;
line += " --data-dir=" + default_data_dir.string();
fc::remove_all(default_data_dir);
}
//parse line into argc/argv format for boost program_options
int argc = 0;
char** argv = nullptr;
#ifndef WIN32 // then UNIX
//use wordexp to get argv/arc
wordexp_t wordexp_result;
wordexp(line.c_str(), &wordexp_result, 0);
auto option_variables = parse_option_variables(wordexp_result.we_wordc, wordexp_result.we_wordv);
argv = wordexp_result.we_wordv;
argc = wordexp_result.we_wordc;
#else
//use ExpandEnvironmentStrings and CommandLineToArgv to get argv/arc
char expanded_line[40000];
ExpandEnvironmentStrings(line.c_str(),expanded_line,sizeof(expanded_line));
argv = CommandLineToArgvA(expanded_line,&argc);
auto option_variables = bts::client::parse_option_variables(argc, argv);
#endif
//extract input command files from cmdline options and concatenate into
//one expected output file so that we can compare against output log
std::vector<string> input_logs = option_variables["input-log"].as<std::vector<string>>();
for (string input_log : input_logs)
{
std::ifstream input_stream(input_log);
expected_output_stream << input_stream.rdbuf();
}
expected_output_stream.close();
//run client with cmdline options
if (with_network)
{
FC_ASSERT(false, "Not implemented yet!")
}
else
{
bts::client::client_ptr client = std::make_shared<bts::client::client>(sim_network);
client->configure_from_command_line(argc,argv);
client_done = client->start();
}
#ifndef WIN32 // then UNIX
wordfree(&wordexp_result);
#else
GlobalFree(argv);
#endif
//add a test that compares input command file to client's log file
fc::path result_file = ::get_data_dir(option_variables) / "console.log";
tests.push_back( test_file(client_done, result_file, expected_output_file) );
} //end while not end of test config file
//check each client's log file against it's golden reference log file
for (test_file current_test : tests)
{
//current_test.compare_files();
current_test.client_done.wait();
BOOST_CHECK_MESSAGE(current_test.compare_files(), "Results mismatch with golden reference log");
}
}
inline void pack( Stream& s, const fc::path& tp )
{
fc::raw::pack( s, tp.generic_string() );
}
void ifstream::open( const fc::path& file, int m ) {
my->ifs.open( file.string().c_str(), std::ios::binary );
}
fc::optional<fc::logging_config> load_logging_config_from_ini_file(const fc::path& config_ini_filename)
{
try
{
fc::logging_config logging_config;
bool found_logging_config = false;
boost::property_tree::ptree config_ini_tree;
boost::property_tree::ini_parser::read_ini(config_ini_filename.preferred_string().c_str(), config_ini_tree);
for (const auto& section : config_ini_tree)
{
const std::string& section_name = section.first;
const boost::property_tree::ptree& section_tree = section.second;
const std::string console_appender_section_prefix = "log.console_appender.";
const std::string file_appender_section_prefix = "log.file_appender.";
const std::string logger_section_prefix = "logger.";
if (boost::starts_with(section_name, console_appender_section_prefix))
{
std::string console_appender_name = section_name.substr(console_appender_section_prefix.length());
std::string stream_name = section_tree.get<std::string>("stream");
// construct a default console appender config here
// stdout/stderr will be taken from ini file, everything else hard-coded here
fc::console_appender::config console_appender_config;
console_appender_config.level_colors.emplace_back(
fc::console_appender::level_color(fc::log_level::debug,
fc::console_appender::color::green));
console_appender_config.level_colors.emplace_back(
fc::console_appender::level_color(fc::log_level::warn,
fc::console_appender::color::brown));
console_appender_config.level_colors.emplace_back(
fc::console_appender::level_color(fc::log_level::error,
fc::console_appender::color::cyan));
console_appender_config.stream = fc::variant(stream_name).as<fc::console_appender::stream::type>();
logging_config.appenders.push_back(fc::appender_config(console_appender_name, "console", fc::variant(console_appender_config)));
found_logging_config = true;
}
else if (boost::starts_with(section_name, file_appender_section_prefix))
{
std::string file_appender_name = section_name.substr(file_appender_section_prefix.length());
fc::path file_name = section_tree.get<std::string>("filename");
if (file_name.is_relative())
file_name = fc::absolute(config_ini_filename).parent_path() / file_name;
// construct a default file appender config here
// filename will be taken from ini file, everything else hard-coded here
fc::file_appender::config file_appender_config;
file_appender_config.filename = file_name;
file_appender_config.flush = true;
file_appender_config.rotate = true;
file_appender_config.rotation_interval = fc::hours(1);
file_appender_config.rotation_limit = fc::days(1);
logging_config.appenders.push_back(fc::appender_config(file_appender_name, "file", fc::variant(file_appender_config)));
found_logging_config = true;
}
else if (boost::starts_with(section_name, logger_section_prefix))
{
std::string logger_name = section_name.substr(logger_section_prefix.length());
std::string level_string = section_tree.get<std::string>("level");
std::string appenders_string = section_tree.get<std::string>("appenders");
fc::logger_config logger_config(logger_name);
logger_config.level = fc::variant(level_string).as<fc::log_level>();
boost::split(logger_config.appenders, appenders_string,
boost::is_any_of(" ,"),
boost::token_compress_on);
logging_config.loggers.push_back(logger_config);
found_logging_config = true;
}
}
if (found_logging_config)
return logging_config;
else
return fc::optional<fc::logging_config>();
}
FC_RETHROW_EXCEPTIONS(warn, "")
}
bool rpc_client_impl::import_bitcoin_wallet(const fc::path& wallet_filename, const std::string& password)
{
return _json_connection->call<bool>("import_bitcoin_wallet", wallet_filename.string(), password);
}
void cafs::export_link( const cafs::link& l, const fc::path& d ) {
try {
if( !fc::exists( d.parent_path() ) ) {
slog( "create '%s'", d.generic_string().c_str() );
fc::create_directories(d.parent_path());
}
fc::vector<char> ch = get_chunk( l.id );
derandomize( l.seed, ch );
// slog( "derandomized... '%s'", fc::to_hex( ch.data(), 16 ).c_str() );
if( ch.size() == 0 ) {
FC_THROW_MSG( "Empty Chunk!" );
}
switch( ch[0] ) {
case file_data_type: {
slog( "file data..." );
// slog( "post randomized... '%s'", fc::to_hex( ch.data(), ch.size() ).c_str() );
fc::ofstream ofile( d, fc::ofstream::binary );
ofile.write( ch.data()+1, ch.size()-1 );
break;
}
case directory_type: {
slog( "directory data..." );
fc::datastream<const char*> ds(ch.data()+1, ch.size()-1);
directory d;
fc::raw::unpack( ds, d );
slog( "%s", fc::json::to_string( d ).c_str() );
for( auto itr = d.entries.begin(); itr != d.entries.end(); ++itr ) {
slog( "entry: %s", itr->name.c_str() );
/*
fc::vector<char> fdat = get_file( itr->ref );
switch( itr->ref.type ) {
case file_data_type: {
break;
}
case directory_type: {
slog( "%s", fc::json::to_string( fc::raw::unpack<directory>(fdat) ).c_str() );
break;
}
case file_header_type: {
slog( "%s", fc::json::to_string( fc::raw::unpack<file_header>(fdat) ).c_str() );
break;
}
default:
wlog( "Unknown Type %d", int(itr->ref.type) );
}
*/
}
break;
}
case file_header_type: {
slog( "file header..." );
fc::datastream<const char*> ds(ch.data()+1, ch.size()-1);
slog( "data %s", fc::to_hex( ch.data(), 16 ).c_str() );
file_header fh;
fc::raw::unpack( ds, fh);
slog( "%s", fc::json::to_string( fh ).c_str() );
fc::ofstream ofile( d, fc::ofstream::binary );
for( auto i = fh.chunks.begin(); i != fh.chunks.end(); ++i ) {
fc::vector<char> c = get_chunk( i->hash );
derandomize( i->seed, c );
ofile.write( c.data(), c.size() );
}
break;
}
default:
FC_THROW_MSG( "Unknown File Type %s", int(ch[0]) );
}
} catch ( fc::error_report& e ) {
throw FC_REPORT_PUSH( e, "Unable to export link ${link} to ${path}", fc::value().set("link", fc::string(l)).set("path", d.generic_string() ) );
}
}
