Major changes, no longer uses mac ids to generate ids, instead rely on consumer to provide a machine id or fallbacks to ipv4

Author: tangledbytes

binding.gyp

@@ -4,7 +4,12 @@
         "cflags!": [ "-fno-exceptions" ],
         "cflags_cc!": [ "-fno-exceptions" ],
         "sources": [
-            "cppsrc/main.cpp"
+            "cppsrc/main.cpp",
+            "cppsrc/generate_hash.cpp",
+            "cppsrc/ipaddress.cpp"
+        ],
+        "cflags_cc": [
+            "-std=c++17"
         ],
         'include_dirs': [
             "<!@(node -p \"require('node-addon-api').include\")"

cppsrc/generate_hash.cpp

@@ -0,0 +1,13 @@
+#include "generate_hash.h"
+
+int generate_hash(const char *str, int s)
+{
+    int result = 0;
+    const int prime = 31;
+    for (int i = 0; i < s; ++i)
+    {
+        result = str[i] + (result * prime);
+    }
+
+    return result;
+}

cppsrc/generate_hash.h

@@ -0,0 +1,3 @@
+#pragma once
+
+int generate_hash(const char *str, int s);

cppsrc/ipaddress.cpp

@@ -0,0 +1,55 @@
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <iostream>
+
+#include "ipaddress.h"
+
+GET_IP_RES getIP(char *ip)
+{
+    int sock = socket(PF_INET, SOCK_DGRAM, 0);
+    sockaddr_in loopback;
+
+    if (sock == -1)
+    {
+        std::cerr << "Could not socket\n";
+        return GET_IP_RES::ERR_COULD_NOT_SOCKET;
+    }
+
+    std::memset(&loopback, 0, sizeof(loopback));
+    loopback.sin_family = AF_INET;
+    loopback.sin_addr.s_addr = INADDR_LOOPBACK; // using loopback ip address
+    loopback.sin_port = htons(9);               // using debug port
+
+    if (connect(sock, reinterpret_cast<sockaddr *>(&loopback), sizeof(loopback)) == -1)
+    {
+        close(sock);
+        std::cerr << "Could not connect\n";
+        return GET_IP_RES::ERR_COULD_NOT_CONNECT;
+    }
+
+    socklen_t addrlen = sizeof(loopback);
+    if (getsockname(sock, reinterpret_cast<sockaddr *>(&loopback), &addrlen) == -1)
+    {
+        close(sock);
+        std::cerr << "Could not getsockname\n";
+        return GET_IP_RES::ERR_COULD_NOT_GET_SOCKETNAME;
+    }
+
+    close(sock);
+
+    char buf[INET_ADDRSTRLEN];
+    if (inet_ntop(AF_INET, &loopback.sin_addr, buf, INET_ADDRSTRLEN) == 0x0)
+    {
+        std::cerr << "Could not inet_ntop\n";
+        return GET_IP_RES::ERR_COULD_NOT_GET_INET_NTOP;
+    }
+    else
+    {
+        std::strcpy(ip, buf);
+        return GET_IP_RES::SUCCESS;
+    }
+}

cppsrc/ipaddress.h

@@ -0,0 +1,13 @@
+#pragma once
+
+enum class GET_IP_RES : int
+{
+    SUCCESS,
+    ERR_COULD_NOT_SOCKET,
+    ERR_COULD_NOT_CONNECT,
+    ERR_COULD_NOT_GET_SOCKETNAME,
+    ERR_COULD_NOT_GET_INET_NTOP
+};
+
+// Returns IPv4 of the current machine
+GET_IP_RES getIP(char *);

cppsrc/main.cpp

@@ -9,34 +9,37 @@
 #include <chrono>
 #include <thread>
 
+#include "ipaddress.h"
+#include "generate_hash.h"
+
 // ////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Total number of bits allocated to an ID
 */
-int TOTAL_BITS = 64;
+constexpr int TOTAL_BITS = 64;
 
 /**
  * Total number of bits allocated to an epoch timestamp
 */
-int EPOCH_BITS = 42;
+constexpr int EPOCH_BITS = 42;
 
 /**
  * Total number of bits allocated to an node/machine id
 */
-int NODE_ID_BITS = 10;
+constexpr int NODE_ID_BITS = 12;
 
 /**
  * Total number of bits allocated to an sequencing
 */
-int SEQUENCE_BITS = 12;
+constexpr int SEQUENCE_BITS = 10;
 
 /** 
  * Max node that can be used
 */
-uint64_t maxNodeId = std::pow(2, NODE_ID_BITS) - 1;
+constexpr uint64_t maxNodeId = (1 << NODE_ID_BITS) - 1;
 
-uint64_t maxSequence = std::pow(2, SEQUENCE_BITS) - 1;
+constexpr uint64_t maxSequence = (1 << SEQUENCE_BITS) - 1;
 
 // ////////////////////////////////////////////////////////////////////////////////////////
 
@@ -46,9 +49,11 @@ uint64_t maxSequence = std::pow(2, SEQUENCE_BITS) - 1;
  * so that the hashed value is always smaller than maxNodeID 
  * which is 10 bits in size
 */
-int nodeID(std::string macID)
+int nodeID()
 {
-    return std::hash<std::string>()(macID) % maxNodeId;
+    char ip[16];
+    getIP(ip);
+    return generate_hash(ip, 16) & maxNodeId;
 }
 
 // ////////////////////////////////////////////////////////////////////////////////////////
@@ -69,19 +74,18 @@ class Snowflake : public Napi::ObjectWrap<Snowflake>
 private:
     static Napi::FunctionReference constructor;
     uint64_t _lastTimestamp;
-    uint64_t _CUSTOM_EPOCH;
-    int _sequence;
-    std::string _macID;
-    int _nodeID;
+    uint64_t _CUSTOM_EPOCH = 1546300800000;
+    uint16_t _sequence;
+    uint16_t _nodeID;
     Napi::Value getUniqueIDBigInt(const Napi::CallbackInfo &info);
-    Napi::Value getUniqueID(const Napi::CallbackInfo &info);
     Napi::Value getTimestampFromID(const Napi::CallbackInfo &info);
+    Napi::Value getNodeIDFomID(const Napi::CallbackInfo &info);
 };
 
 Napi::Object Snowflake::Init(Napi::Env env, Napi::Object exports)
 {
     // This method is used to hook the accessor and method callbacks
-    Napi::Function func = DefineClass(env, "Snowflake", {InstanceMethod("getUniqueIDBigInt", &Snowflake::getUniqueIDBigInt), InstanceMethod("getUniqueID", &Snowflake::getUniqueID), InstanceMethod("getTimestampFromID", &Snowflake::getTimestampFromID)});
+    auto func = DefineClass(env, "Snowflake", {InstanceMethod("getUniqueID", &Snowflake::getUniqueIDBigInt), InstanceMethod("getTimestampFromID", &Snowflake::getTimestampFromID), InstanceMethod("getNodeIDFromID", &Snowflake::getNodeIDFomID)});
 
     // Create a peristent reference to the class constructor. This will allow
     // a function called on a class prototype and a function
@@ -97,14 +101,20 @@ Napi::Object Snowflake::Init(Napi::Env env, Napi::Object exports)
 
 Snowflake::Snowflake(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Snowflake>(info)
 {
-    Napi::String value = info[0].As<Napi::String>();
-    Napi::Number EPOCH = info[1].As<Napi::Number>();
+    auto argLen = info.Length();
+    this->_CUSTOM_EPOCH = info[0].As<Napi::Number>().Int64Value();
+    switch (argLen)
+    {
+    case 2:
+        this->_nodeID = info[1].As<Napi::Number>().Int32Value() & maxNodeId;
+        break;
+    default:
+        this->_nodeID = nodeID();
+        break;
+    }
 
-    this->_macID = value.Utf8Value();
-    this->_nodeID = nodeID(this->_macID);
     this->_lastTimestamp = 0;
     this->_sequence = 0;
-    this->_CUSTOM_EPOCH = EPOCH.Int64Value();
 }
 
 Napi::FunctionReference Snowflake::constructor;
@@ -113,25 +123,25 @@ Napi::FunctionReference Snowflake::constructor;
  * Takes the current timestamp, last timestamp, sequence, and macID
  * and generates a 64 bit long integer by performing bitwise operations
  * 
- * First 42 bits are filled with current timestamp
- * Next 10 bits are filled with the node/machine id (max size can be 1024)
+ * First 41 bits are filled with current timestamp
+ * Next 10 bits are filled with the node/machine id (max size can be 4096)
  * Next 12 bits are filled with sequence which ensures that even if timestamp didn't change the value will be generated
  * 
- * Function can theorotically generate 4096 unique values within a millisecond without repeating values
+ * Function can theorotically generate 1024 unique values within a millisecond without repeating values
 */
 Napi::Value Snowflake::getUniqueIDBigInt(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
+    auto env = info.Env();
 
     uint64_t currentTimestamp = getCurrentTime() - this->_CUSTOM_EPOCH;
 
     if (currentTimestamp == this->_lastTimestamp)
     {
         this->_sequence = (this->_sequence + 1) & maxSequence;
-        if (this->_sequence == 0)
+        if (!this->_sequence)
         {
             std::this_thread::sleep_for(std::chrono::milliseconds(1));
-            currentTimestamp++;
+            ++currentTimestamp;
         }
     }
     else
@@ -141,58 +151,57 @@ Napi::Value Snowflake::getUniqueIDBigInt(const Napi::CallbackInfo &info)
 
     this->_lastTimestamp = currentTimestamp;
 
-    uint64_t id = currentTimestamp << (TOTAL_BITS - EPOCH_BITS);
+    uint64_t id{};
+    id = currentTimestamp << (TOTAL_BITS - EPOCH_BITS);
     id |= (this->_nodeID << (TOTAL_BITS - EPOCH_BITS - NODE_ID_BITS));
     id |= this->_sequence;
 
     return Napi::BigInt::New(env, id);
 }
 
 /**
- * Convert generated number 64 bit integer to a string
+ * Returns timestamp at which the id was generated by retreiving
+ * the first 41 bits of the id, which are filled with current timestamp
+ * bits
 */
-Napi::Value Snowflake::getUniqueID(const Napi::CallbackInfo &info)
+Napi::Value Snowflake::getTimestampFromID(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
+    auto env = info.Env();
+    uint64_t uniqueID{};
 
-    uint64_t currentTimestamp = getCurrentTime() - this->_CUSTOM_EPOCH;
+    if (info[0].IsString())
+    {
+        auto first = info[0].As<Napi::String>();
 
-    if (currentTimestamp == this->_lastTimestamp)
+        uniqueID = std::stoull(first.Utf8Value());
+    }
+    else if (info[0].IsNumber())
     {
-        this->_sequence = (this->_sequence + 1) & maxSequence;
-        if (this->_sequence == 0)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-            currentTimestamp++;
-        }
+        uniqueID = info[0].As<Napi::Number>().Int64Value();
     }
     else
     {
-        this->_sequence = 0;
+        Napi::TypeError::New(env, "Number or string expected").ThrowAsJavaScriptException();
     }
 
-    this->_lastTimestamp = currentTimestamp;
-
-    uint64_t id = currentTimestamp << (TOTAL_BITS - EPOCH_BITS);
-    id |= (this->_nodeID << (TOTAL_BITS - EPOCH_BITS - NODE_ID_BITS));
-    id |= this->_sequence;
+    uint64_t timestamp = uniqueID >> (TOTAL_BITS - EPOCH_BITS);
 
-    return Napi::String::New(env, std::to_string(id));
+    return Napi::Number::New(env, timestamp + _CUSTOM_EPOCH);
 }
 
 /**
  * Returns timestamp at which the id was generated by retreiving
  * the first 42 bits of the id, which are filled with current timestamp
  * bits
 */
-Napi::Value Snowflake::getTimestampFromID(const Napi::CallbackInfo &info)
+Napi::Value Snowflake::getNodeIDFomID(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
+    auto env = info.Env();
     uint64_t uniqueID = 0;
 
     if (info[0].IsString())
     {
-        Napi::String first = info[0].As<Napi::String>();
+        auto first = info[0].As<Napi::String>();
 
         uniqueID = std::stoull(first.Utf8Value());
     }
@@ -205,9 +214,10 @@ Napi::Value Snowflake::getTimestampFromID(const Napi::CallbackInfo &info)
         Napi::TypeError::New(env, "Number or string expected").ThrowAsJavaScriptException();
     }
 
-    uint64_t timestamp = uniqueID >> (TOTAL_BITS - EPOCH_BITS);
+    int BITS = TOTAL_BITS - NODE_ID_BITS - SEQUENCE_BITS;
+    uint16_t machineID = (uniqueID << BITS) >> (BITS + SEQUENCE_BITS);
 
-    return Napi::Number::New(env, timestamp);
+    return Napi::Number::New(env, machineID);
 }
 
 // ////////////////////////////////////////////////////////////////////////////////////////