#reactor

.gitignore

@@ -30,3 +30,10 @@
 *.exe
 *.out
 *.app
+
+# blade build
+blade-bin/
+build64_release/
+
+#vs code
+.vscode/

chive/base/Atomic.h

@@ -0,0 +1,65 @@
+#ifndef CHIVE_BASE_ATOMIC_H
+#define CHIVE_BASE_ATOMIC_H
+
+#include "chive/base/noncopyable.h"
+#include <cstdint>
+
+namespace chive
+{
+namespace base
+{
+template<typename T>
+class AtomicIntegerT : noncopyable
+{
+public:
+    AtomicIntegerT():value_(0){}
+
+    T get() {
+        return __atomic_load_n(&value_, __ATOMIC_SEQ_CST);
+    }
+
+    T getAndAdd(T x) {
+        return __atomic_fetch_add(&value_, x, __ATOMIC_SEQ_CST);
+    }
+
+    T addAndGet(T x) {
+        return getAndAdd(x) + x;
+    }
+
+    T incrementAndGet() {
+        return addAndGet(1);
+    }
+
+    T decrementAndGet() {
+        return addAndGet(-1);
+    }
+
+    void add(T x) {
+        getAndAdd(x);
+    }
+
+    void increment() {
+        incrementAndGet();
+    }
+
+    void decrement() {
+        decrementAndGet();
+    }
+
+    T getAndSet(T newVal) {
+        return __atomic_exchange_n(&value_, newVal, __ATOMIC_SEQ_CST);
+    }
+
+private:
+    volatile T value_;
+};
+} // namespace base
+
+/**
+ * 提供给chive::net namespace下直接使用
+ */
+using AtomicInt32 = base::AtomicIntegerT<int32_t>;
+using AtomicInt64 = base::AtomicIntegerT<int64_t>;
+} // namespace chive
+
+#endif

chive/base/BUILD

@@ -0,0 +1,32 @@
+cc_library(
+    name = 'chive_base',
+    srcs = [
+        'CurrentThread.cc',
+        'CountDownLatch.cc',
+        'Thread.cc',
+        'FileUtil.cc',
+    ],
+    deps = [
+        '#pthread',
+        '//chive/base/clog/:chive_log'
+    ],
+    extra_cppflags = [
+        '-std=c++17',
+        # '-Wall',  # show warning as error
+        '-w',       # no warning
+         '-g',
+    ]
+)
+
+cc_library(
+    name = 'chive_fileutil',
+    srcs = [
+        'FileUtil.cc'
+    ],
+    extra_cppflags = [
+        '-std=c++17',
+        # '-Wall',  # show warning as error
+        '-w',       # no warning
+         '-g',
+    ]
+)

chive/base/Condition.h

@@ -0,0 +1,57 @@
+#ifndef CHIVE_BASE_CONDITION_H
+#define CHIVE_BASE_CONDITION_H
+
+#include "chive/base/MutexLock.h"
+
+#include <pthread.h>
+#include <cassert>
+#include <errno.h>  /*provide ETIMEDOUT */
+
+namespace chive
+{
+class Condition : noncopyable {
+public:
+    explicit Condition(MutexLock& mutex) : mutex_(mutex) {
+        int flag = pthread_cond_init(&cond_, nullptr);
+        assert(flag == 0); (void)flag;
+    }
+
+    ~Condition() {
+        int flag = pthread_cond_destroy(&cond_);
+        assert(flag == 0); (void)flag;
+    }
+
+    void wait() {
+        /// FIXME: need lock guard or not?
+        int flag = pthread_cond_wait(&cond_, mutex_.getPthreadMutexPtr());
+        assert(flag == 0); (void)flag;
+    }
+
+    bool waitForSecond(int second) {
+        struct timespec timeout{};
+        // CLOCK_REALTIME 和 CLOCK_MONOTONIC 的区别
+        // clock_getres 和 clock_gettime的区别
+        /*clock_getres(CLOCK_REALTIME, &timeout);*/
+        clock_getres(CLOCK_MONOTONIC, &timeout);
+        timeout.tv_sec += second;
+        return pthread_cond_timedwait(
+            &cond_, mutex_.getPthreadMutexPtr(), &timeout) == ETIMEDOUT;
+    }
+
+    void notify() {
+        int flag = pthread_cond_signal(&cond_);
+        assert(flag == 0); (void)flag;
+    }
+
+    void notifyall() {
+        int flag = pthread_cond_broadcast(&cond_);
+        assert(flag == 0); (void)flag;
+    }
+
+private:
+    MutexLock& mutex_;
+    pthread_cond_t cond_;
+};
+} // namespace chive
+
+#endif

chive/base/ContentTypes.h

@@ -0,0 +1,39 @@
+#ifndef CHIVE_NET_CONTENT_TYPES_H
+#define CHIVE_NET_CONTENT_TYPES_H
+
+namespace chive
+{
+
+/**
+ * 主流的body content type
+ * 
+ * application/x-www-form-urlencoded： 不属于http content-type规范，通常用于浏览器表单提交，
+ * 格式:name1=value1&name2=value2, POST会放入http body，GET则显示在在URL
+ * urlencoded格式如 URL中出现 %E4%BD%A0，与unicode(\uxxxx) 区分
+ * 
+ * 
+ */
+enum class ContentType
+{
+    ApplicationJson,
+    ApplicationXml,
+    ApplicationBase64,
+    ApplicationXW3FormUrlEncoded,   /**/
+    ApplicationOctetStream, /*二进制流或字节数组*/
+    MultipartFormdata,  /*表单*/
+    TextPlain,
+    TextCss,
+    TextHtml,
+    ApplicationJavascript,
+    OtherType
+};
+
+enum class MimeType
+{
+    TextXml,
+    TextHtml,
+};
+
+} // namespace chive
+
+#endif

chive/base/CountDownLatch.cc

@@ -0,0 +1,31 @@
+#include "chive/base/CountDownLatch.h"
+
+using namespace chive;
+
+CountDownLatch::CountDownLatch(int count)
+    : mutex_{},
+      condition_(mutex_),
+      count_(count) 
+{
+}
+
+void CountDownLatch::wait() {
+    MutexLockGuard lock(mutex_);
+    while(count_ > 0) {
+        condition_.wait();
+    }
+}
+
+void CountDownLatch::countDown() {
+    MutexLockGuard lock(mutex_);
+    --count_;
+    if(count_ == 0) {
+        condition_.notifyall();
+    }
+}
+
+int CountDownLatch::getCount() const {
+    MutexLockGuard lock(mutex_);
+    return count_;
+}
+

chive/base/CountDownLatch.h

@@ -0,0 +1,30 @@
+#ifndef CHIVE_BASE_COUNTDOWNLATCH_H
+#define CHIVE_BASE_COUNTDOWNLATCH_H
+
+#include "chive/base/noncopyable.h"
+#include "chive/base/Condition.h"
+#include "chive/base/MutexLock.h"
+
+namespace chive
+{
+class CountDownLatch : noncopyable {
+public:
+
+    explicit CountDownLatch(int count);
+
+    void wait();
+
+    void countDown();
+
+    int getCount() const;
+private:
+    // 
+    mutable MutexLock mutex_;
+    // 相比muduo源码，这里省去了clang线程安全检查注解 guard_by
+    /// FIXME: 
+    Condition condition_;
+    int count_;
+};
+} // namespace chive
+
+#endif

chive/base/CurrentThread.cc

@@ -0,0 +1,30 @@
+#include "chive/base/CurrentThread.h"
+
+// using namespace chive;
+
+#include <cstdio>
+#include <sys/syscall.h>    /* For SYS_xxx definitions */
+
+namespace chive
+{
+namespace CurrentThread
+{
+// 必须在与 .h 相同的namespace 下定义，否则导致二义性
+// 即，编译器认不出是 .cc 的 还是 .h 的
+// 定义 extern __thread
+__thread int t_cachedTid = 0;
+__thread char t_tidString[32];
+__thread int t_tidStringLength = 6;
+__thread const char* t_threadName = "unknown";
+static_assert(std::is_same<int, pid_t>::value, "pid_t should be int");
+
+void cachedTid() {
+    if(t_cachedTid == 0) {
+        t_cachedTid = static_cast<pid_t>(::syscall(SYS_gettid));
+        t_tidStringLength = snprintf(t_tidString, sizeof t_tidString, "%5d ", t_cachedTid);
+    }
+}    
+} // namespace CurrentThread
+
+} // namespace chive
+

chive/base/CurrentThread.h

@@ -0,0 +1,41 @@
+#ifndef V_CURRENTTHREAD_H
+#define V_CURRENTTHREAD_H
+
+#include <unistd.h>
+#include <type_traits>
+namespace chive
+{
+namespace CurrentThread {
+    // 使用extern告诉编译器这些__thread修饰的变量定义在
+    // 另一个文件，只能初始化为编译器常量
+    extern __thread int t_cachedTid;
+    extern __thread char t_tidString[32];
+    extern __thread int t_tidStringLength;
+    extern __thread const char* t_threadName;
+
+    void cachedTid();
+
+    inline int tid() {
+        // __builtin_expect是GCC的內建函数
+        //作用：编译器分支预测，减少跳转指令，从而优化性能    
+        if(__builtin_expect(t_cachedTid == 0, 0)) {
+            cachedTid();
+        }
+        return t_cachedTid;
+    }
+
+    inline int tidStringLength() {
+        return t_tidStringLength;
+    }
+    // 未实现设置线程名
+    inline const char* name() {
+        return t_threadName;
+    }
+    //根据主线程的pid == tid
+    inline bool isMainThread() {
+        return tid() == ::getpid();
+    }
+};
+} // namespace chive
+
+#endif

chive/base/FileUtil.cc

@@ -0,0 +1,36 @@
+#include "chive/base/FileUtil.h"
+#include "chive/base/clog/chiveLog.h"
+#include <iostream>
+
+using namespace chive;
+using namespace chive::FileUtil;
+
+const char* FILE_PATH = "/data/chive/upload/";
+
+File::File(std::string filename, ContentType type)
+  : filename_(filename),
+    contentType_(type),
+    writtenBytes_(0)
+{
+
+}
+
+File::~File()
+{
+
+}
+
+void File::output(const char* begin, const char* end)
+{
+    fout_.open(FILE_PATH + filename_, std::ios::out|std::ios::binary);
+    if (!fout_.is_open())
+    {
+        // CHIVE_LOG_ERROR("Cannot open file %s", FILE_PATH + filename_);
+        std::cout << "err" << std::endl;
+    }
+    else 
+    {
+        fout_ << std::string(begin, end);
+        fout_.close();
+    }
+}