#ifndef _WIN32 #include "Puid.h" #include "../os/os.h" #include "../utils/bts_assert.h" #include "Uuid.h" #include #include #include #include #include #include #include #include #include #include #include #include namespace bts { namespace utils { // use a single global lock for simplicity. we can do a per domain // lock if we ever need it. we need a lock because posix locks files // per process not per thread. tbb::mutex lock; const std::string lock_file_name = "lock_file"; const std::string counter_file_name = "counter_file"; // we use the algorithm in // http://blogs.msdn.com/b/adioltean/archive/2005/12/28/507866.aspx // relying on the fact that metadata changes (like renaming) are // atomic to provide transactional updates to a counter file which is // used to generate uuids. // // Write process (on Foo.txt): // - Step W1: Acquire "write lock" on the existing file. // - Step W2: Copy the old file in a new unique temporary file. (copy Foo.txt // Foo.TmpNNNN.txt) // - Step W3: Apply the writes to the new file (Foo.TmpNNNN.txt). // - Step W4: Flush all the writes (for example those being remaining in the // cache manager). // - Step W5: Rename the old file in a new unique Alternate form (ren Foo.txt // Foo.AltNNNN.txt) // - Step W6: Rename the new file into the old file (ren Foo.TmpNNNN.txt // Foo.txt) // - Step W7: Delete the old Alternate file (del Foo.AltNNNN.txt). If this // fails, simply ignore. The file will be deleted later during the next // recovery. // - Step W8: Release "write lock" on the existing file. // Recovery from a crash during write (on Foo.txt): // - Step R1: If Foo.txt is missing but we have both Foo.AltNNNN.txt and // Foo.TmpNNNN.txt present, then we crashed between Step W5 and Step W6. Retry // from Step W6. // - Step R2: If Foo.txt is present but Foo.TmpNNNN.txt is also present, then we // crashed before Step W5. Try to delete all Foo.TmpNNNN.txt files and ignore // failures. // - Step R3: If Foo.txt is present but Foo.AltNNNN.txt is also present, then we // crashed between Step W6 and Step W7. Try to delete all Foo.AltNNNN.txt files // and ignore failures. void init_store( std::string const &path, std::string const &lock_path, std::string const &counter_path) { if (!boost::filesystem::is_directory(path)) { boost::filesystem::create_directories(path); std::ofstream fs(lock_path.c_str()); std::ofstream fc(counter_path.c_str()); fc << 0; } } std::string find_file(std::string const &path, std::string const &ending) { for (boost::filesystem::directory_iterator p = boost::filesystem::directory_iterator(path); p != boost::filesystem::directory_iterator(); p++) { std::string fn(p->path().string()); if (boost::algorithm::ends_with(fn, ending)) return fn; } return std::string(); } // boost::filesystem::copy_file is broken for C++ 11 unless one compiles boost // with c++ 11. (See // http://boost.2283326.n4.nabble.com/Filesystem-problems-with-g-std-c-0x-td2639716.html) // so we provide our own. void copy_file(std::string const &in, std::string const &out) { std::fstream f(in.c_str(), std::fstream::in | std::fstream::binary); f << std::noskipws; std::istream_iterator begin(f); std::istream_iterator end; std::fstream f2( out.c_str(), std::fstream::out | std::fstream::trunc | std::fstream::binary); std::ostream_iterator begin2(f2); std::copy(begin, end, begin2); } uint32_t get_host_ip_uint32(std::string const &ip) { std::vector split_vec; boost::algorithm::split(split_vec, ip, boost::algorithm::is_any_of(".")); bts_assert(split_vec.size() == 4); uint32_t result = 0; int idx = 0; for (std::string &byte : split_vec) { uint32_t this_byte = atoi(byte.c_str()); this_byte = (this_byte << (idx++ * 8)); result += this_byte; } return result; } std::string &get_host_ip_string(std::string const &ip) { static std::string result; if (result.size() == 0) { std::ostringstream result_stream; bts_assert(ip.size()); bts_assert(ip != "127.0.0.1"); std::istringstream ip_str(ip); for (int i = 0; i < 4; i++) { int b; ip_str >> b; ip_str.get(); char high_nibble = (b & 0xf0) >> 4; char low_nibble = b & 0x0f; if (high_nibble >= 10) high_nibble = (high_nibble - 10) + 'a'; else high_nibble += '0'; if (low_nibble >= 10) low_nibble = (low_nibble - 10) + 'a'; else low_nibble += '0'; result_stream << high_nibble << low_nibble; } result = result_stream.str(); } return result; } uint64_t reserve_ids(std::string const &scope, int n_ids) { tbb::mutex::scoped_lock l(lock); // we risk race conditions if the directory is not there. // but that's OK, this is rare and easily manageable. std::string path = os::bts_data_path() + "/puids/" + scope; std::string lock_path = path + "/" + lock_file_name; std::string counter_path = path + "/" + counter_file_name; init_store(path, lock_path, counter_path); // W1 boost::interprocess::file_lock f_lock(lock_path.c_str()); boost::interprocess::scoped_lock scope_lock( f_lock); std::string tmp_file = find_file(path, ".tmp"); std::string alt_file = find_file(path, ".alt"); std::string counter_file = find_file(path, counter_file_name); // r1? if (counter_file.size() == 0 && tmp_file.size() && alt_file.size()) { boost::filesystem::rename(tmp_file, counter_path); boost::filesystem::remove(alt_file); f_lock.unlock(); lock.unlock(); return reserve_ids(scope, n_ids); } // r2 else if (counter_file.size() && tmp_file.size()) { boost::filesystem::remove(tmp_file); f_lock.unlock(); lock.unlock(); return reserve_ids(scope, n_ids); } // r3 else if (counter_file.size() && alt_file.size()) { boost::filesystem::remove(alt_file); f_lock.unlock(); lock.unlock(); return reserve_ids(scope, n_ids); } else { // W2, copy counter file to a temp file tmp_file = path + "/" + Uuid().to_text_string() + ".tmp"; copy_file(counter_path, tmp_file); // W3, W4 update temp file, close and flush uint64_t counter_value; std::ifstream(tmp_file.c_str()) >> counter_value; std::ofstream(tmp_file.c_str()) << counter_value + n_ids; // W5, rename counter file to an alt file (renames are atomic) alt_file = path + "/" + Uuid().to_text_string() + ".alt"; boost::filesystem::rename(counter_path, alt_file); // W6, rename temp file to counter file boost::filesystem::rename(tmp_file, counter_path); // W7 delete alt file boost::filesystem::remove(alt_file); return counter_value; } } std::vector gen_ids(std::string const &scope, int n_ids) { auto counter_value = reserve_ids(scope, n_ids); std::vector result; for (int i = 0; i < n_ids; i++) result.push_back(counter_value + i); return result; } static char base_62_alphabet[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; std::string to_base_62(uint32_t src) { std::string out(6, ' '); for (int i = 5; i >= 0; i--) { int r = src % 62; out[i] = base_62_alphabet[r]; src = src / 62; } return out; } void to_base_62(std::vector const &id_vec, std::vector *out) { for (auto src : id_vec) for (int i = 5; i >= 0; i--) { int r = src % 62; out->push_back(base_62_alphabet[r]); src = src / 62; } } uint64_t gen_id(std::string const &scope) { std::vector result = gen_ids(scope, 1); return result[0]; } std::vector gen_puids(std::string const &scope, int n_puids) { // first generate a series of unique uint32 numbers (For this machine) std::vector ids = gen_ids(scope, n_puids); // now add the host ip and a timer string to the generated id to // guarantee uniqueness across machines uint32_t ip = get_host_ip_uint32(os::default_host_ip()); std::string encoded_ip(to_base_62(ip)); uint32_t seconds = time(NULL); std::string encoded_time(to_base_62(seconds)); std::vector result; for (uint32_t id : ids) { std::ostringstream s; s << encoded_ip << "-" << encoded_time << "-" << to_base_62(id); result.push_back(s.str()); } return result; } Puid gen_puid(std::string const &scope) { return *(gen_puids(scope, 1).begin()); } } // namespace utils } // namespace bts #endif