test libev well

Author: wuxiang

libev/example/entry.cpp

@@ -0,0 +1,108 @@
+#include <iostream>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <cstring>
+#include <cstdio>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ev.h>
+
+#include "asyn_server.h"
+#include "nb_net_tool.h"
+
+struct ev_loop*  loop = NULL;
+int server = 0;
+int cli_fd = 0;
+
+//void accept_cb(EV_P_ ev_io* p, int enent)
+void accept_cb(struct ev_loop* loop, struct ev_io* io, int event)
+{
+    printf("accept  handler\n");
+    struct sockaddr_in  cli_addr;
+    socklen_t len = sizeof(cli_addr);
+    cli_fd = accept(server, (struct sockaddr*)&cli_addr, &len);
+    if (-1 == cli_fd)
+    {
+        printf("accept failed\n");
+    }
+
+    //ev_io_stop(EV_A_ p);
+    //ev_break(EV_A_ EVBREAK_ONE);
+
+    //p = (ev_io*)malloc(sizeof(ev_io));
+    //ev_io_init(p, accept_cb, 0, EV_READ);
+    //ev_io_start(loop, p);
+}
+
+
+//void cb(EV_P_ ev_io* p, int enent)
+//{
+//    printf("stdin read happen\n");
+//    //ev_io_stop(EV_A_ p);
+//    //ev_break(EV_A_ EVBREAK_ONE);
+//}
+
+int main()
+{
+    // prepare io
+    //struct ev_loop* loop  = EV_DEFAULT;
+    loop  = EV_DEFAULT;
+    ev_io   accept_id;
+    //ev_io   tmp;
+
+    //int server = socket(AF_INET, SOCK_STREAM, 0);
+    server = socket(AF_INET, SOCK_STREAM, 0);
+
+    struct sockaddr_in   serv_addr;
+    bzero(&serv_addr, sizeof(struct sockaddr_in));
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    serv_addr.sin_port = htons(10026);
+
+    sigset_t     new_mask;
+    sigset_t     old_mask;
+    sigfillset(&new_mask);
+    pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask);
+    printf("start binding\n");
+    if (0 != bind(server, (struct sockaddr*)&serv_addr, sizeof(serv_addr)))
+    {
+        printf("error happen when use bind\n");
+    }
+
+    printf("start listening\n");
+    if (0 != listen(server, 10))
+    {
+        printf("error happen when use listen\n");
+    }
+
+    printf("ev io starting\n");
+    ev_io_init(&accept_id, accept_cb, server, EV_READ);
+    ev_io_start(loop, &accept_id);
+
+    //ev_io_init(&tmp, cb, 0, EV_READ);
+    //ev_io_start(loop, &tmp);
+
+    ev_run(loop, 0);
+    printf("\nev io end\n");
+
+    sigset_t    wait_mask;
+    sigemptyset(&wait_mask);
+    sigaddset(&wait_mask, SIGINT);
+    sigaddset(&wait_mask, SIGQUIT);
+    sigaddset(&wait_mask, SIGTERM);
+    pthread_sigmask(SIG_BLOCK, &wait_mask, 0);
+    int flag = 0;
+    sigwait(&wait_mask, &flag);
+
+    printf("ev io stoping\n");
+    //ev_io_stop(EV_A_ &accept_id);
+    //ev_break(EV_A_ EVBREAK_ALL);
+    printf("ev io has stoped\n");
+
+    return 0;
+}
+
+

libev/example/libev++.cpp

@@ -0,0 +1,213 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ev++.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <resolv.h>
+#include <errno.h>
+#include <list>
+ 
+//
+//  Buffer class - allow for output buffering such that it can be written out
+//                 into async pieces
+//
+struct Buffer {
+    char    *data;
+    ssize_t len;
+    ssize_t pos;
+ 
+    Buffer(const char *bytes, ssize_t nbytes) {
+        pos = 0;
+        len = nbytes;
+        data = new char[nbytes];
+        memcpy(data, bytes, nbytes);
+    }
+ 
+    virtual ~Buffer() {
+        delete [] data;
+    }
+ 
+    char *dpos() {
+        return data + pos;
+    }
+ 
+    ssize_t nbytes() {
+        return len - pos;
+    }
+};
+ 
+//
+//  A single instance of a non-blocking Echo handler
+//
+class EchoInstance {
+private:
+    ev::io      io;
+    static int total_clients;
+ 
+    // Buffers that are pending write
+    std::list<Buffer*>   write_queue;
+ 
+    // Generic callback
+    void callback(ev::io &watcher, int revents) {
+        if (EV_ERROR & revents) {
+            perror("got invalid event");
+            return;
+        }
+ 
+        if (revents & EV_READ)
+            read_cb(watcher);
+ 
+        if (revents & EV_WRITE)
+            write_cb(watcher);
+ 
+        if (write_queue.empty()) {
+            io.set(ev::READ);
+        } else {
+            io.set(ev::READ|ev::WRITE);
+        }
+    }
+ 
+    // Socket is writable
+    void write_cb(ev::io &watcher) {
+        if (write_queue.empty()) {
+            io.set(ev::READ);
+            return;
+        }
+ 
+        Buffer* buffer = write_queue.front();
+ 
+        ssize_t written = write(watcher.fd, buffer->dpos(), buffer->nbytes());
+        if (written < 0) {
+            perror("read error");
+            return;
+        }
+ 
+        buffer->pos += written;
+        if (buffer->nbytes() == 0) {
+            write_queue.pop_front();
+            delete buffer;
+        }
+    }
+ 
+    // Receive message from client socket
+    void read_cb(ev::io &watcher) {
+        char    buffer[1024];
+ 
+        ssize_t  nread = recv(watcher.fd, buffer, sizeof(buffer), 0);
+ 
+        if (nread < 0) {
+            perror("read error");
+            return;
+        }
+ 
+        if (nread == 0) {
+            // Gack - we're deleting ourself inside of ourself!
+            delete this;
+        } else {
+            // Send message bach to the client
+            write_queue.push_back(new Buffer(buffer, nread));
+        }
+    }
+ 
+    // effictivly a close and a destroy
+    virtual ~EchoInstance() {
+        // Stop and free watcher if client socket is closing
+        io.stop();
+ 
+        printf("%d client(s) connected.\n", --total_clients);
+    }
+ 
+public:
+    EchoInstance(int s) {
+        fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK);
+ 
+        printf("Got connection\n");
+        total_clients++;
+ 
+        io.set<EchoInstance, &EchoInstance::callback>(this);
+ 
+        io.start(s, ev::READ);
+    }
+};
+ 
+class EchoServer {
+private:
+    ev::io      io;
+    ev::sig     sio;
+    int         s;
+ 
+public:
+ 
+    void io_accept(ev::io &watcher, int revents) {
+        if (EV_ERROR & revents) {
+            perror("got invalid event");
+            return;
+        }
+ 
+        struct sockaddr_in client_addr;
+        socklen_t client_len = sizeof(client_addr);
+ 
+        int client_sd = accept(watcher.fd, (struct sockaddr *)&client_addr, &client_len);
+ 
+        if (client_sd < 0) {
+            perror("accept error");
+            return;
+        }
+ 
+        EchoInstance *client = new EchoInstance(client_sd);
+    }
+ 
+    static void signal_cb(ev::sig &signal, int revents) {
+        signal.loop.break_loop();
+    }
+ 
+    EchoServer(int port) {
+        printf("Listening on port %d\n", port);
+ 
+        struct sockaddr_in addr;
+ 
+        s = socket(PF_INET, SOCK_STREAM, 0);
+ 
+        addr.sin_family = AF_INET;
+        addr.sin_port   = htons(port);
+        addr.sin_addr.s_addr = INADDR_ANY;
+ 
+        if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
+            perror("bind");
+        }
+ 
+        fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK);
+ 
+        listen(s, 5);
+ 
+        io.set<EchoServer, &EchoServer::io_accept>(this);
+        io.start(s, ev::READ);
+ 
+        sio.set<&EchoServer::signal_cb>();
+        sio.start(SIGINT);
+    }
+ 
+    virtual ~EchoServer() {
+        shutdown(s, SHUT_RDWR);
+        close(s);
+    }
+};
+ 
+int EchoInstance::total_clients = 0;
+ 
+int main(int argc, char **argv)
+{
+    int     port = 8192;
+ 
+    if (argc > 1)
+        port = atoi(argv[1]);
+ 
+    ev::default_loop    loop;
+    EchoServer          echo(port);
+ 
+    loop.run(0);
+ 
+    return 0;
+}

libev/example/libev-examples/.gitignore

@@ -0,0 +1,3 @@
+bin/
+obj/
+*.dSYM

libev/example/libev-examples/.hg/00changelog.i

@@ -0,0 +1 @@
+default

libev/example/libev-examples/.hg/branch

@@ -0,0 +1,2 @@
+929fc180866cb7315af6c33abc0d4f5f852e4004 61
+929fc180866cb7315af6c33abc0d4f5f852e4004 default

libev/example/libev-examples/.hg/branchheads.cache

@@ -0,0 +1,2 @@
+[paths]
+default = https://bitbucket.org/scassidy/libev-examples

libev/example/libev-examples/.hg/dirstate

@@ -0,0 +1,4 @@
+revlogv1
+store
+fncache
+dotencode