add osx support.

Signed-off-by: Sean Ogden <positivelyskewed.sf@gmail.com>

Makefile.am

@@ -28,6 +28,7 @@
 ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
 AM_CXXFLAGS = $(PO6_CFLAGS) $(E_CFLAGS) $(BUSYBEE_CFLAGS) $(WANAL_CXXFLAGS) -fpermissive
 AM_YFLAGS = -d
+TARGET_OS = `uname -s`
 
 BUILT_SOURCES = client/parse_space_y.h
 
@@ -69,7 +70,9 @@ noinst_PROGRAMS = \
 			client/c/testcompile \
 			client/cc/testcompile
 
+if ENABLE_DOCS
 dist_man_MANS = doc/man/hyperdex-daemon.1
+endif
 
 CONFIG_CLEAN_FILES = hyperclient.pc
 
@@ -83,7 +86,11 @@ JAVAROOT = $(abs_top_srcdir)
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = hyperclient.pc
 
+if ENABLE_DOCS
 .PHONY: coverage doc/HyperDex-$(VERSION).pdf
+else
+.PHONY: coverage
+endif
 
 dist-hook:
 	-rm -rf $(distdir)/doc/_build
@@ -218,7 +225,7 @@ hyperdex_daemon_SOURCES = \
 hyperdex_daemon_LDADD = \
 			$(E_LIBS) \
 			$(BUSYBEE_LIBS) -lleveldb \
-			$(REPLICANT_LIBS) -lcityhash -lpopt -lglog -lrt -lpthread
+			$(REPLICANT_LIBS) -lcityhash -lpopt -lglog -lpthread
 hyperdex_daemon_CPPFLAGS = $(CPPFLAGS)
 
 #daemon_test_index_encode_SOURCES = runner.cc daemon/test/index_encode.cc daemon/index_encode.cc common/float_encode.cc
@@ -425,7 +432,8 @@ hyperdex_SOURCES = hyperdex.cc
 hyperdex_CPPFLAGS = -DHYPERDEX_EXEC_DIR=\""$(hyperdexexecdir)\"" $(CPPFLAGS)
 
 hyperdex_initialize_cluster_SOURCES = tools/initialize-cluster.cc
-hyperdex_initialize_cluster_CPPFLAGS = -DHYPERDEX_COORD_LIB=\""$(hyperdexexecdir)/libhypercoordinator.so.0\"" $(CPPFLAGS)
+
+hyperdex_initialize_cluster_CPPFLAGS = -DHYPERDEX_COORD_LIB=\""$(hyperdexexecdir)/libhypercoordinator$(SHEXT)\"" $(CPPFLAGS)
 hyperdex_initialize_cluster_LDADD = libhyperclient.la
 
 hyperdex_coordinator_SOURCES = tools/coordinator.cc
@@ -489,10 +497,12 @@ hyperdex_simple_consistency_stress_test_LDADD = libhyperclient.la -lpopt -lpthre
 
 # These need to be chained so that they'll only build once, and will not rely
 # upon a PHONY rule.
+if ENABLE_DOCS
 doc/man/hyperdex-daemon.1: doc/man/hyperdex-daemon.rst
 	sphinx-build -W -d ${abs_top_builddir}/doc/_build -b man doc doc/man
 
 doc/HyperDex-$(VERSION).pdf:
 	sphinx-build -W -d ${abs_top_builddir}/doc/_build -b latex ${abs_top_srcdir}/doc ${abs_top_builddir}/doc/_build/latex
 	make -C ${abs_top_builddir}/doc/_build/latex all-pdf
 	cp ${abs_top_builddir}/doc/_build/latex/HyperDex.pdf doc/HyperDex-$(VERSION).pdf
+endif

common/configuration.cc

@@ -170,7 +170,7 @@ configuration :: get_schema(const char* sname) const
     {
         if (strcmp(sname, m_spaces[s].name) == 0)
         {
-            return &m_spaces[s].schema;
+            return &m_spaces[s].sc;
         }
     }
 
@@ -363,7 +363,7 @@ configuration :: point_leader(const char* sname, const e::slice& key)
         }
 
         uint64_t h;
-        hash(m_spaces[s].schema, key, &h);
+        hash(m_spaces[s].sc, key, &h);
 
         for (size_t pl = 0; pl < m_spaces[s].subspaces[0].regions.size(); ++pl)
         {
@@ -396,7 +396,7 @@ configuration :: point_leader(const region_id& rid, const e::slice& key)
                 }
 
                 uint64_t h;
-                hash(m_spaces[s].schema, key, &h);
+                hash(m_spaces[s].sc, key, &h);
 
                 for (size_t pl = 0; pl < m_spaces[s].subspaces[0].regions.size(); ++pl)
                 {
@@ -539,15 +539,15 @@ configuration :: lookup_region(const subspace_id& ssid,
                 continue;
             }
 
-            assert(m_spaces[s].schema.attrs_sz == hashes.size());
+            assert(m_spaces[s].sc.attrs_sz == hashes.size());
 
             for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
             {
                 bool matches = true;
 
                 for (size_t a = 0; matches && a < m_spaces[s].subspaces[ss].attrs.size(); ++a)
                 {
-                    assert(a < m_spaces[s].schema.attrs_sz);
+                    assert(a < m_spaces[s].sc.attrs_sz);
                     matches &= m_spaces[s].subspaces[ss].regions[r].lower_coord[a] <= hashes[m_spaces[s].subspaces[ss].attrs[a]] &&
                                hashes[m_spaces[s].subspaces[ss].attrs[a]] <= m_spaces[s].subspaces[ss].regions[r].upper_coord[a];
                 }
@@ -716,10 +716,10 @@ configuration :: debug_dump(std::ostream& out)
         out << "  fault_tolerance=" << s.fault_tolerance << std::endl;
         out << "  schema" << std::endl;
 
-        for (size_t i = 0; i < s.schema.attrs_sz; ++i)
+        for (size_t i = 0; i < s.sc.attrs_sz; ++i)
         {
-            out << "    attribute name=" << s.schema.attrs[i].name
-                      << " type=" << s.schema.attrs[i].type << std::endl;
+            out << "    attribute name=" << s.sc.attrs[i].name
+                      << " type=" << s.sc.attrs[i].type << std::endl;
         }
 
         for (size_t x = 0; x < s.subspaces.size(); ++x)
@@ -730,7 +730,7 @@ configuration :: debug_dump(std::ostream& out)
 
             for (size_t i = 0; i < ss.attrs.size(); ++i)
             {
-                out << " " << s.schema.attrs[ss.attrs[i]].name;
+                out << " " << s.sc.attrs[ss.attrs[i]].name;
             }
 
             out << std::endl;
@@ -847,7 +847,7 @@ configuration :: refill_cache()
             for (size_t y = 0; y < ss.regions.size(); ++y)
             {
                 region& r(ss.regions[y]);
-                m_schemas_by_region.push_back(std::make_pair(r.id.get(), &s.schema));
+                m_schemas_by_region.push_back(std::make_pair(r.id.get(), &s.sc));
                 m_subspace_ids_by_region.push_back(std::make_pair(r.id.get(), ss.id.get()));
 
                 if (r.replicas.empty())

common/float_encode.cc

@@ -28,7 +28,7 @@
 #define __STDC_LIMIT_MACROS
 
 // C
-#include <cmath>
+#include <tr1/cmath>
 #include <cstdlib>
 
 // Linux
@@ -102,7 +102,7 @@ hyperdex :: float_encode(double x)
 {
     uint64_t out = 0xffffffffffffffffULL;
 
-    if (isinf(x))
+    if (std::isinf(x))
     {
         if (x > 0)
         {
@@ -113,7 +113,7 @@ hyperdex :: float_encode(double x)
             out = 0;
         }
     }
-    else if (isnan(x))
+    else if (std::isnan(x))
     {
         out = 0xfff0000000000000ULL + 3;
     }

common/hyperspace.cc

@@ -37,7 +37,7 @@ space :: space()
     : id()
     , name("")
     , fault_tolerance()
-    , schema()
+    , sc()
     , subspaces()
     , m_c_strs()
     , m_attrs()
@@ -48,7 +48,7 @@ space :: space(const char* new_name, const hyperdex::schema& sc)
     : id()
     , name(new_name)
     , fault_tolerance()
-    , schema(sc)
+    , sc(sc)
     , subspaces()
     , m_c_strs()
     , m_attrs()
@@ -60,7 +60,7 @@ space :: space(const space& other)
     : id(other.id)
     , name(other.name)
     , fault_tolerance(other.fault_tolerance)
-    , schema(other.schema)
+    , sc(other.sc)
     , subspaces(other.subspaces)
     , m_c_strs()
     , m_attrs()
@@ -75,11 +75,11 @@ space :: ~space() throw ()
 bool
 space :: validate() const
 {
-    for (size_t i = 0; i < schema.attrs_sz; ++i)
+    for (size_t i = 0; i < sc.attrs_sz; ++i)
     {
-        for (size_t j = i + 1; j < schema.attrs_sz; ++j)
+        for (size_t j = i + 1; j < sc.attrs_sz; ++j)
         {
-            if (strcmp(schema.attrs[i].name, schema.attrs[j].name) == 0)
+            if (strcmp(sc.attrs[i].name, sc.attrs[j].name) == 0)
             {
                 return false;
             }
@@ -101,7 +101,7 @@ space :: validate() const
 
         for (size_t j = 0; j < subspaces[i].attrs.size(); ++j)
         {
-            if (subspaces[i].attrs[j] >= schema.attrs_sz)
+            if (subspaces[i].attrs[j] >= sc.attrs_sz)
             {
                 return false;
             }
@@ -125,7 +125,7 @@ space :: operator = (const space& rhs)
     id = rhs.id;
     name = rhs.name;
     fault_tolerance = rhs.fault_tolerance;
-    schema = rhs.schema;
+    sc = rhs.sc;
     subspaces = rhs.subspaces;
     reestablish_backing();
     return *this;
@@ -137,30 +137,30 @@ space :: reestablish_backing()
     // Compute the size of the c_strs backing
     size_t sz = strlen(name) + 1;
 
-    for (size_t i = 0; i < schema.attrs_sz; ++i)
+    for (size_t i = 0; i < sc.attrs_sz; ++i)
     {
-        sz += strlen(schema.attrs[i].name) + 1;
+        sz += strlen(sc.attrs[i].name) + 1;
     }
 
     // Create the two new backings
     m_c_strs = new char[sz];
-    m_attrs = new attribute[schema.attrs_sz];
+    m_attrs = new attribute[sc.attrs_sz];
     char* ptr = m_c_strs.get();
     sz = strlen(name) + 1;
     memmove(ptr, name, sz);
     name = ptr;
     ptr += sz;
 
-    for (size_t i = 0; i < schema.attrs_sz; ++i)
+    for (size_t i = 0; i < sc.attrs_sz; ++i)
     {
-        m_attrs[i].type = schema.attrs[i].type;
-        sz = strlen(schema.attrs[i].name) + 1;
-        memmove(ptr, schema.attrs[i].name, sz);
+        m_attrs[i].type = sc.attrs[i].type;
+        sz = strlen(sc.attrs[i].name) + 1;
+        memmove(ptr, sc.attrs[i].name, sz);
         m_attrs[i].name = ptr;
         ptr += sz;
     }
 
-    schema.attrs = m_attrs.get();
+    sc.attrs = m_attrs.get();
 }
 
 e::buffer::packer
@@ -169,12 +169,12 @@ hyperdex :: operator << (e::buffer::packer pa, const space& s)
     e::slice name;
     uint16_t num_subspaces = s.subspaces.size();
     name = e::slice(s.name, strlen(s.name));
-    pa = pa << s.id.get() << name << s.fault_tolerance << s.schema.attrs_sz << num_subspaces;
+    pa = pa << s.id.get() << name << s.fault_tolerance << s.sc.attrs_sz << num_subspaces;
 
-    for (size_t i = 0; i < s.schema.attrs_sz; ++i)
+    for (size_t i = 0; i < s.sc.attrs_sz; ++i)
     {
-        name = e::slice(s.schema.attrs[i].name, strlen(s.schema.attrs[i].name));
-        pa = pa << name << static_cast<uint16_t>(s.schema.attrs[i].type);
+        name = e::slice(s.sc.attrs[i].name, strlen(s.sc.attrs[i].name));
+        pa = pa << name << static_cast<uint16_t>(s.sc.attrs[i].type);
     }
 
     for (size_t i = 0; i < num_subspaces; ++i)
@@ -192,14 +192,14 @@ hyperdex :: operator >> (e::unpacker up, space& s)
     e::slice name;
     std::vector<e::slice> attrs;
     uint16_t num_subspaces;
-    up = up >> id >> name >> s.fault_tolerance >> s.schema.attrs_sz >> num_subspaces;
+    up = up >> id >> name >> s.fault_tolerance >> s.sc.attrs_sz >> num_subspaces;
     s.id = space_id(id);
-    s.m_attrs = new attribute[s.schema.attrs_sz];
-    s.schema.attrs = s.m_attrs.get();
+    s.m_attrs = new attribute[s.sc.attrs_sz];
+    s.sc.attrs = s.m_attrs.get();
     size_t sz = name.size() + 1;
 
     // Unpack all attributes
-    for (size_t i = 0; !up.error() && i < s.schema.attrs_sz; ++i)
+    for (size_t i = 0; !up.error() && i < s.sc.attrs_sz; ++i)
     {
         e::slice attr;
         uint16_t type;
@@ -218,7 +218,7 @@ hyperdex :: operator >> (e::unpacker up, space& s)
     *ptr = '\0';
     ++ptr;
 
-    for (size_t i = 0; i < s.schema.attrs_sz; ++i)
+    for (size_t i = 0; i < s.sc.attrs_sz; ++i)
     {
         s.m_attrs[i].name = ptr;
         memmove(ptr, attrs[i].data(), attrs[i].size());
@@ -244,12 +244,12 @@ hyperdex :: pack_size(const space& s)
     size_t sz = sizeof(uint64_t) /* id */
               + sizeof(uint32_t) + strlen(s.name) /* name */
               + sizeof(uint64_t) /* fault_tolerance */
-              + sizeof(uint16_t) /* schema.attrs_sz */
+              + sizeof(uint16_t) /* sc.attrs_sz */
               + sizeof(uint16_t); /* num subspaces */
 
-    for (size_t i = 0; i < s.schema.attrs_sz; ++i)
+    for (size_t i = 0; i < s.sc.attrs_sz; ++i)
     {
-        sz += sizeof(uint32_t) + strlen(s.schema.attrs[i].name)
+        sz += sizeof(uint32_t) + strlen(s.sc.attrs[i].name)
             + sizeof(uint16_t);
     }
 

common/hyperspace.h

@@ -64,7 +64,7 @@ class space
         space_id id;
         const char* name;
         uint64_t fault_tolerance;
-        hyperdex::schema schema;
+        hyperdex::schema sc;
         std::vector<subspace> subspaces;
 
     private:

common/serialization.cc

@@ -50,9 +50,12 @@ hyperdex :: operator << (e::buffer::packer lhs, const po6::net::ipaddr& rhs)
         rhs.pack(&sa, 0);
 #ifdef _MSC_VER
         memmove(data, &sa.sin6_addr.u.Byte, 16);
+#elif defined __APPLE__
+        memmove(data, &sa.sin6_addr.__u6_addr.__u6_addr8, 16);
 #else
         memmove(data, &sa.sin6_addr.__in6_u.__u6_addr8, 16);
 #endif
+
     }
     else
     {
@@ -88,6 +91,8 @@ hyperdex :: operator >> (e::unpacker lhs, po6::net::ipaddr& rhs)
         in6_addr ia;
 #ifdef _MSC_VER
         memmove(ia.u.Byte, rem.data(), 16);
+#elif defined __APPLE__
+        memmove(ia.__u6_addr.__u6_addr8, rem.data(), 16);
 #else
         memmove(ia.__in6_u.__u6_addr8, rem.data(), 16);
 #endif