├── src
    ├── useless.md
    ├── logging
    │   ├── useless.md
    │   ├── singleton.h
    │   ├── log_recorder.h
    │   ├── blocking_queue.h
    │   ├── logger.h
    │   ├── logger.cpp
    │   └── log_recorder.cpp
    ├── conn_data.h
    ├── test
    │   ├── dotest.h
    │   ├── test_config.h
    │   ├── test.h
    │   └── test_client.h
    ├── persistence.cpp
    ├── persistence.h
    ├── recovery.h
    ├── cmd_recoder.h
    ├── kv_database.h
    ├── main.cpp
    ├── utils.h
    ├── transaction.h
    ├── config.h
    ├── store_client.h
    ├── kvstore.pro
    ├── tcp_server.h
    ├── kv_database.cpp
    ├── tcp_connection.h
    ├── config.cpp.autosave
    ├── cmd_recoder.cpp
    ├── store_server.h
    ├── tcp_server.cpp
    ├── config.cpp
    ├── recovery.cpp
    ├── tcp_connection.cpp
    ├── store_client.cpp
    ├── cmd_protocol.h
    ├── store_server.cpp
    └── kvstore.pro.user
└── README.md


/src/useless.md:
--------------------------------------------------------------------------------
1 | 1
2 | 


--------------------------------------------------------------------------------
/src/logging/useless.md:
--------------------------------------------------------------------------------
1 | 1
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # [c++]使用boost.asio写的简单键值对缓存
 2 | 支持put，del， get三个命令。
 3 | 用use切换数据库。
 4 | 
 5 | 支持密码。
 6 | 
 7 | 支持持久化。
 8 | 
 9 | 支持事务。
10 | 
11 | <p>配置文件形式如下</p>
12 | <p>persistence:on</p>
13 | <p>password:"mima"</p>
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/src/conn_data.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONN_DATA
 2 | #define CONN_DATA
 3 | #include <string>
 4 | #include "transaction.h"
 5 | 
 6 | namespace kvstore {
 7 | 
 8 | struct ConnData {
 9 |     ConnData() : db(0), buf(), transaction(), login(false) {}
10 |     std::size_t db;
11 |     std::string buf;
12 |     Transaction transaction;
13 |     bool login;
14 | };
15 | //buf高水位
16 | }
17 | #endif // CONN_DATA
18 | 
19 | 


--------------------------------------------------------------------------------
/src/test/dotest.h:
--------------------------------------------------------------------------------
 1 | #include <thread>
 2 | #include "test.h"
 3 | #include "test/test_config.h"
 4 | #include "../store_server.h"
 5 | #include "../store_client.h"
 6 | #include "test/test_client.h"
 7 | using namespace kvstore;
 8 | namespace test {
 9 | 
10 | static void do_test(boost::asio::io_service& ioservice) {
11 |    test_config();
12 |    test_client_transaction3();
13 |    //test_client_transaction2();
14 |    //test_client_transaction();
15 | }
16 | 
17 | }//namespace
18 | 


--------------------------------------------------------------------------------
/src/logging/singleton.h:
--------------------------------------------------------------------------------
 1 | #ifndef SINGLETON_H
 2 | #define SINGLETON_H
 3 | namespace logging {
 4 | 
 5 | template<class T>
 6 | class Singleton {
 7 | public:
 8 |     static T& get_instance() {
 9 |         static T instance_;
10 |         return instance_;
11 |     }
12 | 
13 |     ~Singleton() { }
14 | 
15 | private:
16 |     Singleton() {}
17 |     Singleton(const Singleton &other);
18 |     Singleton & operator=(const Singleton &other);
19 | };
20 | }
21 | #endif // SINGLETON_H
22 | 
23 | 


--------------------------------------------------------------------------------
/src/persistence.cpp:
--------------------------------------------------------------------------------
 1 | #include "persistence.h"
 2 | 
 3 | #include "cmd_protocol.h"
 4 | namespace kvstore {
 5 | Persistence::Persistence(StoreServer& server):
 6 |     server_(server),
 7 |     cmdRecoder_()
 8 | {
 9 | 
10 | }
11 | 
12 | int Persistence::record(const std::string &cmd, int databaseid) {
13 |     return cmdRecoder_.record(cmd, databaseid);
14 | }
15 | 
16 | int Persistence::recover() {
17 |     Recovery recovery;
18 |     return recovery.recover(server_);
19 | }
20 | 
21 | 
22 | } //namespace
23 | 
24 | 


--------------------------------------------------------------------------------
/src/persistence.h:
--------------------------------------------------------------------------------
 1 | #ifndef PERSISTENCE_H
 2 | #define PERSISTENCE_H
 3 | //#include "store_server.h"
 4 | #include "cmd_recoder.h"
 5 | #include "recovery.h"
 6 | namespace kvstore {
 7 | class StoreServer;
 8 | 
 9 | class Persistence
10 | {
11 | public:
12 |     Persistence(StoreServer& server);
13 |      int record(const std::string& cmd, int databaseid);
14 |      int recover();
15 | 
16 | private:
17 |      StoreServer& server_;
18 |     CmdRecoder cmdRecoder_;
19 | };
20 | 
21 | } //namepsace
22 | 
23 | #endif // PERSISTENCE_H
24 | 


--------------------------------------------------------------------------------
/src/recovery.h:
--------------------------------------------------------------------------------
 1 | #ifndef RECOVERY_H
 2 | #define RECOVERY_H
 3 | #include "kv_database.h"
 4 | #include <vector>
 5 | namespace kvstore {
 6 | class StoreServer;
 7 | class Recovery {
 8 | public:
 9 |     Recovery();
10 |     int recover(StoreServer &server);
11 | 
12 | private:
13 |     int execute_cmds(StoreServer &server, std::size_t db,const std::vector<std::string>& cmds);
14 |     int read_file(const std::string& filename, std::vector<std::string>& cmds);
15 | private:
16 | 
17 | };
18 | 
19 | } //namespace
20 | 
21 | #endif // RECOVERY_H
22 | 


--------------------------------------------------------------------------------
/src/cmd_recoder.h:
--------------------------------------------------------------------------------
 1 | #ifndef CMDRECODER_H
 2 | #define CMDRECODER_H
 3 | #include <string>
 4 | #include <vector>
 5 | #include <fstream>
 6 | namespace kvstore {
 7 | 
 8 | class CmdRecoder
 9 | {
10 | public:
11 |     CmdRecoder(std::size_t dbnum);
12 |     CmdRecoder();
13 |     int record(const std::string& cmd, int databaseid);
14 | private:
15 |     int init();
16 | private:
17 |     std::size_t dbnum_;
18 |     std::vector<std::ofstream> dbfiles_;
19 | };
20 | static const char* CMD_SAVE_PATH_FOLDER = "cmd_save/";
21 | 
22 | }
23 | #endif // CMDRECODER_H
24 | 


--------------------------------------------------------------------------------
/src/logging/log_recorder.h:
--------------------------------------------------------------------------------
 1 | #ifndef LOG_RECORDER_H
 2 | #define LOG_RECORDER_H
 3 | #include <string>
 4 | #include <memory>
 5 | #include <atomic>
 6 | #include <functional>
 7 | #include <mutex>
 8 | #include "blocking_queue.h"
 9 | #include "logger.h"
10 | 
11 | namespace logging {
12 | class LogRecorder {
13 | public:
14 |     LogRecorder();
15 |     void submit(std::string msg);
16 |     void stop();
17 |     static Logger::OutputCallback callback();
18 | 
19 | private:
20 |     void create_dir_and_files();
21 |     void customer_thread_function();
22 |     void adjust_filename();
23 | private:
24 |     BlockingQueue<std::string> queue_;
25 |     std::atomic_bool quit_;
26 | };
27 | 
28 | } // namespace
29 | #endif // LOG_RECORDER_H
30 | 


--------------------------------------------------------------------------------
/src/kv_database.h:
--------------------------------------------------------------------------------
 1 | #ifndef KVDATABASE_H
 2 | #define KVDATABASE_H
 3 | 
 4 | #include <unordered_map>
 5 | //#include <map>
 6 | #include <vector>
 7 | #include <string>
 8 | 
 9 | namespace kvstore {
10 | class KVDatabase {
11 |     typedef std::unordered_map<std::string, std::string> StringMap;
12 | public:
13 |     KVDatabase();
14 |     KVDatabase(std::size_t num);
15 | 
16 |     std::size_t size() const;
17 | 
18 |     int clear(std::size_t id);
19 |     int put(std::size_t id, std::string key, std::string value);
20 |     int get(std::size_t id, std::string key, std::string& value) const;
21 |     int del(std::size_t id, std::string key);
22 | 
23 | private:
24 |     std::vector<StringMap> maps_;
25 | };
26 | 
27 | 
28 | } //namespace
29 | 
30 | #endif // KVDATABASE_H
31 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "store_server.h"
 3 | #include "test/dotest.h"
 4 | using namespace std;
 5 | using namespace kvstore;
 6 | 
 7 | 
 8 | int main()
 9 | {
10 |     //设置log输出到控制台，并且保存到文件
11 |     logging::Logger::set_output(logging::LogRecorder::callback());
12 |     //logging::Logger::set_level(logging::Logger::eINFO);
13 |     logging::Logger::set_level(logging::Logger::eDEBUG);
14 |     //logging::Logger::set_no_display_function(true);
15 |     boost::asio::io_service ioservice;
16 |     std::size_t port = 23333;
17 |     StoreServer server(ioservice, port);
18 |     server.init();
19 |     //做测试入口
20 |     test::do_test(ioservice);
21 |     ioservice.run();
22 |     cout << "Hello World!" << endl;
23 |     return 0;
24 | }
25 | 
26 | 
27 | 
28 | 
29 | 
30 | 


--------------------------------------------------------------------------------
/src/utils.h:
--------------------------------------------------------------------------------
 1 | #ifndef UTILS
 2 | #define UTILS
 3 | #include <sstream>
 4 | #include <string>
 5 | #include <time.h>
 6 | namespace utils{
 7 | 
 8 | template<class T>
 9 | static std::string to_string(const T& value) {
10 |     std::stringstream ss;
11 |     ss << value;
12 |     std::string str;
13 |     ss >> str;
14 |     return str;
15 | }
16 | 
17 | static std::string& trim(std::string &s) {
18 |     if (s.empty()) {
19 |         return s;
20 |     }
21 |     s.erase(0,s.find_first_not_of(" "));
22 |     s.erase(s.find_last_not_of(" ") + 1);
23 |     return s;
24 | }
25 | 
26 | static std::string& trim_quo(std::string &s) {
27 |     if (s.empty()) {
28 |         return s;
29 |     }
30 |     s.erase(0,s.find_first_not_of("\""));
31 |     s.erase(s.find_last_not_of("\"") + 1);
32 |     return s;
33 | }
34 | 
35 | 
36 | }
37 | #endif // UTILS
38 | 
39 | 


--------------------------------------------------------------------------------
/src/transaction.h:
--------------------------------------------------------------------------------
 1 | #ifndef TRANSACTION
 2 | #define TRANSACTION
 3 | 
 4 | #include <vector>
 5 | #include <map>
 6 | #include <string>
 7 | namespace kvstore {
 8 | 
 9 | class Transaction {
10 |     public:
11 |     Transaction() : cmds_(), watchs_(), mult_flag_(false) {}
12 |     bool mult() const { return mult_flag_; }
13 |     void set_mult(bool flag) { mult_flag_ = flag; }
14 |     void add_cmd(const std::string& cmd) { cmds_.push_back(cmd); }
15 |     void add_watch(const std::string& key, const std::string& value) { watchs_[key] = value; }
16 |     void clear_cmd() { cmds_.clear(); }
17 |     void clear_watch() { watchs_.clear(); }
18 |     std::vector<std::string>& cmds() { return cmds_; }
19 |     std::map<std::string, std::string> & watchs() { return watchs_; }
20 | private:
21 |     std::vector<std::string> cmds_;
22 |     std::map<std::string, std::string> watchs_;
23 |     bool mult_flag_;
24 | };
25 | 
26 | } // namespace
27 | #endif // TRANSACTION
28 | 
29 | 


--------------------------------------------------------------------------------
/src/config.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONFIG_H
 2 | #define CONFIG_H
 3 | #include <string>
 4 | namespace kvstore {
 5 | 
 6 | struct ConfigInfo {
 7 |     ConfigInfo() : need_password(false), persistence(false), password("") {}
 8 |     bool need_password;
 9 |     bool persistence;
10 |     std::string password;
11 | };
12 | 
13 | class Config {
14 | public:
15 |     Config();
16 |     Config(const std::string& path);
17 | 
18 |     bool need_persistence() const { return info_.persistence; }
19 |     bool need_password() const { return info_.need_password; }
20 |     std::string password() const { return info_.password; }
21 | 
22 | private:
23 |     void init(const std::string& path);
24 |     int parse(const std::string& path);
25 |     void process_password(const std::string& value);
26 |     void process_persistence(const std::string& value);
27 | private:
28 |     ConfigInfo info_;
29 | };
30 | //方便测试，把函数声明到头文件
31 | int parse_line(const std::string &line, std::string &key, std::string &value);
32 | 
33 | 
34 | } //namespace
35 | #endif // CONFIG_H
36 | 


--------------------------------------------------------------------------------
/src/store_client.h:
--------------------------------------------------------------------------------
 1 | #ifndef STORECLIENT_H
 2 | #define STORECLIENT_H
 3 | #include <boost/asio.hpp>
 4 | #include <boost/array.hpp>
 5 | #include <unistd.h>
 6 | #include <set>
 7 | #include <functional>
 8 | 
 9 | #include "tcp_connection.h"
10 | #include "logging/logger.h"
11 | #include "logging/log_recorder.h"
12 | namespace kvstore {
13 | 
14 | class StoreClient {
15 | public:
16 |     typedef std::function<void(boost::system::error_code& error)> ConnectCallback;
17 |     typedef std::pair<int, std::string>  Result;
18 | public:
19 |     StoreClient(boost::asio::io_service& ioservice);
20 |     void connect(const std::string& addr, const std::string& port);
21 | 
22 |     Result use(std::size_t db);
23 |     Result put(const std::string& key, const std::string& value);
24 |     Result get(const std::string& key);
25 |     Result del(const std::string& key);
26 |     Result login(const std::string& password);
27 |     Result mult();
28 |     Result exec();
29 |     Result discard();
30 |     Result watch(const std::string& key);
31 | private:
32 |     boost::asio::io_service& ioservice_;
33 |     boost::asio::ip::tcp::socket socket_;
34 | };
35 | 
36 | }//namespace
37 | 
38 | #endif // STORECLIENT_H
39 | 


--------------------------------------------------------------------------------
/src/logging/blocking_queue.h:
--------------------------------------------------------------------------------
 1 | #ifndef BLOCKING_QUEUE_H
 2 | #define BLOCKING_QUEUE_H
 3 | 
 4 | #include <mutex>
 5 | #include <condition_variable>
 6 | #include <queue>
 7 | 
 8 | namespace logging {
 9 | 
10 | template<class T>
11 | class BlockingQueue {
12 | public:
13 |     BlockingQueue() : queue_(), mutex_(), cond_() {}
14 | 
15 |     void push(T new_value) {
16 |         std::lock_guard<std::mutex> lock(mutex_);
17 |         queue_.push(std::move(new_value));
18 |         cond_.notify_one();
19 |     }
20 | 
21 |     bool empty() const {
22 |         std::lock_guard<std::mutex> lock(mutex_);
23 |         return queue_.empty();
24 |     }
25 | 
26 |     T pop() {
27 |         std::unique_lock<std::mutex> lock(mutex_);
28 |         cond_.wait(lock, [this]{ return !queue_.empty(); });
29 |         T value = std::move(queue_.front());
30 |         queue_.pop();
31 |         return value;
32 |     }
33 | 
34 | private:
35 |     BlockingQueue(const BlockingQueue& other) = delete;
36 |     BlockingQueue& operator=(const BlockingQueue& other) = delete;
37 |     BlockingQueue(BlockingQueue&& other) = delete;
38 | 
39 | 
40 | private:
41 |     std::queue<T> queue_;
42 |     mutable std::mutex mutex_;
43 |     std::condition_variable cond_;
44 | };
45 | 
46 | 
47 | 
48 | } //namespace
49 | 
50 | #endif // BLOCKING_QUEUE_H
51 | 
52 | 


--------------------------------------------------------------------------------
/src/kvstore.pro:
--------------------------------------------------------------------------------
 1 | TEMPLATE = app
 2 | CONFIG += console c++11
 3 | CONFIG -= app_bundle
 4 | CONFIG -= qt
 5 | 
 6 | QMAKE_CXXFLAGS += -std=c++11
 7 | QMAKE_CXXFLAGS += -Werror
 8 | QMAKE_CXXFLAGS +=  -Wno-unused-parameter
 9 | QMAKE_CXXFLAGS +=  -Wno-unused-function
10 | QMAKE_CXXFLAGS +=  -Wno-unused-variable
11 | 
12 | 
13 | 
14 | LIBS += -lboost_coroutine
15 | LIBS += -lboost_context
16 | LIBS += -lboost_filesystem
17 | LIBS += -lboost_thread
18 | LIBS += -lboost_system
19 | LIBS += -lpthread
20 | 
21 | 
22 | SOURCES += main.cpp \
23 |     logging/log_recorder.cpp \
24 |     logging/logger.cpp \
25 |     tcp_connection.cpp \
26 |     tcp_server.cpp \
27 |     store_server.cpp \
28 |     kv_database.cpp \
29 |     store_client.cpp \
30 |     cmd_recoder.cpp \
31 |     persistence.cpp \
32 |     recovery.cpp \
33 |     config.cpp
34 | 
35 | HEADERS += \
36 |     logging/blocking_queue.h \
37 |     logging/log_recorder.h \
38 |     logging/logger.h \
39 |     logging/singleton.h \
40 |     tcp_connection.h \
41 |     tcp_server.h \
42 |     store_server.h \
43 |     kv_database.h \
44 |     test/test.h \
45 |     test/dotest.h \
46 |     store_client.h \
47 |     cmd_recoder.h \
48 |     persistence.h \
49 |     utils.h \
50 |     recovery.h \
51 |     cmd_protocol.h \
52 |     conn_data.h \
53 |     config.h \
54 |     test/test_config.h \
55 |     transaction.h \
56 |     test/test_client.h
57 | 
58 | 


--------------------------------------------------------------------------------
/src/tcp_server.h:
--------------------------------------------------------------------------------
 1 | #ifndef TCPSERVER_H
 2 | #define TCPSERVER_H
 3 | #include <boost/asio.hpp>
 4 | #include <boost/array.hpp>
 5 | #include <unistd.h>
 6 | #include <set>
 7 | #include <functional>
 8 | 
 9 | #include "tcp_connection.h"
10 | #include "logging/logger.h"
11 | #include "logging/log_recorder.h"
12 | namespace kvstore {
13 | 
14 | class TcpServer  //nocopyable
15 | {
16 | public:
17 |     typedef std::function<void(TcpConnection::Pointer)> ConnectionCallback;
18 | 
19 | public:
20 |     TcpServer(io_service& ioservice, std::size_t port);
21 |     void set_close_callback(TcpConnection::CloseCallback cb);
22 |     void set_read_callback(TcpConnection::ReadCallback cb);
23 |     void set_new_conn_callback(ConnectionCallback cb);
24 | private:
25 |     void start_accept();
26 |     void handle_accept(TcpConnection::Pointer conn,  const boost::system::error_code &ec);
27 |     void handle_close(TcpConnection::Pointer conn);
28 |     void handle_read(TcpConnection::Pointer conn,  std::size_t bytes_transfered);
29 | 
30 | private:
31 |     TcpServer(const TcpServer&) = delete;
32 |     TcpServer(TcpServer&&) = delete;
33 |     TcpServer& operator=(const TcpServer&) = delete;
34 | 
35 | private:
36 |     boost::asio::ip::tcp::acceptor acceptor_;
37 |     std::set<TcpConnection::Pointer> conns_;
38 |     TcpConnection::CloseCallback close_callback_;
39 |     TcpConnection::ReadCallback read_callback_;
40 |     ConnectionCallback new_conn_callback_;
41 | };
42 | 
43 | 
44 | } // namespace
45 | 
46 | 
47 | 
48 | #endif // TCPSERVER_H
49 | 
50 | 
51 | 
52 | 


--------------------------------------------------------------------------------
/src/kv_database.cpp:
--------------------------------------------------------------------------------
 1 | #include "kv_database.h"
 2 | #include <assert.h>
 3 | #include "logging/logger.h"
 4 | namespace kvstore {
 5 | 
 6 | //const int DEFAULT_DB_ID = 0;
 7 | const int DEFAULT_DB_NUM = 10;
 8 | 
 9 | KVDatabase::KVDatabase() :
10 |     maps_(DEFAULT_DB_NUM)
11 | {
12 | }
13 | 
14 | KVDatabase::KVDatabase(std::size_t num) :
15 |     maps_(num)
16 | {
17 | 
18 | }
19 | 
20 | std::size_t KVDatabase::size() const {
21 |     return maps_.size();
22 | }
23 | 
24 | int KVDatabase::clear(std::size_t id) {
25 |     if (id >= size()) {
26 |         LOG_DEBUG<<"err";
27 |         return -1;
28 |     }
29 |     maps_[id].clear();
30 |     return 0;
31 | }
32 | 
33 | int KVDatabase::put(std::size_t id, std::string key, std::string value) {
34 |     if (id >= size()) {
35 |         LOG_DEBUG<<"err";
36 |         return -1;
37 |     }
38 |     maps_[id][key] = value;
39 |     return 0;
40 | }
41 | 
42 | int KVDatabase::get(std::size_t id, std::string key, std::string &value) const {
43 |     if (id >= size()) {
44 |         LOG_DEBUG<<"err";
45 |         return -2;
46 |     }
47 |     auto iter = maps_[id].find(key);
48 |     if (iter == maps_[id].end()) {
49 |         LOG_DEBUG<<"err";
50 |         return -1;
51 |     }
52 |     value = iter->second;
53 |     return 0;
54 | }
55 | 
56 | int KVDatabase::del(std::size_t id, std::string key) {
57 |     if (id >= size()) {
58 |         LOG_DEBUG<<"err";
59 |         return -2;
60 |     }
61 |     auto iter = maps_[id].find(key);
62 |     if (iter == maps_[id].end()) {
63 |         LOG_DEBUG<<"err";
64 |         return -1;
65 |     }
66 |     maps_[id].erase(iter);
67 |     return 0;
68 | }
69 | 
70 | }//namespace
71 | 
72 | 


--------------------------------------------------------------------------------
/src/tcp_connection.h:
--------------------------------------------------------------------------------
 1 | #ifndef TCP_CONNECTION_H
 2 | #define TCP_CONNECTION_H
 3 | #include <memory>
 4 | #include <boost/asio.hpp>
 5 | #include <boost/array.hpp>
 6 | #include <vector>
 7 | #include <functional>
 8 | #include <string>
 9 | 
10 | namespace kvstore {
11 | 
12 | using namespace boost::asio::ip;
13 | using boost::asio::io_service;
14 | 
15 | class TcpConnection : public std::enable_shared_from_this<TcpConnection>
16 | {
17 | public:
18 |     typedef std::shared_ptr<TcpConnection> Pointer;
19 |     typedef std::weak_ptr<TcpConnection> WeakPointer;
20 |     typedef boost::array<char, 4096> ConnBuffer;
21 |     typedef std::function<void(Pointer)> CloseCallback;
22 |     typedef std::function<void(Pointer, std::size_t)> ReadCallback;
23 | public:
24 |     explicit TcpConnection(io_service& io_service);
25 |     ~TcpConnection();
26 |     ConnBuffer& buf();
27 |     void start();
28 |     static Pointer create(boost::asio::io_service& io_service);
29 |     tcp::socket& socket();
30 |     void set_close_callback(const CloseCallback& cb);
31 |     void set_read_callback(const ReadCallback& cb);
32 |     void send(const std::string& msg);
33 |     void send(const std::vector<char>& msg);
34 |     void shutdown();
35 |     bool connecting() const;
36 | 
37 | private:
38 |     void handle_write(const boost::system::error_code &ec, std::size_t bytes_transfered);
39 |     void handle_read(const boost::system::error_code &ec, std::size_t bytes_transfered);
40 |     void handle_close();
41 | 
42 | private:
43 |     ConnBuffer readbuf_;
44 |     std::string buf_;
45 |     tcp::socket socket_;
46 |     bool is_connecting_;
47 |     CloseCallback close_callback_;
48 |     ReadCallback read_callback_;
49 | };
50 | 
51 | } // namespace
52 | #endif // TCP_CONNECTION_H
53 | 


--------------------------------------------------------------------------------
/src/logging/logger.h:
--------------------------------------------------------------------------------
 1 | #ifndef LOGGER_H
 2 | #define LOGGER_H
 3 | #include <sstream>
 4 | #include <functional>
 5 | namespace logging {
 6 | 
 7 | class Logger {
 8 | public:
 9 |     //用来设置不同的日志级别,从muduo拷贝过来的
10 |     enum LogLevel {
11 |         eTRACE,
12 |         eDEBUG,
13 |         eINFO,
14 |         eWARN,
15 |         eERROR,
16 |         eFATAL,
17 |         eNUM_LOG_LEVELS,//级别个数
18 |     };
19 |     typedef std::function<void(std::string)> OutputCallback;
20 | public:
21 |     Logger(const char* filename, int line, const char* func_name, LogLevel level);
22 |     ~Logger();
23 | 
24 |     std::stringstream& stream();
25 | 
26 |     static LogLevel log_level();
27 |     static void set_level(LogLevel level);
28 |     static void set_output(OutputCallback cb);
29 | 
30 | private:
31 |     std::stringstream sstream_;
32 | 
33 | private:
34 |     static LogLevel level_limit_;
35 |     static OutputCallback output_callback_;
36 | };
37 | 
38 | 
39 | #define LOG_TRACE if (logging::Logger::log_level() <= logging::Logger::eTRACE) \
40 |     logging::Logger(__FILE__, __LINE__, __func__,logging::Logger::eTRACE).stream()
41 | 
42 | #define LOG_DEBUG if (logging::Logger::log_level() <= logging::Logger::eDEBUG) \
43 |     logging::Logger(__FILE__, __LINE__, __func__, logging::Logger::eDEBUG).stream()
44 | 
45 | #define LOG_INFO if (logging::Logger::log_level() <= logging::Logger::eINFO) \
46 |     logging::Logger(__FILE__, __LINE__, __func__, logging::Logger::eINFO).stream()
47 | 
48 | #define LOG_WARN logging::Logger(__FILE__, __LINE__, __func__, logging::Logger::eWARN).stream()
49 | 
50 | #define LOG_ERROR logging::Logger(__FILE__, __LINE__, __func__, logging::Logger::eERROR).stream()
51 | 
52 | #define LOG_FATAL logging::Logger(__FILE__, __LINE__, __func__, logging::Logger::eFATAL).stream()
53 | 
54 | 
55 | 
56 | } // namespace
57 | #endif // LOGGER_H
58 | 


--------------------------------------------------------------------------------
/src/logging/logger.cpp:
--------------------------------------------------------------------------------
 1 | #include "logger.h"
 2 | #include "singleton.h"
 3 | 
 4 | #include <iostream>
 5 | #include <ctime>
 6 | #include <string>
 7 | #include <utility>
 8 | #include <thread>
 9 | 
10 | namespace logging {
11 | 
12 | Logger::LogLevel DEFAULT_LEVEL = Logger::eTRACE;
13 | 
14 | typename Logger::LogLevel Logger::level_limit_ = DEFAULT_LEVEL;
15 | 
16 | typename Logger::OutputCallback Logger::output_callback_ = [](std::string msg){
17 |     std::cout<<msg<<std::endl;
18 | };
19 | 
20 | const char* LEVEL_STRING[] = { "TRACE", "DEBUG", "INFO",
21 |                                "WARN", "ERROR", "FATAL"};
22 | 
23 | std::string get_time_str() {
24 |     std::time_t t;
25 |     std::time(&t);
26 |     std::string str = std::ctime(&t);
27 |     //去掉回车
28 |     str.erase(str.size() - 1, 1);
29 |     return str;
30 | }
31 | 
32 | Logger::Logger(const char *filename, int line,
33 |                const char *func_name, Logger::LogLevel level) {
34 |     sstream_<<"[";
35 |     sstream_<<LEVEL_STRING[level];
36 |     sstream_<<"] ";
37 |     sstream_<<get_time_str() << " ";
38 |   //  sstream_<<"tid:" << std::this_thread::get_id()<<" ";
39 |     sstream_<< filename << " ";
40 |     sstream_<<"(" << line<<") ";
41 |     sstream_<<func_name<<"";
42 |     sstream_<<"：";
43 | }
44 | 
45 | Logger::~Logger() {
46 |     if (output_callback_) {
47 |         std::string str = sstream_.str();
48 |         output_callback_(std::move(str));
49 |     }
50 | }
51 | 
52 | Logger::LogLevel Logger::log_level() {
53 |     return Logger::level_limit_;
54 | }
55 | 
56 | void Logger::set_level(Logger::LogLevel level) {
57 |     Logger::level_limit_ = level;
58 | }
59 | 
60 | void Logger::set_output(OutputCallback cb) {
61 |     Logger::output_callback_ = std::move(cb);
62 | }
63 | 
64 | std::stringstream &Logger::stream() {
65 |     return sstream_;
66 | }
67 | 
68 | 
69 | } // namespace
70 | 
71 | 
72 | 


--------------------------------------------------------------------------------
/src/config.cpp.autosave:
--------------------------------------------------------------------------------
 1 | #include "config.h"
 2 | #include <map>
 3 | #include <fstream>
 4 | #include "logging/logger.h"
 5 | #include "utils.h"
 6 | namespace kvstore {
 7 | 
 8 | static const char* DEFALUT_CONFIG_PATH = "config/config";
 9 | 
10 | 
11 | Config::Config() {
12 |     init(DEFALUT_CONFIG_PATH);
13 | }
14 | 
15 | Config::Config(std::string path) {
16 |     init(path);
17 | }
18 | 
19 | void Config::init(std::string path) {
20 |     int err = parse(path);
21 | }
22 | 
23 | int Config::parse(std::string path) {
24 |     std::ifstream ifs(path);
25 |     if (!ifs) {
26 |         LOG_DEBUG<<"file error.";
27 |         return -1;
28 |     }
29 |     std::map<std::string, std::string> configs;
30 |     std::string line;
31 |     std::string key;
32 |     std::string value;
33 |     while (std::getline(ifs, line)) {
34 |         parse_line(line, key, value);
35 |         configs[key] = value;
36 |     }
37 |     
38 |     std::vector<std::string> cmds {
39 |         "password", "persistence"
40 |     };
41 |     
42 |     for (auto &cmd : cmds) {
43 |         auto iter = configs.find(cmd);
44 |         if (iter)
45 |     }
46 |     return 0;
47 | }
48 | 
49 | 
50 | 
51 | int parse_line(const std::string &line, std::string &key, std::string &value) {
52 |     std::size_t pos = 0;
53 |     pos = line.find(":");
54 |     if (pos == std::string::npos) {
55 |         LOG_DEBUG<<"config parse error";
56 |         return -1;
57 |     }
58 |     key = line.substr(0, pos);
59 |     utils::trim(key);
60 |     ++pos;
61 |     if (pos >= line.length()) {
62 |         LOG_DEBUG<<"config parse error: no value";
63 |         return -2;
64 |     }
65 |     value = line.substr(pos, line.length() - pos);
66 |     utils::trim(value);
67 |     utils::trim_quo(value);
68 |     if (value.empty()) {
69 |         LOG_DEBUG<<"config parse error: no value";
70 |         return -3;
71 |     }
72 |     return 0;
73 | }
74 | } //namespace
75 | 


--------------------------------------------------------------------------------
/src/cmd_recoder.cpp:
--------------------------------------------------------------------------------
 1 | #include "cmd_recoder.h"
 2 | #include <sys/stat.h>
 3 | #include <sys/types.h> //for mkdir
 4 | #include <sstream>
 5 | #include <assert.h>
 6 | #include<stdio.h> //rename
 7 | #include <logging/logger.h>
 8 | #include "utils.h"
 9 | #include "cmd_protocol.h"
10 | namespace kvstore {
11 | 
12 | 
13 | const int DEFAULT_DB_NUM = 10;
14 | 
15 | CmdRecoder::CmdRecoder(std::size_t dbnum) :
16 |     dbnum_(dbnum),
17 |     dbfiles_(dbnum)
18 | {
19 |     init();
20 | }
21 | 
22 | CmdRecoder::CmdRecoder() :
23 |     dbnum_(DEFAULT_DB_NUM),
24 |     dbfiles_(DEFAULT_DB_NUM)
25 | {
26 |     init();
27 | }
28 | 
29 | int CmdRecoder::record(const std::string &cmd, int databaseid) {
30 |     int result = -1;
31 |     assert(static_cast<std::size_t>(databaseid) <dbnum_ );
32 |     if (static_cast<std::size_t>(databaseid) >= dbnum_) {
33 |         return result;
34 |     }
35 |     int req_type = static_cast<int>(cmd[POS_TYPE]);
36 |     switch (req_type) {
37 |     case REQ_TYPE_PUT :
38 |     case REQ_TYPE_DEL:
39 |         dbfiles_[databaseid]<<cmd;
40 |         dbfiles_[databaseid].flush();
41 |         result = 1;
42 |     default:
43 |         result = 0;
44 |     }
45 |     return result;
46 | }
47 | 
48 | 
49 | 
50 | int CmdRecoder::init() {
51 |     int err = mkdir(CMD_SAVE_PATH_FOLDER ,
52 |                          S_IRUSR | S_IWUSR | S_IXUSR | S_IRWXG | S_IRWXO);
53 |     if (err != 0) {
54 |         //LOG_INFO<<"文件夹创建失败";
55 |         //return isCreate;
56 |     }
57 | 
58 |     //创建文件
59 |     std::string filename;
60 |     for (int i = 0; i < static_cast<int>(dbnum_); ++i) {
61 |         filename = CMD_SAVE_PATH_FOLDER;
62 |         filename = filename + "/db" + utils::to_string(i) + ".kvdb";
63 |         dbfiles_[i].open(filename, std::ios::app |  std::ios::binary);
64 |         if (!dbfiles_[i]) {
65 |             LOG_DEBUG<<"第"<<i<<"个文件创建失败";
66 |             continue;
67 |         }
68 |     }
69 | 
70 |     return err;
71 | }
72 | 
73 | } //namespace
74 | 
75 | 


--------------------------------------------------------------------------------
/src/store_server.h:
--------------------------------------------------------------------------------
 1 | #ifndef STORESERVER_H
 2 | #define STORESERVER_H
 3 | #include <unordered_map>
 4 | #include <map>
 5 | #include "tcp_server.h"
 6 | #include "cmd_recoder.h"
 7 | #include "persistence.h"
 8 | #include "conn_data.h"
 9 | #include "config.h"
10 | namespace kvstore {
11 | 
12 | class StoreServer {
13 |     friend class Recovery;
14 | public:
15 |     StoreServer(io_service& ioservice, std::size_t port);
16 | public:
17 |     int execute_db_cmd(const std::string& cmd, std::size_t db, std::string& retmsg);
18 |     void init();
19 | private:
20 |     void handle_close(TcpConnection::Pointer conn);
21 |     void handle_read(TcpConnection::Pointer conn, std::size_t bytes_transfered);
22 |     void handle_new_conn(TcpConnection::Pointer conn);
23 |     int dispath_cmd(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
24 |     int execute_cmd_put(const std::string& cmd, std::size_t db, std::string& retmsg);
25 |     int execute_cmd_get(const std::string& cmd, std::size_t db, std::string& retmsg);
26 |     int execute_cmd_del(const std::string& cmd, std::size_t db, std::string& retmsg);
27 |     int execute_cmd_use(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
28 |     int execute_cmd_login(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
29 |     int execute_cmd_mult(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
30 |     int execute_cmd_exec(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
31 |     int add_transaction(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
32 |     int execute_cmd_discard(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
33 |     int execute_cmd_watch(const std::string& cmd, TcpConnection::Pointer conn,std::string& retmsg);
34 |     KVDatabase& db();
35 | private:
36 | 
37 | private:
38 |     TcpServer tcp_server_;
39 |     std::map<TcpConnection::Pointer, ConnData> conns_;
40 |     KVDatabase dbs_;
41 |     Config  config_;
42 |     Persistence persistence_;
43 | };
44 | 
45 | }//namespace
46 | #endif // STORESERVER_H
47 | 
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/src/tcp_server.cpp:
--------------------------------------------------------------------------------
 1 | #include "tcp_server.h"
 2 | 
 3 | #include <functional>
 4 | #include <utility>
 5 | 
 6 | #include "logging/logger.h"
 7 | 
 8 | namespace kvstore {
 9 | 
10 | TcpServer::TcpServer(io_service &ioservice, size_t port) :
11 |     acceptor_(ioservice, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
12 |     conns_()
13 | {
14 |     start_accept();
15 | }
16 | 
17 | 
18 | void TcpServer::start_accept() {
19 |     TcpConnection::Pointer conn = TcpConnection::create(acceptor_.get_io_service());
20 |     acceptor_.async_accept(conn->socket(), std::bind(
21 |                                &TcpServer::handle_accept, this, conn, std::placeholders::_1));
22 | }
23 | 
24 | void TcpServer::handle_accept(TcpConnection::Pointer conn,  const boost::system::error_code &ec) {
25 |     if (!ec) {
26 |         conns_.insert(conn);
27 |         conn->set_close_callback(
28 |                     std::bind(&TcpServer::handle_close, this, std::placeholders::_1));
29 |         conn->set_read_callback(
30 |                     std::bind(&TcpServer::handle_read, this,  std::placeholders::_1, std::placeholders::_2));
31 |         conn->start();
32 |         if (new_conn_callback_) {
33 |             new_conn_callback_(conn);
34 |         }
35 |     } else {
36 |         LOG_ERROR<<ec.message();
37 |     }
38 |     start_accept();
39 | }
40 | 
41 | void TcpServer::handle_close(TcpConnection::Pointer conn) {
42 |     auto iter = conns_.find(conn);
43 |     assert(iter != conns_.end());
44 |     conns_.erase(iter);
45 |     if (close_callback_) {
46 |         close_callback_(conn);
47 |     }
48 | }
49 | 
50 | void TcpServer::handle_read(TcpConnection::Pointer conn, std::size_t bytes) {
51 |     if (read_callback_) {
52 |         read_callback_(conn, bytes);
53 |     }
54 | }
55 | 
56 | void TcpServer::set_close_callback(TcpConnection::CloseCallback cb) {
57 |     close_callback_ = std::move(cb);
58 | }
59 | 
60 | void TcpServer::set_read_callback(TcpConnection::ReadCallback cb) {
61 |     read_callback_ = std::move(cb);
62 | }
63 | 
64 | void TcpServer::set_new_conn_callback(TcpServer::ConnectionCallback cb) {
65 |     new_conn_callback_ = cb;
66 | }
67 | 
68 | 
69 | } //namespace
70 | 


--------------------------------------------------------------------------------
/src/config.cpp:
--------------------------------------------------------------------------------
 1 | #include "config.h"
 2 | #include <map>
 3 | #include <fstream>
 4 | #include "logging/logger.h"
 5 | #include "utils.h"
 6 | namespace kvstore {
 7 | 
 8 | static const char* DEFALUT_CONFIG_PATH = "config/config";
 9 | 
10 | 
11 | Config::Config() : info_() {
12 |     init(DEFALUT_CONFIG_PATH);
13 | }
14 | 
15 | Config::Config(const std::string& path) : info_() {
16 |     init(path);
17 | }
18 | 
19 | void Config::init(const std::string& path) {
20 |     int err = parse(path);
21 | }
22 | 
23 | int Config::parse(const std::string& path) {
24 |     std::ifstream ifs(path);
25 |     if (!ifs) {
26 |         LOG_DEBUG<<"file error.";
27 |         return -1;
28 |     }
29 |     std::map<std::string, std::string> configs;
30 |     std::string line;
31 |     std::string key;
32 |     std::string value;
33 |     while (std::getline(ifs, line)) {
34 |         parse_line(line, key, value);
35 |         configs[key] = value;
36 |     }
37 | 
38 |     for (auto &pair : configs) {
39 |         if (pair.first == "password") {
40 |             LOG_INFO<<"启用密码保护，密码为" <<pair.second;
41 |             process_password(pair.second);
42 |         } else if (pair.first == "persistence") {
43 |             process_persistence(pair.second);
44 |         }
45 |     }
46 |     return 0;
47 | }
48 | 
49 | 
50 | void Config::process_persistence(const std::string &value) {
51 |     if (value == "on") {
52 |         info_.persistence = true;
53 |         LOG_INFO<<"启用持久化";
54 |     } else {
55 |         info_.persistence = false;
56 |     }
57 | }
58 | 
59 | void Config::process_password(const std::string &value) {
60 |     info_.need_password = true;
61 |     info_.password = value;
62 | }
63 | 
64 | int parse_line(const std::string &line, std::string &key, std::string &value) {
65 |     std::size_t pos = 0;
66 |     pos = line.find(":");
67 |     if (pos == std::string::npos) {
68 |         LOG_DEBUG<<"config parse error, line:" <<line;
69 |         return -1;
70 |     }
71 |     key = line.substr(0, pos);
72 |     utils::trim(key);
73 |     ++pos;
74 |     if (pos >= line.length()) {
75 |         LOG_DEBUG<<"config parse error: no value";
76 |         return -2;
77 |     }
78 |     value = line.substr(pos, line.length() - pos);
79 |     utils::trim(value);
80 |     utils::trim_quo(value);
81 |     if (value.empty()) {
82 |         LOG_DEBUG<<"config parse error: no value";
83 |         return -3;
84 |     }
85 |     return 0;
86 | }
87 | } //namespace
88 | 


--------------------------------------------------------------------------------
/src/recovery.cpp:
--------------------------------------------------------------------------------
 1 | #include "recovery.h"
 2 | #include <vector>
 3 | #include <boost/asio.hpp>
 4 | #include <fstream>
 5 | #include "utils.h"
 6 | #include "cmd_protocol.h"
 7 | #include "logging/logger.h"
 8 | #include "store_server.h"
 9 | namespace kvstore {
10 | Recovery::Recovery()
11 | {
12 | }
13 | 
14 | int Recovery::recover(StoreServer &server) {
15 |     std::vector<std::string> cmds;
16 |     std::string filename = CMD_SAVE_PATH_FOLDER;
17 |      int err = 0;
18 |     for (std::size_t i = 0; i < server.db().size(); ++i) {
19 |         filename = CMD_SAVE_PATH_FOLDER;
20 |         filename = filename + "/db" + utils::to_string(i) + ".kvdb";
21 |         cmds.clear();
22 |         err = read_file(filename, cmds);
23 |         if (err < 0) {
24 |             LOG_DEBUG<<"read_file error,filename:" << filename;
25 |             continue;
26 |         }
27 |         //执行命令
28 |         err = execute_cmds(server, i, cmds);
29 |         if (err < 0) {
30 |             //命令有一条执行失败，就清空那一整个数据库
31 |             LOG_DEBUG<<"cmd syntax error";
32 |             server.db().clear(i);
33 |             continue;
34 |         }
35 |     }
36 |     return 0;
37 | }
38 | 
39 | int Recovery::execute_cmds(StoreServer &server, std::size_t db,const std::vector<std::string> &cmds) {
40 |     std::string msg;
41 |     int err;
42 |     for (std::size_t i = 0; i < cmds.size(); ++i) {
43 |         err = server.execute_db_cmd(cmds[i], db, msg);
44 |         if (err < 0) {
45 |             LOG_ERROR<<"第"<<i<<"个db文件命令错误";
46 |             return err;
47 |         }
48 |     }
49 |     return err;
50 | }
51 | 
52 | int Recovery::read_file(const std::string& filename, std::vector<std::string>& cmds) {
53 |     std::ifstream ifs;
54 |     std::string line;
55 |     std::string cmdbuf;
56 |     ifs.open(filename, std::ios::binary);
57 |     if (!ifs) {
58 |         LOG_DEBUG<<"file error";
59 |         return -2;
60 |     }
61 |     while (!cmdbuf.empty() || std::getline(ifs, line)) {
62 |         cmdbuf.append(line);
63 |         line = "";
64 |         if (cmdbuf.length() <= 3) {
65 |             if (!ifs) {
66 |                 LOG_DEBUG<<"cmd syntax error";
67 |                 return -1;
68 |             }
69 |             continue;
70 |         }
71 |         unsigned short len = *((unsigned short*) (cmdbuf.data() + POS_TOTAL_LENGTH));
72 |         len = boost::asio::detail::socket_ops::network_to_host_short(len);
73 |         if (cmdbuf.length() < len) {
74 |             if (!ifs) {
75 |                 LOG_DEBUG<<"cmd syntax error";
76 |                 return -1;
77 |             }
78 |             continue;
79 |         }
80 |         cmds.push_back( cmdbuf.substr(0, len));
81 |         cmdbuf.erase(0, len);
82 |     }
83 |     return 0;
84 | }
85 | 
86 | 
87 | } //namespace
88 | 


--------------------------------------------------------------------------------
/src/tcp_connection.cpp:
--------------------------------------------------------------------------------
 1 | #include "tcp_connection.h"
 2 | 
 3 | #include <functional>
 4 | 
 5 | #include "logging/logger.h"
 6 | namespace kvstore {
 7 | 
 8 | TcpConnection::TcpConnection(io_service &io_service) :
 9 |     readbuf_(),
10 |     buf_(),
11 |     socket_(io_service),
12 |     is_connecting_(false)
13 | {
14 | }
15 | 
16 | TcpConnection::~TcpConnection() {
17 |     LOG_DEBUG<<"~TcpConnection";
18 | }
19 | 
20 | TcpConnection::ConnBuffer &TcpConnection::buf() {
21 |     return readbuf_;
22 | }
23 | 
24 | void TcpConnection::start() {
25 |     is_connecting_ = true;
26 |     socket_.async_read_some(boost::asio::buffer(readbuf_), std::bind(
27 |                                 &TcpConnection::handle_read, this, std::placeholders::_1, std::placeholders::_2));
28 | }
29 | 
30 | TcpConnection::Pointer TcpConnection::create(io_service &io_service) {
31 |     return std::make_shared<TcpConnection>(io_service);
32 | }
33 | 
34 | tcp::socket &TcpConnection::socket() {
35 |     return socket_;
36 | }
37 | 
38 | void TcpConnection::set_close_callback(const TcpConnection::CloseCallback &cb) {
39 |     close_callback_ = cb;
40 | }
41 | 
42 | void TcpConnection::set_read_callback(const TcpConnection::ReadCallback &cb) {
43 |     read_callback_ = cb;
44 | }
45 | 
46 | void TcpConnection::send(const std::string &msg) {
47 |     boost::asio::async_write(socket_, boost::asio::buffer(msg), std::bind(
48 |                                  &TcpConnection::handle_write, this, std::placeholders::_1, std::placeholders::_2));
49 | }
50 | 
51 | void TcpConnection::send(const std::vector<char> &msg) {
52 |     boost::asio::async_write(socket_, boost::asio::buffer(msg), std::bind(
53 |                                  &TcpConnection::handle_write, this, std::placeholders::_1, std::placeholders::_2));
54 | }
55 | 
56 | void TcpConnection::shutdown() {
57 |     handle_close();
58 | }
59 | 
60 | bool TcpConnection::connecting() const {
61 |     return is_connecting_;
62 | }
63 | 
64 | void TcpConnection::handle_write(const boost::system::error_code &ec, std::size_t bytes_transfered)
65 | {}
66 | 
67 | void TcpConnection::handle_read(const boost::system::error_code &ec, std::size_t bytes_transfered) {
68 |     if (!ec) {
69 |         if(read_callback_) {
70 |             read_callback_(shared_from_this(), bytes_transfered);
71 |         }
72 |         socket_.async_read_some(boost::asio::buffer(readbuf_), std::bind(
73 |                                     &TcpConnection::handle_read, this, std::placeholders::_1,  std::placeholders::_2));
74 |     } else {
75 | 
76 |         if (ec.value() == boost::asio::error::eof) {// EOF
77 |             handle_close();
78 |         } else {
79 |              LOG_DEBUG<<ec.message();
80 |         }
81 |     }
82 | }
83 | 
84 | void TcpConnection::handle_close() {
85 |     is_connecting_ = false;
86 |     if (close_callback_) {
87 |         close_callback_(shared_from_this());
88 |     }
89 | }
90 | 
91 | } // namespace
92 | 
93 | 


--------------------------------------------------------------------------------
/src/test/test_config.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONFIG2_H
 2 | #define CONFIG2_H
 3 | #include "test.h"
 4 | #include "../config.h"
 5 | namespace test {
 6 | 
 7 | static void test_config() {
 8 |     std::string line;
 9 |     std::string key;
10 |     std::string value;
11 |     int err = 0;
12 |     line = "key1:value1";
13 |     err = kvstore::parse_line(line, key, value);
14 |     DEBUG_INFO<<"line:"<<line;
15 |     EXCEPT_FALSE(err < 0);
16 |     EXCEPT_EQ(key, "key1");
17 |     EXCEPT_EQ(value, "value1");
18 | 
19 |     line = "key1 : value1";
20 |     err = kvstore::parse_line(line, key, value);
21 |     DEBUG_INFO<<"line:"<<line;
22 |     EXCEPT_FALSE(err < 0);
23 |     EXCEPT_EQ(key, "key1");
24 |     EXCEPT_EQ(value, "value1");
25 | 
26 |     line = "    key1 : value1   ";
27 |     err = kvstore::parse_line(line, key, value);
28 |     DEBUG_INFO<<"line:"<<line;
29 |     EXCEPT_FALSE(err < 0);
30 |     EXCEPT_EQ(key, "key1");
31 |     EXCEPT_EQ(value, "value1");
32 | 
33 |     line = "    key1    : value1   ";
34 |     err = kvstore::parse_line(line, key, value);
35 |     DEBUG_INFO<<"line:"<<line;
36 |     EXCEPT_FALSE(err < 0);
37 |     EXCEPT_EQ(key, "key1");
38 |     EXCEPT_EQ(value, "value1");
39 | 
40 | 
41 |     line = "    key1    : \"value1\"   ";
42 |     err = kvstore::parse_line(line, key, value);
43 |     DEBUG_INFO<<"line:"<<line;
44 |     EXCEPT_FALSE(err < 0);
45 |     EXCEPT_EQ(key, "key1");
46 |     EXCEPT_EQ(value, "value1");
47 | 
48 | 
49 |     // key1  :   "value" "     //多一个”也会被清理
50 |     line = "    key1    : \"value1\"\"   ";
51 |     err = kvstore::parse_line(line, key, value);
52 |     DEBUG_INFO<<"line:"<<line;
53 |     EXCEPT_FALSE(err < 0);
54 |     EXCEPT_EQ(key, "key1");
55 |     EXCEPT_EQ(value, "value1");
56 | 
57 |     // key1  :   " value  " "     //多一个”也会被清理
58 |     line = "    key1    : \" value1  \"\"   ";
59 |     err = kvstore::parse_line(line, key, value);
60 |     DEBUG_INFO<<"line:"<<line;
61 |     EXCEPT_FALSE(err < 0);
62 |     EXCEPT_EQ(key, "key1");
63 |     EXCEPT_NE(value, "value1");
64 |     EXCEPT_EQ(value, " value1  ");
65 |    // EXCEPT_EQ();
66 | 
67 |     line = "key value";
68 |     err = kvstore::parse_line(line, key, value);
69 |     DEBUG_INFO<<"line:"<<line;
70 |     EXCEPT_TRUE(err < 0);
71 | 
72 |     line = "key value:";
73 |     err = kvstore::parse_line(line, key, value);
74 |     DEBUG_INFO<<"line:"<<line;
75 |     EXCEPT_TRUE(err < 0);
76 | 
77 |     line = "key value:      ";
78 |     err = kvstore::parse_line(line, key, value);
79 |     DEBUG_INFO<<"line:"<<line;
80 |     EXCEPT_TRUE(err < 0);
81 | 
82 |     line = "key:   \"\"   ";
83 |     err = kvstore::parse_line(line, key, value);
84 |     DEBUG_INFO<<"line:"<<line;
85 |     EXCEPT_TRUE(err < 0);
86 | 
87 |     line = "key:   \"\"   ";
88 |     err = kvstore::parse_line(line, key, value);
89 |     DEBUG_INFO<<"line:"<<line;
90 |     EXCEPT_TRUE(err < 0);
91 | }
92 | 
93 | } //namespace
94 | 
95 | #endif // CONFIG2_H
96 | 
97 | 


--------------------------------------------------------------------------------
/src/store_client.cpp:
--------------------------------------------------------------------------------
 1 | #include "store_client.h"
 2 | #include "cmd_protocol.h"
 3 | namespace kvstore{
 4 | 
 5 | StoreClient::StoreClient(boost::asio::io_service& ioservice) :
 6 |     ioservice_(ioservice),
 7 |     socket_(ioservice)
 8 | {
 9 | 
10 | }
11 | 
12 | void StoreClient::connect(const std::string& addr,const std::string&  port) {
13 |     //boost::system::error_code error;
14 |     boost::asio::ip::tcp::resolver resolver(ioservice_);
15 |     LOG_INFO<<"正在尝试连接"<<addr<<":"<<port;
16 |     boost::asio::ip::tcp::resolver::query query(addr, port);
17 |     boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
18 |     boost::asio::connect(socket_, endpoint_iterator);
19 | }
20 | 
21 | static StoreClient::Result recv_response(boost::asio::ip::tcp::socket& socket) {
22 |     std::vector<char> buffer(3);
23 |     size_t reply_length = boost::asio::read(socket,boost::asio::buffer(buffer));
24 |     std::string response(buffer.data(), reply_length);
25 |     unsigned short s = *((unsigned short*) (response.data() + POS_TOTAL_LENGTH));
26 |     s = boost::asio::detail::socket_ops::network_to_host_short(s);
27 |     if (s <= 2) {
28 |         return std::make_pair(-1,"");
29 |     }
30 |     if (s == 1 + 2) {
31 |         return std::make_pair(response[POS_TYPE],"");
32 |     }
33 |     std::vector<char> buffer2(s - 1 - 2);
34 |     reply_length = boost::asio::read(socket,boost::asio::buffer(buffer2));
35 |     std::string retmsg{buffer2.data(), reply_length};
36 |     return std::make_pair(response[POS_TYPE], std::move(retmsg));
37 | }
38 | 
39 | StoreClient::Result StoreClient::use(std::size_t db) {
40 |     std::string msg = get_use_request(db);
41 |     boost::asio::write(socket_, boost::asio::buffer(msg));
42 |    return recv_response(socket_);
43 | }
44 | 
45 | StoreClient::Result StoreClient::put(const std::string& key, const std::string& value) {
46 |     std::string msg = get_put_request(std::move(key), std::move(value));
47 |     boost::asio::write(socket_, boost::asio::buffer(msg));
48 |     return recv_response(socket_);
49 | }
50 | 
51 | StoreClient::Result StoreClient::get(const std::string& key) {
52 |     std::string msg = get_get_request(key);
53 |     boost::asio::write(socket_, boost::asio::buffer(msg));
54 |     return recv_response(socket_);
55 | }
56 | 
57 | StoreClient::Result StoreClient::del(const std::string& key) {
58 |     std::string msg = get_del_request(key);
59 |     boost::asio::write(socket_, boost::asio::buffer(msg));
60 |     return recv_response(socket_);
61 | }
62 | 
63 | StoreClient::Result StoreClient::login(const std::string& password) {
64 |     std::string msg = get_login_request(password);
65 |     boost::asio::write(socket_, boost::asio::buffer(msg));
66 |     return recv_response(socket_);
67 | }
68 | 
69 | StoreClient::Result StoreClient::mult() {
70 |     std::string msg = get_mult_request();
71 |     boost::asio::write(socket_, boost::asio::buffer(msg));
72 |     return recv_response(socket_);
73 | }
74 | 
75 | StoreClient::Result StoreClient::exec() {
76 |     std::string msg = get_exec_request();
77 |     boost::asio::write(socket_, boost::asio::buffer(msg));
78 |     return recv_response(socket_);
79 | }
80 | 
81 | StoreClient::Result StoreClient::discard() {
82 |     std::string msg = get_discard_request();
83 |     boost::asio::write(socket_, boost::asio::buffer(msg));
84 |     return recv_response(socket_);
85 | }
86 | 
87 | StoreClient::Result StoreClient::watch(const std::string& key)
88 | {
89 |     auto msg = get_watch_request(key);
90 |     boost::asio::write(socket_, boost::asio::buffer(msg));
91 |     return recv_response(socket_);
92 | }
93 | 
94 | 
95 | }//namespace
96 | 


--------------------------------------------------------------------------------
/src/logging/log_recorder.cpp:
--------------------------------------------------------------------------------
  1 | #include "log_recorder.h"
  2 | #include <iostream>
  3 | #include <fstream>
  4 | #include <sys/stat.h>
  5 | #include <sys/types.h> //for mkdir
  6 | #include <thread>
  7 | #include <sstream>
  8 | #include<stdio.h> //rename
  9 | #include <unistd.h>
 10 | #include <vector>
 11 | 
 12 | #include "singleton.h"
 13 | namespace logging{
 14 | 
 15 | const char* LOG_PATH_FOLDER = "log";
 16 | const int MAX_LOG_FILES_NUM  = 10;
 17 | const int MAX_LOG_FILE_SIZE = 1024 * 10;
 18 | 
 19 | LogRecorder::LogRecorder():
 20 |     queue_(),
 21 |     quit_(false)
 22 | {
 23 |     create_dir_and_files();
 24 |     std::thread t(std::bind(&LogRecorder::customer_thread_function, this));
 25 |     t.detach();
 26 | }
 27 | 
 28 | void LogRecorder::submit(std::string msg) {
 29 |     queue_.push(msg);
 30 | }
 31 | 
 32 | Logger::OutputCallback LogRecorder::callback() {
 33 |     return [](std::string msg) {
 34 |         Singleton<LogRecorder>::get_instance().submit(msg);
 35 |     };
 36 | }
 37 | 
 38 | template<class T>
 39 | int to_int(const T& value) {
 40 |     std::stringstream ss;
 41 |     ss << value;
 42 |     int i = 0;
 43 |     ss >> i;
 44 |     return i;
 45 | }
 46 | 
 47 | template<class T>
 48 | std::string to_string(const T& value) {
 49 |     std::stringstream ss;
 50 |     ss << value;
 51 |     std::string str;
 52 |     ss >> str;
 53 |     return str;
 54 | }
 55 | 
 56 | int get_filesize(const std::string& path) {
 57 |     struct stat buf;
 58 |     if (stat(path.c_str(), &buf) < 0) {
 59 |         //printf("Mesg: %s\n", strerror(errno));
 60 |         return -1;
 61 |     }
 62 |     //    printf("%s's size      is %-4d      bytes\n", path.c_str(), buf.st_size);
 63 |     //    printf("%s's t_blksize is %-4d bytes\n", path.c_str(),      buf.st_blksize);
 64 |     //    printf("%s's blocks    is %-4d blocks\n",      path.c_str(), buf.st_blocks);
 65 |     return buf.st_size;
 66 | }
 67 | 
 68 | void LogRecorder::create_dir_and_files() {
 69 |     int isCreate = mkdir(LOG_PATH_FOLDER ,
 70 |                          S_IRUSR | S_IWUSR | S_IXUSR | S_IRWXG | S_IRWXO);
 71 |     if (isCreate != 0) {
 72 |         //std::cout<<"创建文件夹失败"<<std::endl;
 73 |         return;
 74 |     }
 75 |     std::string filename = LOG_PATH_FOLDER;
 76 |     if (std::ifstream(filename + "/log0.txt")) {
 77 |         //std::cout<<"已存在文件，不用新创建"<<std::endl;
 78 |         return;
 79 |     }
 80 |     //创建好几个文件，log0.txt log1.txt log2.txt log3.txt .....
 81 |     for (int i = 0; i < MAX_LOG_FILES_NUM; ++i) {
 82 |         filename = LOG_PATH_FOLDER;
 83 |         filename = filename + "/log" + to_string(i) + ".txt";
 84 |         std::ofstream ofs(filename, std::ios::app);
 85 |         if (!ofs) continue;
 86 |         ofs<<"log"<<std::endl;
 87 |     }
 88 | }
 89 | 
 90 | void LogRecorder::customer_thread_function() {
 91 |     while (!quit_) {
 92 |         std::string log_msg = queue_.pop();
 93 |         std::string filename = LOG_PATH_FOLDER + std::string("/log0.txt");
 94 |         if (get_filesize(filename) >= MAX_LOG_FILE_SIZE) {
 95 |             adjust_filename();
 96 |         }
 97 |         std::ofstream ofs(filename, std::ios::app);
 98 |         if (ofs) {
 99 |             std::cout<<log_msg<<std::endl;
100 |             ofs << log_msg << std::endl;
101 |         } else {
102 |            // std::cout<<filename<<"写入失败"<<std::endl;
103 |         }
104 |     }//while
105 | }
106 | 
107 | void LogRecorder::adjust_filename() {
108 |     if (MAX_LOG_FILES_NUM < 2) {
109 |         throw;
110 |     }
111 |     std::string filename;
112 |     std::vector<std::string> filenames;
113 |     filenames.reserve(MAX_LOG_FILES_NUM);
114 |     for (int i = 0; i < MAX_LOG_FILES_NUM; ++i) {
115 |         filename = LOG_PATH_FOLDER + std::string("/log") + to_string(i) + ".txt";
116 |         filenames.push_back(filename);
117 |     }
118 | 
119 |     if (remove(filename.c_str()) != 0) {
120 |        // std::cout<<"删除文件失败："<<filename<<std::endl;
121 |     }
122 | 
123 |     for (int i = MAX_LOG_FILES_NUM - 2; i >= 0; --i) {
124 |         if (rename(filenames[i].c_str(), filenames[i + 1].c_str()) != 0) {  //oldname, newname
125 |             //std::cout<<"修改文件名失败："<<filenames[i]<<","<<filenames[i + 1]<<std::endl;
126 |         }
127 |     }
128 | }
129 | 
130 | 
131 | }
132 | 
133 | 


--------------------------------------------------------------------------------
/src/test/test.h:
--------------------------------------------------------------------------------
 1 | #ifndef TEST_H
 2 | #define TEST_H
 3 | #include <iostream>
 4 | #include <sstream>
 5 | namespace test {
 6 | 
 7 | class SimpleDebugPrinter {
 8 | public:
 9 |     SimpleDebugPrinter() :ss_() { }
10 |     ~SimpleDebugPrinter() { std::cout<<ss_.str()<<std::endl; }
11 |     std::stringstream& stream() {return ss_;}
12 | private:
13 |       std::stringstream ss_;
14 | };
15 | 
16 | #define DEBUG_INFO SimpleDebugPrinter().stream()<<"[DEBUG_INFO]"
17 | 
18 | #define PRINT_RESULT(x)                              \
19 |     do {                                                              \
20 |         if (x) {                                                       \
21 |             std::cout<<"【OK】";                         \
22 |         } else {                                                      \
23 |              std::cout<<"【FAILED】";                  \
24 |         }                                                                 \
25 |     } while (0)
26 | 
27 | #define EXIT_IF_FALSE(x)                              \
28 |     do {                                                              \
29 |         if (!(x)) {                                                    \
30 |               exit(0);                                               \
31 |         }                                                               \
32 |     } while (0)
33 | 
34 | #define STR(s)  #s
35 | 
36 | #define PRINT_INFO()                                   \
37 |     do {                                                              \
38 |         std::cout<<"In "<<__FILE__<<","<< __func__ <<"("<<__LINE__<<"):"; \
39 |     }while(0) \
40 | 
41 | 
42 | #define EXCEPT_TRUE(x)                                                                   \
43 |     do {                                                                                                  \
44 |         PRINT_RESULT(x);                                                                        \
45 |         PRINT_INFO();                                                                               \
46 |          std::cout<<"statement is '" << STR(x) << "'";                          \
47 |         std::cout<<", except true" << std::endl;                                  \
48 |         EXIT_IF_FALSE((x));                                                                    \
49 |     }while(0)
50 | 
51 | #define EXCEPT_FALSE(x)                                                                   \
52 |     do {                                                                                                    \
53 |         PRINT_RESULT(!(x));                                                                         \
54 |         PRINT_INFO();                                                                               \
55 |         std::cout<<"statement is '" << STR(x) << "'";                             \
56 |         std::cout<<", except false"<<std::endl;                                      \
57 |         EXIT_IF_FALSE(!(x));                                                                      \
58 |     }while(0)
59 | 
60 | #define EXCEPT_EQ(a, b)                                                                   \
61 |     do {                                                                                                  \
62 |         PRINT_RESULT((a) == (b));                                                         \
63 |         PRINT_INFO();                                                                             \
64 |         std::cout<<"except '" << STR(a) <<" == " <<STR(b) ;               \
65 |         std::cout<<"'"<<std::endl;                                                          \
66 |         EXIT_IF_FALSE((a) == (b));                                                           \
67 |     }while(0)
68 | 
69 | #define EXCEPT_NE(a, b)                                                                   \
70 |     do {                                                                                                  \
71 |         PRINT_RESULT((a) != (b));                                                          \
72 |         PRINT_INFO();                                                                             \
73 |         std::cout<<"except '" << STR(a) <<" != " <<STR(b) ;                \
74 |         std::cout<<"'"<<std::endl;                                                         \
75 |         EXIT_IF_FALSE((a) != (b));                                                                      \
76 |     }while(0)
77 | } //namespace
78 | #endif // TEST_H
79 | 
80 | 


--------------------------------------------------------------------------------
/src/test/test_client.h:
--------------------------------------------------------------------------------
  1 | #ifndef TEST_CLIENT
  2 | #define TEST_CLIENT
  3 | #include "test.h"
  4 | #include <thread>
  5 | #include "../store_client.h"
  6 | #include "../cmd_protocol.h"
  7 | using namespace kvstore;
  8 | namespace test {
  9 | static void test_client_transaction() {
 10 |     std::thread t([&](){
 11 |         boost::asio::io_service ioservice2;
 12 |         ioservice2.run();
 13 |         StoreClient client(ioservice2);
 14 |         client.connect("127.0.0.1", "23333");
 15 |         StoreClient::Result result;
 16 |         result = client.use(2);
 17 |         DEBUG_INFO<<"result:"<<result.second;
 18 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 19 |         result = client.put("123", "456");
 20 |         DEBUG_INFO<<"result:"<<result.second;
 21 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 22 |         result = client.get("123");
 23 |         DEBUG_INFO<<"result:"<<result.second;
 24 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 25 |         result = client.mult();
 26 |         DEBUG_INFO<<"result:"<<result.second;
 27 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 28 |         result = client.put("333", "333");
 29 |         DEBUG_INFO<<"result:"<<result.second;
 30 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 31 |         result = client.put("444", "444");
 32 |         DEBUG_INFO<<"result:"<<result.second;
 33 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 34 |         result = client.put("555", "555");
 35 |         DEBUG_INFO<<"result:"<<result.second;
 36 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 37 |         result = client.exec();
 38 |         DEBUG_INFO<<"result:"<<result.second;
 39 |         result = client.get("333");
 40 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 41 |         EXCEPT_EQ(result.second, "333");
 42 |         result = client.get("444");
 43 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 44 |         EXCEPT_EQ(result.second, "444");
 45 |         result = client.get("555");
 46 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 47 |         EXCEPT_EQ(result.second, "555");
 48 | 
 49 |        // client.del("123");
 50 |        // client.get("123");
 51 |     });
 52 |     t.detach();
 53 | }
 54 | 
 55 | static void test_client_transaction2() {
 56 |     std::thread t([&](){
 57 |         boost::asio::io_service ioservice2;
 58 |         ioservice2.run();
 59 |         StoreClient client(ioservice2);
 60 |         client.connect("127.0.0.1", "23333");
 61 |         StoreClient::Result result;
 62 |         result = client.use(2);
 63 |         DEBUG_INFO<<"result:"<<result.second;
 64 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 65 | 
 66 |         result = client.put("123", "456");
 67 |         DEBUG_INFO<<"result:"<<result.second;
 68 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 69 | 
 70 |         result = client.get("123");
 71 |         DEBUG_INFO<<"result:"<<result.second;
 72 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 73 | 
 74 |         result = client.mult();
 75 |         DEBUG_INFO<<"result:"<<result.second;
 76 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 77 | 
 78 |         result = client.mult();
 79 |         DEBUG_INFO<<"result:"<<result.second;
 80 |         EXCEPT_EQ(result.first, RESP_TYPE_ERR);
 81 | 
 82 |         result = client.use(3);
 83 |         DEBUG_INFO<<"result:"<<result.second;
 84 |         EXCEPT_EQ(result.first, RESP_TYPE_ERR);
 85 | 
 86 |         result = client.put("555", "555");
 87 |         DEBUG_INFO<<"result:"<<result.second;
 88 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 89 | 
 90 |         result = client.exec();
 91 |         DEBUG_INFO<<"result:"<<result.second;
 92 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 93 | 
 94 |         result = client.get("555");
 95 |         DEBUG_INFO<<"result:"<<result.second;
 96 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
 97 |         EXCEPT_EQ(result.second, "555");
 98 | 
 99 |         result = client.del("555");
100 |         DEBUG_INFO<<"result:"<<result.second;
101 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
102 | 
103 |         result = client.get("555");
104 |         DEBUG_INFO<<"result:"<<result.second;
105 |         EXCEPT_EQ(result.first, RESP_TYPE_ERR);
106 |         EXCEPT_EQ(result.second, "null");
107 | 
108 |         result = client.del("555");
109 |         DEBUG_INFO<<"result:"<<result.second;
110 |         EXCEPT_EQ(result.first, RESP_TYPE_ERR);
111 |         EXCEPT_EQ(result.second, "null");
112 |        // client.del("123");
113 |        // client.get("123");
114 |     });
115 |     t.detach();
116 | }
117 | 
118 | static void test_client_transaction3() {
119 |     std::thread t([&](){
120 |         boost::asio::io_service ioservice2;
121 |         ioservice2.run();
122 |         StoreClient client(ioservice2);
123 |         client.connect("127.0.0.1", "23333");
124 |         StoreClient::Result result;
125 |         result = client.use(2);
126 |         DEBUG_INFO<<"result:"<<result.second;
127 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
128 | 
129 |         result = client.put("123", "456");
130 |         DEBUG_INFO<<"result:"<<result.second;
131 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
132 | 
133 |         result = client.get("123");
134 |         DEBUG_INFO<<"result:"<<result.second;
135 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
136 | 
137 |         result = client.mult();
138 |         DEBUG_INFO<<"result:"<<result.second;
139 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
140 | 
141 |         result = client.put("999", "456");
142 |         DEBUG_INFO<<"result:"<<result.second;
143 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
144 | 
145 |         result = client.exec();
146 |         DEBUG_INFO<<"result:"<<result.second;
147 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
148 | 
149 |         result = client.mult();
150 |         DEBUG_INFO<<"result:"<<result.second;
151 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
152 | 
153 |         result = client.discard();
154 |         DEBUG_INFO<<"result:"<<result.second;
155 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
156 | 
157 |         result = client.discard();
158 |         DEBUG_INFO<<"result:"<<result.second;
159 |         EXCEPT_EQ(result.first, RESP_TYPE_ERR);
160 | 
161 |         result = client.watch("999");
162 |         DEBUG_INFO<<"result:"<<result.second;
163 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
164 | 
165 |         result = client.put("999", "99999");
166 |         DEBUG_INFO<<"result:"<<result.second;
167 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
168 | 
169 |         result = client.mult();
170 |         DEBUG_INFO<<"result:"<<result.second;
171 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
172 | 
173 |         result = client.put("324", "432");
174 |         DEBUG_INFO<<"result:"<<result.second;
175 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
176 | 
177 |         result = client.put("432", "522");
178 |         DEBUG_INFO<<"result:"<<result.second;
179 |         EXCEPT_EQ(result.first, RESP_TYPE_OK);
180 | 
181 |         result = client.exec();
182 |         DEBUG_INFO<<"result:"<<result.second;
183 |         EXCEPT_EQ(result.first, RESP_TYPE_ERR);
184 | 
185 |     });
186 |     t.detach();
187 | }
188 | 
189 | }
190 | #endif // TEST_CLIENT
191 | 
192 | 


--------------------------------------------------------------------------------
/src/cmd_protocol.h:
--------------------------------------------------------------------------------
  1 | #ifndef PROTOCOL
  2 | #define PROTOCOL
  3 | #include <cstddef>
  4 | #include <boost/asio.hpp>
  5 | #include <string>
  6 | namespace kvstore {
  7 | 
  8 |     
  9 | const int POS_TYPE = 0;
 10 | //request
 11 | const int POS_TOTAL_LENGTH = 1;
 12 | //get命令
 13 | const int POS_GET_KEY_LENGTH = POS_TOTAL_LENGTH + 2;
 14 | const int POS_GET_KEY = POS_GET_KEY_LENGTH + 2;
 15 | //use命令
 16 | const int POS_DB_ID = POS_TOTAL_LENGTH + 2;
 17 | //response
 18 | const int POS_MSG = POS_TOTAL_LENGTH + 2;
 19 | //type r
 20 | const int REQ_TYPE_PUT = 0x00;
 21 | const int REQ_TYPE_GET = 0x01;
 22 | const int REQ_TYPE_DEL = 0x02;
 23 | const int REQ_TYPE_USE = 0x03;
 24 | const int REQ_TYPE_LOGIN = 0x04;
 25 | const int REQ_TYPE_MULT = 0x05;
 26 | const int REQ_TYPE_EXEC = 0x06;
 27 | const int REQ_TYPE_DISCARD = 0x07;
 28 | const int REQ_TYPE_WATCH = 0x08;
 29 | const int RESP_TYPE_OK = 0x00;
 30 | const int RESP_TYPE_ERR = 0x01;
 31 | 
 32 | 
 33 | inline int get_pos_value(std::size_t key_len) {
 34 |     return POS_GET_KEY + static_cast<int>(key_len);
 35 | }
 36 | 
 37 | 
 38 | union Len {
 39 |     unsigned short us;
 40 |     char c[2];
 41 | };
 42 | 
 43 | 
 44 | //first_item 适用于只有一个值的请求
 45 | static int first_item(const std::string& str, std::string& key) {
 46 |     key = str.substr(3, str.size() - 3);
 47 |     return 0;
 48 | }
 49 | 
 50 | static unsigned short total_len(const std::string& msg) {
 51 |     unsigned short len = *((unsigned short*) (msg.data() + POS_TOTAL_LENGTH));
 52 |     len = boost::asio::detail::socket_ops::network_to_host_short(len);
 53 |     return len;
 54 | }
 55 | //get_key 和 get_value 适用于 put请求
 56 | static int get_key(const std::string& str, std::size_t total_len, std::string& key) {
 57 |     unsigned short key_len_s = *((unsigned short*) (str.data() + POS_GET_KEY_LENGTH));
 58 |     key_len_s = boost::asio::detail::socket_ops::network_to_host_short(key_len_s);
 59 |     std::size_t key_len = static_cast<std::size_t>(key_len_s);
 60 |     if (key_len + POS_GET_KEY > total_len ) {
 61 |         return -1;
 62 |     }
 63 |     key = str.substr(POS_GET_KEY, key_len);
 64 |     return 0;
 65 | }
 66 | 
 67 | static int  get_value(const std::string& str,std::size_t total_len,
 68 |         std::size_t key_len, std::string& value) {
 69 |     const int POS_VALUE = get_pos_value(key_len);
 70 |     std::size_t value_len = total_len - static_cast<std::size_t>(POS_VALUE);
 71 |     if (POS_VALUE == 0) {
 72 |         value = "";
 73 |     } else {
 74 |         value = str.substr(POS_VALUE, value_len);
 75 |     }
 76 |     return 0;
 77 | }
 78 | 
 79 | static std::string get_response(const std::string& msg, int type) {
 80 |     std::string resp = std::string{"xxx"}  + msg;
 81 |     Len len;
 82 |     len.us = boost::asio::detail::socket_ops::host_to_network_short(resp.size());
 83 |     resp[POS_TYPE] = type;
 84 |     resp[POS_TOTAL_LENGTH] = len.c[0];
 85 |     resp[POS_TOTAL_LENGTH + 1] = len.c[1];
 86 |     return resp;
 87 | }
 88 | 
 89 | static void set_total_len(std::string& msg) {
 90 |     Len len;
 91 |     len.us = static_cast<unsigned short> (msg.length());
 92 |     len.us = boost::asio::detail::socket_ops::host_to_network_short(len.us);
 93 |     msg[POS_TOTAL_LENGTH] = len.c[0];
 94 |     msg[POS_TOTAL_LENGTH + 1] = len.c[0 + 1];
 95 | }
 96 | 
 97 | static std::string get_use_request(std::size_t db) {
 98 |     std::string msg("xxxx");
 99 |     set_total_len(msg);
100 |     msg[POS_DB_ID] = static_cast<unsigned char>(db);
101 |     msg[POS_TYPE] = REQ_TYPE_USE;
102 |     return msg;
103 | }
104 | 
105 | static std::string get_put_request(std::string key, std::string value) {
106 |     std::string msg = std::string("xxxxx") + key + value;
107 |     msg[POS_TYPE] = REQ_TYPE_PUT;
108 |     set_total_len(msg);
109 |     Len len;
110 |     len.us = static_cast<unsigned short> (key.length());
111 |     len.us = boost::asio::detail::socket_ops::host_to_network_short(len.us);
112 |     msg[POS_GET_KEY_LENGTH] = len.c[0];
113 |     msg[POS_GET_KEY_LENGTH + 1] = len.c[0 + 1];
114 |     return msg;
115 | }
116 | 
117 | static std::string get_get_request(std::string key) {
118 |     std::string msg = std::string("xxx") + key;
119 |     set_total_len(msg);
120 |     msg[POS_TYPE] = REQ_TYPE_GET;
121 |     return msg;
122 | }
123 | 
124 | static std::string get_del_request(std::string key) {
125 |     std::string msg = std::string("xxx") + key;
126 |     set_total_len(msg);
127 |     msg[POS_TYPE] = REQ_TYPE_DEL;
128 |     return msg;
129 | }
130 | 
131 | static std::string get_login_request(std::string password) {
132 |     std::string msg = std::string("xxx") + password;
133 |     set_total_len(msg);
134 |     msg[POS_TYPE] = REQ_TYPE_LOGIN;
135 |     return msg;
136 | }
137 | 
138 | static std::string get_mult_request() {
139 |     std::string msg("xxx");
140 |     set_total_len(msg);
141 |     msg[POS_TYPE] = REQ_TYPE_MULT;
142 |     return msg;
143 | }
144 | 
145 | static std::string get_exec_request() {
146 |     std::string msg("xxx");
147 |     set_total_len(msg);
148 |     msg[POS_TYPE] = REQ_TYPE_EXEC;
149 |     return msg;
150 | }
151 | 
152 | static std::string get_discard_request() {
153 |     std::string msg("xxx");
154 |     set_total_len(msg);
155 |     msg[POS_TYPE] = REQ_TYPE_DISCARD;
156 |     return msg;
157 | }
158 | 
159 | static std::string get_watch_request(const std::string& key) {
160 |     std::string msg = std::string("xxx") + key;
161 |     set_total_len(msg);
162 |     msg[POS_TYPE] = REQ_TYPE_WATCH;
163 |     return msg;
164 | }
165 | 
166 | 
167 | }//namespace
168 | 
169 | 
170 | //协议的长度2字节采用unsigned short， 一字节采用unsigned char
171 | //客户端request
172 | 
173 | // --------------------------------------------------------------------------------------------------------
174 | // | 请求类型   |    总 长 度      |   key长度  | key正文 + value 正文（如果有）|
175 | // |  1byte        |     2bytes       |   2bytes    |  变长                                              |
176 | //----------------------------------------------------------------------------------------------------------
177 | 
178 | //请求类型
179 | //0x00  put
180 | //0x01  get
181 | //0x02 del
182 | //0x03 use
183 | //0x04 login
184 | //0x05 mult
185 | //0x06 exec
186 | 
187 | //get
188 | // ----------------------------------------------------------------------
189 | // | 请求类型   |    总 长 度         | key正文|
190 | // |  1byte        |     2bytes          |  变长     |
191 | //------------------------------------------------------------------------
192 | 
193 | //put
194 | // ----------------------------------------------------------------------------------------
195 | // | 请求类型   |    总 长 度      |   key长度  | key正文 + value正文|
196 | // |  1byte        |     2bytes       |   2bytes    |             变 长              |
197 | //----------------------------------------------------------------------------------------
198 | 
199 | //del
200 | // -----------------------------------------------------------------------
201 | // | 请求类型   |    总 长 度      |   key长度  | key正文|
202 | // |  1byte        |     2bytes       |   2bytes    |  变长     |
203 | //-----------------------------------------------------------------------
204 | 
205 | //use
206 | // ----------------------------------------------------------
207 | // | 请求类型   |    总 长 度      |   数据库id  |
208 | // |  1byte        |     2bytes       |   1byte       |
209 | //-----------------------------------------------------------
210 | 
211 | //watch
212 | // -----------------------------------------------------------------------
213 | // | 请求类型   |    总 长 度      |   key长度  | key正文|
214 | // |  1byte        |     2bytes       |   2bytes    |  变长     |
215 | //-----------------------------------------------------------------------
216 | 
217 | //login
218 | // ----------------------------------------------------------
219 | // | 请求类型   |    总 长 度         | 密码正文 |
220 | // |  1byte        |     2bytes          |  变长       |
221 | //----------------------------------------------------------
222 | 
223 | 
224 | //discard
225 | 
226 | //服务端response、
227 | // ----------------------------------------------------------
228 | // | 答复类型   |  总长度          |   message    |
229 | // |  1byte        |    2bytes        |   变长           |
230 | //------------------------------------------------------------
231 | 
232 | //答复类型
233 | // 0x00 ok
234 | // 0x01 error
235 | 
236 | 
237 | 
238 | #endif // PROTOCOL
239 | 
240 | 


--------------------------------------------------------------------------------
/src/store_server.cpp:
--------------------------------------------------------------------------------
  1 | #include "store_server.h"
  2 | #include "cmd_protocol.h"
  3 | #include <assert.h>
  4 | namespace kvstore {
  5 | StoreServer::StoreServer(io_service& ioservice, std::size_t port) :
  6 |     tcp_server_(ioservice, port),
  7 |     conns_(),
  8 |     dbs_(),
  9 |     config_(),
 10 |     persistence_(*this)
 11 | {
 12 |     tcp_server_.set_close_callback(
 13 |                 std::bind(&StoreServer::handle_close, this, std::placeholders::_1));
 14 |     tcp_server_.set_new_conn_callback(
 15 |                 std::bind(&StoreServer::handle_new_conn, this, std::placeholders::_1));
 16 |     tcp_server_.set_read_callback(
 17 |                 std::bind(&StoreServer::handle_read, this, std::placeholders::_1, std::placeholders::_2));
 18 |     LOG_INFO<<"kvstore server start!";
 19 | }
 20 | 
 21 | void StoreServer::handle_close(TcpConnection::Pointer conn) {
 22 |     auto iter = conns_.find(conn);
 23 |     assert(iter != conns_.end());
 24 |     conns_.erase(iter);
 25 | }
 26 | 
 27 | void StoreServer::handle_read(TcpConnection::Pointer conn, std::size_t bytes_transfered) {
 28 |     ConnData& data = conns_[conn];
 29 |     std::string& buf = data.buf;
 30 |     //没有获得完整命令，就返回
 31 |     buf.append(std::string(conn->buf().data(), bytes_transfered));
 32 |     if (buf.length() < 3) {
 33 |         return;
 34 |     }
 35 |     std::size_t len = static_cast<std::size_t>(total_len(buf));
 36 |     if (buf.length() < len) {
 37 |         return;
 38 |     }
 39 |     std::string cmd = buf.substr(0, len);
 40 |     buf.erase(0, len);
 41 |     std::string retmsg("");
 42 |     //将命令分发到对应的处理函数中，返回结果
 43 |     int err = dispath_cmd(cmd, conn, retmsg);
 44 |     //发送response
 45 |     std::string response("");
 46 |     if (err < 0) {
 47 |         response = get_response(retmsg, RESP_TYPE_ERR);
 48 |     } else {
 49 |         response = get_response(retmsg, RESP_TYPE_OK);
 50 |         persistence_.record(cmd,  data.db);
 51 |     }
 52 |     conn->send(response);
 53 |     //尾递归，处理没有处理完的命令
 54 |     handle_read(conn, 0);
 55 | }
 56 | 
 57 | void StoreServer::handle_new_conn(TcpConnection::Pointer conn) {
 58 |     conns_[conn] = ConnData();
 59 | }
 60 | 
 61 | int StoreServer::dispath_cmd(const std::string &cmd,
 62 |                              TcpConnection::Pointer conn, std::string &retmsg)
 63 | {
 64 |     ConnData& data = conns_[conn];
 65 |     int err = 0;
 66 |     if (cmd[POS_TYPE] == REQ_TYPE_LOGIN) {
 67 |         //输入密码登陆
 68 |         return execute_cmd_login(cmd, conn, retmsg);
 69 |     }
 70 |     if (!data.login && config_.need_password()) {
 71 |         retmsg = "please enter password";
 72 |         LOG_DEBUG<<"用户未登录";
 73 |         return -1;
 74 |     }
 75 |     if (cmd[POS_TYPE] == REQ_TYPE_MULT) {
 76 |         //mult
 77 |         return execute_cmd_mult(cmd, conn, retmsg);
 78 |     }
 79 |     if (cmd[POS_TYPE] == REQ_TYPE_WATCH) {
 80 |         //watch
 81 |         return execute_cmd_watch(cmd, conn, retmsg);
 82 |     }
 83 |     if (cmd[POS_TYPE] == REQ_TYPE_EXEC) {
 84 |         //exec
 85 |         return  execute_cmd_exec(cmd, conn, retmsg);
 86 |     }
 87 |     if (cmd[POS_TYPE] == REQ_TYPE_DISCARD) {
 88 |         //discard
 89 |         return  execute_cmd_discard(cmd, conn, retmsg);
 90 |     }
 91 |     if (data.transaction.mult()) {
 92 |         //在输入了mult之后，get put del clear会进入这，加入事务
 93 |         return add_transaction(cmd, conn, retmsg);
 94 |     }
 95 |     if (cmd[POS_TYPE] == REQ_TYPE_USE) {
 96 |         //切换db
 97 |         return  execute_cmd_use(cmd, conn, retmsg);
 98 |     }
 99 |     //get put del clear
100 |     err = execute_db_cmd(cmd, data.db, retmsg);
101 |     return err;
102 | }
103 | 
104 | int StoreServer::execute_db_cmd(const std::string &cmd, std::size_t db, std::string &retmsg) {
105 |     int req_type = static_cast<int>(cmd[POS_TYPE]);
106 |     int err = -1;
107 |     switch (req_type) {
108 |     case REQ_TYPE_PUT :
109 |         err = execute_cmd_put(cmd, db, retmsg);
110 |         LOG_DEBUG<<"execute_cmd_put";
111 |         return err;
112 |     case REQ_TYPE_GET:
113 |         err =  execute_cmd_get(cmd, db, retmsg);
114 |         LOG_DEBUG<<"execute_cmd_get";
115 |         return err;
116 |     case REQ_TYPE_DEL:
117 |         err =  execute_cmd_del(cmd, db, retmsg);
118 |         LOG_DEBUG<<"execute_cmd_del";
119 |         return err;
120 |     default:
121 |         break;
122 |     }
123 |     retmsg = "cmd syntax error";
124 |     return err;
125 | }
126 | 
127 | void StoreServer::init() {
128 |     LOG_DEBUG<<"开始恢复数据";
129 |     persistence_.recover();
130 |     LOG_DEBUG<<"恢复数据完成";
131 | }
132 | 
133 | KVDatabase &StoreServer::db() {
134 |     return dbs_;
135 | }
136 | 
137 | int StoreServer::execute_cmd_put(const std::string &cmd, std::size_t db,std::string &retmsg) {
138 |     std::string key;
139 |     int err = get_key(cmd, cmd.length(), key);
140 |     if (err < 0) {
141 |         //todo
142 |         LOG_DEBUG<<"err1";
143 |         retmsg = "error";
144 |         return -1;
145 |     }
146 |     std::string value;
147 |     err = get_value(cmd, cmd.length(), key.length(), value);
148 |     if (err < 0) {
149 |         //todo
150 |         LOG_DEBUG<<"err2";
151 |         retmsg = "error";
152 |         return -2;
153 |     }
154 |     err = dbs_.put(db, std::move(key), std::move(value));
155 |     if (err < 0) {
156 |         //todo
157 |         LOG_DEBUG<<"err3";
158 |         retmsg = "error";
159 |         return -3;
160 |     }
161 |     retmsg = "ok";
162 |     return 0;
163 | }
164 | 
165 | int StoreServer::execute_cmd_del(const std::string &cmd, std::size_t db,std::string &retmsg) {
166 |     std::string keystring;
167 |     int err = first_item(cmd, keystring);
168 |     if (err < 0) {
169 |         //todo
170 |         LOG_DEBUG<<"err1";
171 |         retmsg = "error";
172 |         return -1;
173 |     }
174 |     err = dbs_.del(db, std::move(keystring));
175 |     if (err < 0) {
176 |         //todo
177 |         LOG_DEBUG<<"null";
178 |         retmsg = "null";
179 |         return -2;
180 |     }
181 |     retmsg = "ok";
182 |     return 0;
183 | }
184 | 
185 | int StoreServer::execute_cmd_use(const std::string &cmd,
186 |                                  TcpConnection::Pointer conn, std::string &retmsg) {
187 |     unsigned char c = cmd[POS_DB_ID];
188 |     std::size_t db = static_cast<std::size_t>(c);
189 |     if (db >= dbs_.size()) {
190 |         retmsg = "error:number is too large";
191 |         LOG_DEBUG<<"err";
192 |         return -1;
193 |     }
194 |     retmsg = "ok";
195 |     conns_[conn].db = db;
196 |     return 0;
197 | }
198 | 
199 | int StoreServer::execute_cmd_login(const std::string &cmd,
200 |                                    TcpConnection::Pointer conn, std::string &retmsg)
201 | {
202 |     retmsg = "ok";
203 |     if (!config_.need_password()) {
204 |         return 0;
205 |     }
206 |     std::string password;
207 |     int err = first_item(cmd, password);
208 |     if (err < 0) {
209 |         LOG_DEBUG<<"err";
210 |         retmsg = "syntax error";
211 |         return -1;
212 |     }
213 | 
214 |     if (password != config_.password()) {
215 |         LOG_DEBUG<<"err";
216 |         retmsg = "password wrong";
217 |         return -2;
218 |     }
219 |     conns_[conn].login = true;
220 |     return 0;
221 | }
222 | 
223 | int StoreServer::execute_cmd_mult(const std::string &cmd,
224 |                                   TcpConnection::Pointer conn, std::string &retmsg)
225 | {
226 |     ConnData& data = conns_[conn];
227 |     if (data.transaction.mult()) {
228 |         retmsg = "error";
229 |         return -1;
230 |     }
231 |     data.transaction.set_mult(true);
232 |     retmsg = "ok";
233 |     return 0;
234 | }
235 | 
236 | int StoreServer::execute_cmd_exec(const std::string &cmd,
237 |                                   TcpConnection::Pointer conn, std::string &retmsg)
238 | {
239 |     //todo
240 |     ConnData& data = conns_[conn];
241 |     int err = 0;
242 |     for (auto &pair : data.transaction.watchs()) {
243 |         std::string value("");
244 |         dbs_.get(data.db, pair.first, value);
245 |         if (value != pair.second) {
246 |             err = -1;
247 |             break;
248 |         }
249 |     }
250 |     if (err == -1) {
251 |         retmsg="watch value has been changed";
252 |         return err;
253 |     }
254 |     std::string ret;
255 |     retmsg = "";
256 |     for (auto &cmd : data.transaction.cmds()) {
257 |         err = execute_db_cmd(cmd, data.db, ret);
258 |         retmsg = retmsg + ret + "\r\n";
259 |         if (err < 0) {
260 |             break;
261 |         }
262 |     }
263 |     if (!retmsg.empty()) {
264 |         retmsg.erase(retmsg.size() - 2, 2);
265 |     }
266 |     data.transaction.set_mult(false);
267 |     data.transaction.clear_cmd();
268 |     data.transaction.clear_watch();
269 |     return err;
270 | }
271 | 
272 | int StoreServer::add_transaction(const std::string &cmd,
273 |                                  TcpConnection::Pointer conn, std::string &retmsg)
274 | {
275 |     ConnData& data = conns_[conn];
276 |     if (cmd[POS_TYPE] == REQ_TYPE_USE) {
277 |         retmsg = "error";
278 |         return -1;
279 |     }
280 |     data.transaction.add_cmd(cmd);
281 |     retmsg = "queued";
282 |     return 0;
283 | }
284 | 
285 | int StoreServer::execute_cmd_discard(const std::string &cmd,
286 |                                      TcpConnection::Pointer conn, std::string &retmsg)
287 | {
288 | 
289 |     ConnData& data = conns_[conn];
290 |      if (!data.transaction.mult()) {
291 |          retmsg = "don't need to discard";
292 |          return -1;
293 |      }
294 |     data.transaction.set_mult(false);
295 |     data.transaction.clear_cmd();
296 |     data.transaction.clear_watch();
297 |     retmsg = "ok";
298 |     return 0;
299 | }
300 | 
301 | int StoreServer::execute_cmd_watch(const std::string &cmd,
302 |                                    TcpConnection::Pointer conn, std::string &retmsg)
303 | {
304 |     std::string keystring;
305 |     int err = first_item(cmd, keystring);
306 |     if (err < 0) {
307 |         //todo
308 |         LOG_DEBUG<<"cmd syntax error";
309 |         retmsg = "cmd syntax error";
310 |         return -1;
311 |     }
312 |     std::string value;
313 |     ConnData& data = conns_[conn];
314 |     err = dbs_.get(data.db, std::move(keystring), value);
315 |     if (err < 0) {
316 |         value = "";
317 |     }
318 |     data.transaction.add_watch(keystring, value);
319 |     return 0;
320 | }
321 | 
322 | int StoreServer::execute_cmd_get(const std::string &cmd, std::size_t db,std::string &retmsg) {
323 |     std::string keystring;
324 |     int err = first_item(cmd, keystring);
325 |     if (err < 0) {
326 |         //todo
327 |         LOG_DEBUG<<"err1";
328 |         retmsg = "error";
329 |         return -1;
330 |     }
331 |     std::string value;
332 |     err = dbs_.get(db, std::move(keystring), value);
333 |     if (err < 0) {
334 |         //todo
335 |         LOG_DEBUG<<"null";
336 |         retmsg = "null";
337 |         return -2;
338 |     }
339 |     retmsg = value;
340 |     return 0;
341 | }
342 | 
343 | 
344 | }//namespace
345 | 
346 | 


--------------------------------------------------------------------------------
/src/kvstore.pro.user:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <!DOCTYPE QtCreatorProject>
  3 | <!-- Written by QtCreator 3.5.0, 2017-03-07T23:28:56. -->
  4 | <qtcreator>
  5 |  <data>
  6 |   <variable>EnvironmentId</variable>
  7 |   <value type="QByteArray">{a526d735-51c7-4b8c-a058-95f544668f26}</value>
  8 |  </data>
  9 |  <data>
 10 |   <variable>ProjectExplorer.Project.ActiveTarget</variable>
 11 |   <value type="int">0</value>
 12 |  </data>
 13 |  <data>
 14 |   <variable>ProjectExplorer.Project.EditorSettings</variable>
 15 |   <valuemap type="QVariantMap">
 16 |    <value type="bool" key="EditorConfiguration.AutoIndent">true</value>
 17 |    <value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
 18 |    <value type="bool" key="EditorConfiguration.CamelCaseNavigation">true</value>
 19 |    <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
 20 |     <value type="QString" key="language">Cpp</value>
 21 |     <valuemap type="QVariantMap" key="value">
 22 |      <value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
 23 |     </valuemap>
 24 |    </valuemap>
 25 |    <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
 26 |     <value type="QString" key="language">QmlJS</value>
 27 |     <valuemap type="QVariantMap" key="value">
 28 |      <value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
 29 |     </valuemap>
 30 |    </valuemap>
 31 |    <value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
 32 |    <value type="QByteArray" key="EditorConfiguration.Codec">UTF-8</value>
 33 |    <value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
 34 |    <value type="int" key="EditorConfiguration.IndentSize">4</value>
 35 |    <value type="bool" key="EditorConfiguration.KeyboardTooltips">false</value>
 36 |    <value type="int" key="EditorConfiguration.MarginColumn">80</value>
 37 |    <value type="bool" key="EditorConfiguration.MouseHiding">true</value>
 38 |    <value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
 39 |    <value type="int" key="EditorConfiguration.PaddingMode">1</value>
 40 |    <value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
 41 |    <value type="bool" key="EditorConfiguration.ShowMargin">false</value>
 42 |    <value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
 43 |    <value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
 44 |    <value type="int" key="EditorConfiguration.TabKeyBehavior">0</value>
 45 |    <value type="int" key="EditorConfiguration.TabSize">8</value>
 46 |    <value type="bool" key="EditorConfiguration.UseGlobal">true</value>
 47 |    <value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
 48 |    <value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
 49 |    <value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
 50 |    <value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
 51 |    <value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
 52 |   </valuemap>
 53 |  </data>
 54 |  <data>
 55 |   <variable>ProjectExplorer.Project.PluginSettings</variable>
 56 |   <valuemap type="QVariantMap"/>
 57 |  </data>
 58 |  <data>
 59 |   <variable>ProjectExplorer.Project.Target.0</variable>
 60 |   <valuemap type="QVariantMap">
 61 |    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">deskon</value>
 62 |    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">deskon</value>
 63 |    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{f2b5f4a2-6448-4c1b-afcc-09e49986b0b3}</value>
 64 |    <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
 65 |    <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
 66 |    <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
 67 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
 68 |     <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/sunfish/qtcode/build-kvstore-deskon-Debug</value>
 69 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
 70 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
 71 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
 72 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
 73 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
 74 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
 75 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
 76 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
 77 |       <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
 78 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
 79 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
 80 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
 81 |      </valuemap>
 82 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
 83 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
 84 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
 85 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
 86 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
 87 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
 88 |        <value type="QString">-w</value>
 89 |        <value type="QString">-r</value>
 90 |       </valuelist>
 91 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
 92 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
 93 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
 94 |      </valuemap>
 95 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
 96 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
 97 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
 98 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
 99 |     </valuemap>
100 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
101 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
102 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
103 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
104 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
105 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
106 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
107 |        <value type="QString">-w</value>
108 |        <value type="QString">-r</value>
109 |       </valuelist>
110 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
111 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
112 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
113 |      </valuemap>
114 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
115 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
116 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
117 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
118 |     </valuemap>
119 |     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
120 |     <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
121 |     <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
122 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
123 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
124 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
125 |     <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
126 |     <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
127 |    </valuemap>
128 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
129 |     <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/sunfish/qtcode/build-kvstore-deskon-Release</value>
130 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
131 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
132 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
133 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
134 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
135 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
136 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
137 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
138 |       <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
139 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
140 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
141 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
142 |      </valuemap>
143 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
144 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
145 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
146 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
147 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
148 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
149 |        <value type="QString">-w</value>
150 |        <value type="QString">-r</value>
151 |       </valuelist>
152 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
153 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
154 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
155 |      </valuemap>
156 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
157 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
158 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
159 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
160 |     </valuemap>
161 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
162 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
163 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
164 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
165 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
166 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
167 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
168 |        <value type="QString">-w</value>
169 |        <value type="QString">-r</value>
170 |       </valuelist>
171 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
172 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
173 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
174 |      </valuemap>
175 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
176 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
177 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
178 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
179 |     </valuemap>
180 |     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
181 |     <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
182 |     <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
183 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
184 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
185 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
186 |     <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
187 |     <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
188 |    </valuemap>
189 |    <value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">2</value>
190 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
191 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
192 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
193 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
194 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
195 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
196 |     </valuemap>
197 |     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
198 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
199 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
200 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
201 |    </valuemap>
202 |    <value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
203 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
204 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
205 |     <valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
206 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
207 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
208 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
209 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
210 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
211 |     <value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
212 |     <value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
213 |     <value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
214 |     <value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
215 |     <value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
216 |     <valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
217 |     <value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
218 |     <value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
219 |     <value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
220 |     <value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
221 |     <value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
222 |     <valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
223 |      <value type="int">0</value>
224 |      <value type="int">1</value>
225 |      <value type="int">2</value>
226 |      <value type="int">3</value>
227 |      <value type="int">4</value>
228 |      <value type="int">5</value>
229 |      <value type="int">6</value>
230 |      <value type="int">7</value>
231 |      <value type="int">8</value>
232 |      <value type="int">9</value>
233 |      <value type="int">10</value>
234 |      <value type="int">11</value>
235 |      <value type="int">12</value>
236 |      <value type="int">13</value>
237 |      <value type="int">14</value>
238 |     </valuelist>
239 |     <value type="int" key="PE.EnvironmentAspect.Base">2</value>
240 |     <valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
241 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">kvstore</value>
242 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
243 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration:/home/sunfish/qtcode/kvstore/kvstore.pro</value>
244 |     <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.CommandLineArguments"></value>
245 |     <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.ProFile">kvstore.pro</value>
246 |     <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix">false</value>
247 |     <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">true</value>
248 |     <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
249 |     <value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
250 |     <value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
251 |     <value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
252 |     <value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
253 |     <value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
254 |     <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
255 |    </valuemap>
256 |    <value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
257 |   </valuemap>
258 |  </data>
259 |  <data>
260 |   <variable>ProjectExplorer.Project.Target.1</variable>
261 |   <valuemap type="QVariantMap">
262 |    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qt5-deskon</value>
263 |    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">qt5-deskon</value>
264 |    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{0bb78d17-6d5c-470b-b253-1672982557ca}</value>
265 |    <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
266 |    <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
267 |    <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
268 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
269 |     <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/sunfish/qtcode/build-kvstore-qt5_deskon-Debug</value>
270 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
271 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
272 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
273 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
274 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
275 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
276 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
277 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
278 |       <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
279 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
280 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
281 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
282 |      </valuemap>
283 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
284 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
285 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
286 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
287 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
288 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
289 |        <value type="QString">-w</value>
290 |        <value type="QString">-r</value>
291 |       </valuelist>
292 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
293 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
294 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
295 |      </valuemap>
296 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
297 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
298 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
299 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
300 |     </valuemap>
301 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
302 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
303 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
304 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
305 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
306 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
307 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
308 |        <value type="QString">-w</value>
309 |        <value type="QString">-r</value>
310 |       </valuelist>
311 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
312 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
313 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
314 |      </valuemap>
315 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
316 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
317 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
318 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
319 |     </valuemap>
320 |     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
321 |     <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
322 |     <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
323 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Debug</value>
324 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
325 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
326 |     <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
327 |     <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
328 |    </valuemap>
329 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
330 |     <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/sunfish/qtcode/build-kvstore-qt5_deskon-Release</value>
331 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
332 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
333 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
334 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
335 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
336 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
337 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
338 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
339 |       <value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
340 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
341 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.SeparateDebugInfo">false</value>
342 |       <value type="bool" key="QtProjectManager.QMakeBuildStep.UseQtQuickCompiler">false</value>
343 |      </valuemap>
344 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
345 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
346 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
347 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
348 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
349 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
350 |        <value type="QString">-w</value>
351 |        <value type="QString">-r</value>
352 |       </valuelist>
353 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
354 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
355 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
356 |      </valuemap>
357 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
358 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">构建</value>
359 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
360 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
361 |     </valuemap>
362 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
363 |      <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
364 |       <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
365 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
366 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
367 |       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
368 |       <valuelist type="QVariantList" key="Qt4ProjectManager.MakeStep.AutomaticallyAddedMakeArguments">
369 |        <value type="QString">-w</value>
370 |        <value type="QString">-r</value>
371 |       </valuelist>
372 |       <value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
373 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
374 |       <value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
375 |      </valuemap>
376 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
377 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">清理</value>
378 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
379 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
380 |     </valuemap>
381 |     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
382 |     <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
383 |     <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
384 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Release</value>
385 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
386 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
387 |     <value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
388 |     <value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">true</value>
389 |    </valuemap>
390 |    <value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">2</value>
391 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
392 |     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
393 |      <value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
394 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">部署</value>
395 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
396 |      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
397 |     </valuemap>
398 |     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
399 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">在本地部署</value>
400 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
401 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
402 |    </valuemap>
403 |    <value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
404 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.PluginSettings"/>
405 |    <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
406 |     <valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
407 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
408 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
409 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
410 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
411 |     <value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
412 |     <value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
413 |     <value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
414 |     <value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">true</value>
415 |     <value type="int" key="Analyzer.Valgrind.LeakCheckOnFinish">1</value>
416 |     <value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
417 |     <valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
418 |     <value type="int" key="Analyzer.Valgrind.SelfModifyingCodeDetection">1</value>
419 |     <value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
420 |     <value type="bool" key="Analyzer.Valgrind.ShowReachable">false</value>
421 |     <value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
422 |     <value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
423 |     <valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
424 |      <value type="int">0</value>
425 |      <value type="int">1</value>
426 |      <value type="int">2</value>
427 |      <value type="int">3</value>
428 |      <value type="int">4</value>
429 |      <value type="int">5</value>
430 |      <value type="int">6</value>
431 |      <value type="int">7</value>
432 |      <value type="int">8</value>
433 |      <value type="int">9</value>
434 |      <value type="int">10</value>
435 |      <value type="int">11</value>
436 |      <value type="int">12</value>
437 |      <value type="int">13</value>
438 |      <value type="int">14</value>
439 |     </valuelist>
440 |     <value type="int" key="PE.EnvironmentAspect.Base">-1</value>
441 |     <valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
442 |     <value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
443 |     <value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
444 |     <value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
445 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">自定义执行档</value>
446 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
447 |     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
448 |     <value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
449 |     <value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
450 |     <value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
451 |     <value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
452 |     <value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
453 |     <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
454 |    </valuemap>
455 |    <value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
456 |   </valuemap>
457 |  </data>
458 |  <data>
459 |   <variable>ProjectExplorer.Project.TargetCount</variable>
460 |   <value type="int">2</value>
461 |  </data>
462 |  <data>
463 |   <variable>ProjectExplorer.Project.Updater.FileVersion</variable>
464 |   <value type="int">18</value>
465 |  </data>
466 |  <data>
467 |   <variable>Version</variable>
468 |   <value type="int">18</value>
469 |  </data>
470 | </qtcreator>
471 | 


--------------------------------------------------------------------------------