libcouchbase 0.0.1

data/ext/libcouchbase/tests/mocksupport/procutil.h

@@ -0,0 +1,89 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LCB_PROCUTIL_H
+#define LCB_PROCUTIL_H
+
+#ifdef _WIN32
+#include <windows.h>
+#include <process.h>
+#else
+#include <sys/types.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef struct {
+        /** Full command line to launch */
+        const char *name;
+
+        /** Name of file to which output should be redirected. Optional */
+        const char *redirect;
+
+        /** Whether this should be a foreground process (uses 'system') */
+        int interactive;
+
+        /** Exit status */
+        int status;
+
+        /** Whether the application exited*/
+        int exited;
+
+        /** PLATFORM-SPECIFIC */
+#ifdef _WIN32
+        STARTUPINFO si;
+        PROCESS_INFORMATION pi;
+#else
+        pid_t pid;
+#endif
+    } child_process_t;
+
+
+    /**
+     * Create a new process.
+     * Returns 0 on success and nonzero on failure.
+     */
+    int create_process(child_process_t *process);
+
+    /**
+     * Try to kill the process. If 'force' is specified, the process is killed
+     * using more "forceful" action
+     */
+    void kill_process(child_process_t *process, int force);
+
+    /**
+     * Wait until a process has terminated.
+     * If tmosec is negative, it polls without blocking,
+     * if it is 0, it waits forever. If it is
+     * positive, it will wait for that many seconds, polling intermittently.
+     *
+     * Returns 0 if the process exited. nonzero on timeout
+     */
+    int wait_process(child_process_t *process, int tmosec);
+
+    /**
+     * Cleans up any resources opened while creating the process.
+     */
+    void cleanup_process(child_process_t *process);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/tests/mocksupport/server.c

@@ -0,0 +1,391 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-2012 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#include "config.h"
+#include "server.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <ctype.h>
+
+#ifndef _WIN32
+#define DIRSEP "/"
+#include <pthread.h>
+#include <sys/wait.h>
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <signal.h>
+#ifdef linux
+#undef ntohs
+#undef ntohl
+#undef htons
+#undef htonl
+#endif
+#else
+#define DIRSEP "\\"
+#include <io.h> /* for access() */
+#endif /* ! _WIN32 */
+
+static int create_monitor(struct test_server_info *info)
+{
+    struct addrinfo hints, *next, *ai;
+    int error;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_flags = AI_PASSIVE;
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    info->sock = -1;
+    error = getaddrinfo(NULL, "0", &hints, &ai);
+    if (error != 0) {
+#ifdef _WIN32
+        if (0) {
+#else
+        if (error != EAI_SYSTEM) {
+#endif
+            fprintf(stderr, "getaddrinfo failed: %s\n",
+                    gai_strerror(error));
+        } else {
+            perror("getaddrinfo failed:");
+        }
+        return 0;
+    }
+
+    for (next = ai; next; next = next->ai_next) {
+        int flags = 1;
+        socklen_t len;
+
+        if ((info->sock = socket(next->ai_family,
+                                 next->ai_socktype,
+                                 next->ai_protocol)) == -1) {
+            continue;
+        }
+
+        setsockopt(info->sock, SOL_SOCKET, SO_REUSEADDR,
+                   (void *)&flags, sizeof(flags));
+
+        if (bind(info->sock, next->ai_addr, next->ai_addrlen) == -1) {
+            closesocket(info->sock);
+            info->sock = -1;
+            continue;
+        } else if (listen(info->sock, 10) == -1) {
+            closesocket(info->sock);
+            info->sock = -1;
+            continue;
+        }
+
+        /* Ok, I've got a working socket :) */
+        len = sizeof(info->storage);
+        if (getsockname(info->sock, (struct sockaddr *)&info->storage, &len) == -1) {
+            closesocket(info->sock);
+            info->sock = -1;
+            continue;
+        }
+        if (next->ai_addr->sa_family == AF_INET) {
+            info->port = ntohs((*(struct sockaddr_in *)&info->storage).sin_port);
+        } else {
+            info->port = ntohs((*(struct sockaddr_in6 *)&info->storage).sin6_port);
+        }
+    }
+
+    freeaddrinfo(ai);
+    return info->sock != -1;
+}
+
+static void wait_for_server(const char *port)
+{
+    struct addrinfo hints, *next, *ai;
+    int sock = -1;
+    int error;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_flags = AI_PASSIVE;
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    error = getaddrinfo("localhost", port, &hints, &ai);
+    if (error != 0) {
+#ifndef _WIN32
+        if (error != EAI_SYSTEM) {
+#else
+        if (0) {
+#endif
+            fprintf(stderr, "getaddrinfo failed: %s\n",
+                    gai_strerror(error));
+        } else {
+            perror("getaddrinfo failed:");
+        }
+        abort();
+    }
+
+    while (1) {
+        for (next = ai; next; next = next->ai_next) {
+            if ((sock = socket(next->ai_family,
+                               next->ai_socktype,
+                               next->ai_protocol)) == -1) {
+                continue;
+            }
+
+            if (connect(sock, next->ai_addr, next->ai_addrlen) == 0) {
+                closesocket(sock);
+                freeaddrinfo(ai);
+                return;
+            }
+
+            closesocket(sock);
+        }
+        usleep(250);
+    }
+}
+
+/**
+ * Parse server parameters from environment;
+ * format is host,bucket,username,password
+ */
+static int parse_server_conf(struct test_server_info *info, const char *param)
+{
+    char *strings[10] = { NULL };
+    int curix = 0;
+    char *param_copy = strdup(param);
+    param = param_copy;
+
+    while (*param && curix < 10) {
+        const char *curfld;
+        char *curval;
+        size_t diff;
+
+        for (curfld = param; *param && *param != ','; param++);
+        diff = (param - curfld);
+        curval = calloc(1, diff + 1);
+        curval[diff] = '\0';
+        memcpy(curval, curfld, diff);
+        strings[curix++] = curval;
+        if (*param == ',') {
+            param++;
+        }
+    }
+
+    info->http = strings[0];
+    info->bucket = strings[1];
+    info->username = strings[2];
+    info->password = strings[3];
+
+    free(param_copy);
+
+    if (!info->http) {
+        fprintf(stderr, "Must have node entry point for real cluster test\n");
+        return 0;
+    }
+    return 1;
+}
+
+static int start_mock_process(struct test_server_info *info, char **argv)
+{
+    char argbuf[4096] = { 0 };
+    char **arg;
+    for (arg = argv; *arg; arg++) {
+        strcat(argbuf, *arg);
+        strcat(argbuf, " ");
+    }
+
+    memset(&info->process, 0, sizeof(info->process));
+    info->process.name = argbuf;
+
+    return create_process(&info->process);
+}
+
+static void kill_mock_process(struct test_server_info *info)
+{
+    kill_process(&info->process, 1);
+    wait_process(&info->process, 1);
+    cleanup_process(&info->process);
+}
+
+#ifndef _WIN32
+#define WRAPPER_BASE "start_mock.sh"
+#else
+#define WRAPPER_BASE "start_mock.bat"
+#endif
+
+static void negotiate_mock_connection(struct test_server_info *info)
+{
+    char buffer[1024];
+    lcb_ssize_t offset;
+    lcb_ssize_t nr;
+    int ii;
+
+    /* wait until the server connects */
+    for (ii = 0; ii < 10; ii++) {
+        info->client = accept(info->sock, NULL, NULL);
+        if (info->client == -1) {
+            /* running this in gdb on OS X, I got an EINTR a few times */
+            if (errno == EINTR) {
+                fprintf(stderr, "start_mock_server: Sleeping 1 second on EINTR\n");
+                sleep(1);
+            } else {
+                perror("start_mock_server");
+                abort();
+            }
+        } else {
+            break;
+        }
+    }
+
+    assert(info->client != -1);
+    /* Get the port number of the http server */
+    offset = snprintf(buffer, sizeof(buffer), "localhost:");
+    nr = recv(info->client, buffer + offset,
+              sizeof(buffer) - (size_t)offset - 1, 0);
+    assert(nr > 0);
+    buffer[nr + offset] = '\0';
+    info->http = strdup(buffer);
+    wait_for_server(buffer + offset);
+}
+
+static int start_mock_server(struct test_server_info *info, char **cmdline)
+{
+
+    char wrapper[1024];
+    char monitor[1024];
+    char *argv[1024];
+#ifdef _WIN32
+    int access_mode = 00;
+#else
+    int access_mode = X_OK;
+#endif
+    const char *srcdir = getenv("srcdir");
+
+
+    if (srcdir == NULL) {
+        srcdir = ".";
+    }
+
+    snprintf(wrapper, sizeof(wrapper),
+             "%s" DIRSEP "tests" DIRSEP WRAPPER_BASE,
+             srcdir);
+
+    if (access(wrapper, access_mode) == -1) {
+        fprintf(stderr, "Failed to locate \"%s\": %s\n",
+                wrapper,
+                strerror(errno));
+        return 0;
+    }
+
+
+    if (!create_monitor(info)) {
+        return 0;
+    }
+
+    {
+        int arg = 0;
+        argv[arg++] = (char *)wrapper;
+        sprintf(monitor, "--harakiri-monitor=localhost:%d", info->port);
+        argv[arg++] = monitor;
+
+        if (cmdline != NULL) {
+            int ii = 0;
+            while (cmdline[ii] != NULL && arg < 1022) {
+                argv[arg++] = cmdline[ii++];
+            }
+        }
+        argv[arg++] = NULL;
+
+    }
+
+    start_mock_process(info, argv);
+    negotiate_mock_connection(info);
+    sleep(1); /* give it a bit time to initialize itself */
+    return 1;
+}
+
+const void *start_test_server(char **cmdline)
+{
+    const char *clconf = getenv(LCB_TEST_REALCLUSTER_ENV);
+    int server_ok = 0;
+    struct test_server_info *info = calloc(1, sizeof(*info));
+
+#ifdef _WIN32
+    /** Winsock boilerplate */
+    {
+        WSADATA wsaData;
+        if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0) {
+            fprintf(stderr, "WSAStartup failed. Abort\n");
+            abort();
+        }
+    }
+#endif
+
+    if (info == NULL) {
+        return NULL;
+    }
+
+    if (clconf) {
+        server_ok = parse_server_conf(info, clconf);
+        info->is_mock = 0;
+    } else {
+        server_ok = start_mock_server(info, cmdline);
+        info->is_mock = 1;
+    }
+
+    if (!server_ok) {
+        fprintf(stderr, "Couldn't setup server!\n");
+        abort();
+    }
+
+    return info;
+}
+
+void shutdown_mock_server(const void *handle)
+{
+    struct test_server_info *info = (void *)handle;
+    if (info != NULL) {
+        free(info->http);
+        free(info->bucket);
+        free(info->username);
+        free(info->password);
+        if (info->is_mock) {
+            closesocket(info->client);
+            closesocket(info->sock);
+            kill_mock_process(info);
+        }
+        free((void *)handle);
+    }
+}
+
+const char *get_mock_http_server(const void *handle)
+{
+    struct test_server_info *info = (void *)handle;
+    return info->http;
+}
+
+void get_mock_std_creds(const void *handle, const char **userp, const char **passp)
+{
+    const struct test_server_info *info = handle;
+    if (info->is_mock) {
+        *userp = NULL;
+        *passp = NULL;
+    } else {
+        *userp = info->username;
+        *passp = info->password;
+    }
+}
+
+int is_using_real_cluster(void)
+{
+    return getenv(LCB_TEST_REALCLUSTER_ENV) != NULL;
+}