iprange 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4cf4818d4ba6e945d3d11f15edd860b7586bf815
+  data.tar.gz: 10995790fd132aa1bc7100f71b4ddb9f155e75f1
+SHA512:
+  metadata.gz: 0d4ffb3db2965f645f80c92b77fb77b2623cb34c2fbd485426d652cc39678e04d3a173d5dc867825e36613a2bc4c03aeac95c925204ac6bedc79edb318daf273
+  data.tar.gz: f9d801b8bd54dedb193ba169b7aa738bfe1af0fd94fcd10d87135c5359195120eca1c1252664753de46d02b25bbb12035e4bacdf0fb288b1c18548a976bcc35b

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+nginx/logs/

data/.rspec

@@ -0,0 +1,2 @@
+--format doc
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iprange.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Juarez Bochi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# IPRange
+
+Store IP Ranges in Redis as sorted sets for fast retrieval
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'iprange'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iprange
+
+## Usage
+
+    > redis_config = {host: "127.0.0.1"}
+    > range = IPRange::Range.new(redis_config)
+    > range.add("192.168.0.1/24", some: "data", more: "metadata")
+    > range.find("192.168.0.20")
+    => {:range=>"192.168.0.1/24", "some"=>"data", "more"=>"metadata"}
+
+## Notice
+
+This gem relies on [a Redis fork that implements interval sets](https://github.com/hoxworth/redis/tree/2.6-intervals), as described in this [blog post](http://blog.togo.io/how-to/adding-interval-sets-to-redis/).
+
+If your intervals do not, you can try the tag v0.0.1, which uses sorted sets instead of inverval sets.
+
+## Contributing
+
+1. Fork it ( http://github.com/jbochi/iprange/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/gixlg_importer.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'iprange'
+require 'mysql2'
+require 'redis'
+
+mysql_config = {
+  host: "localhost",
+  database: "looking_glass_db",
+  username: "looking_glass_usr",
+  password: "looking_glass_pwd"
+}
+
+redis_config = {}
+
+LAST_UPDATE_TIME_KEY = 'last_update_time'
+
+def update(mysql, redis_config)
+  range = IPRange::Range.new(redis_config)
+  redis = Redis.new(redis_config)
+  last_update_time = redis.get(LAST_UPDATE_TIME_KEY)
+
+  sql =  "SELECT neighbor, prefix, aspath, originas, nexthop, time from prefixes"
+  sql += " WHERE time >= '#{last_update_time}'" if last_update_time
+  sql += " ORDER BY time"
+
+  results = mysql.query(sql)
+  puts "#{results.count} prefixes found since '#{last_update_time}'"
+  results.each_with_index do |row, i|
+    range.add row["prefix"], {
+      as: row["originas"],
+      nexthop: row["nexthop"],
+      router: row["neighbor"],
+      aspath: row["aspath"],
+      timestamp: row["time"]
+    }
+    if ((i + 1) % 10000) == 0
+      puts "10000 rows added"
+      redis.set(LAST_UPDATE_TIME_KEY, row['time'])
+    end
+  end
+end
+
+begin
+  mysql = Mysql2::Client.new mysql_config
+  update mysql, redis_config
+rescue Exception => e
+  puts e.message
+  puts e.backtrace.inspect
+else
+  puts "Done!"
+ensure
+  mysql.close if mysql
+end

data/iprange.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iprange/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iprange"
+  spec.version       = Iprange::VERSION
+  spec.authors       = ["Juarez Bochi"]
+  spec.email         = ["jbochi@gmail.com"]
+  spec.summary       = "IP ranges on Redis"
+  spec.description   = "Save IP ranges on Redis for fast lookup using interval sets."
+  spec.homepage      = "https://github.com/globocom/iprange"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "redis"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/iprange.rb

@@ -0,0 +1,41 @@
+require "iprange/version"
+require "redis"
+require "ipaddr"
+
+module IPRange
+  class Range
+    def initialize(redis_config={}, redis_key="ip_table")
+      @redis = Redis.new redis_config
+      @redis_key = redis_key
+    end
+
+    def remove(range)
+      @redis.irem(@redis_key, range)
+      @redis.del(metadata_key(range))
+    end
+
+    def add(range, metadata={})
+      ipaddr_range = IPAddr.new(range).to_range
+      @redis.iadd(@redis_key, ipaddr_range.first.to_i, ipaddr_range.last.to_i, range)
+      hash = metadata_key(range)
+      @redis.mapped_hmset(hash, metadata) unless metadata.empty?
+    end
+
+    def find(ip)
+      find_all(ip).first
+    end
+
+    def find_all(ip)
+      ipaddr = IPAddr.new(ip)
+      ranges = @redis.istab(@redis_key, ipaddr.to_i)
+      ranges.map do |range|
+        metadata = @redis.hgetall(metadata_key(range))
+        {range: range}.merge(metadata)
+      end
+    end
+
+    def metadata_key(range)
+      "#{@redis_key}:#{range}"
+    end
+  end
+end

data/lib/iprange/version.rb

@@ -0,0 +1,3 @@
+module Iprange
+  VERSION = "0.0.2"
+end

data/nginx/README.md

@@ -0,0 +1,17 @@
+This is a sample Nginx config file to query ips
+
+  $ ./start_nginx.sh
+
+  $ curl -s "localhost:8080/?ip=177.205.166.201" | python -m json.tool
+  {
+      "data": {
+          "as": "18881",
+          "aspath": "18881",
+          "nexthop": "200.219.138.113",
+          "range": "177.205.160.0/20",
+          "router": "201.7.183.65",
+          "timestamp": "2014-03-28 16:00:13 -0300"
+      },
+      "status": "ok"
+  }
+

data/nginx/nginx.conf

@@ -0,0 +1,25 @@
+worker_processes  1;
+pid /tmp/nginx.pid;
+error_log "error.log" error;
+
+events {
+    worker_connections  1024;
+}
+
+
+http {
+    default_type  application/octet-stream;
+    sendfile        on;
+    keepalive_timeout  65;
+
+    server {
+        listen       8080;
+        server_name  localhost;
+
+        location / {
+            set $ip $arg_ip;
+            default_type 'text/plain';
+            content_by_lua_file 'range_lookup.lua';
+        }
+    }
+}

data/nginx/range_lookup.lua

@@ -0,0 +1,52 @@
+local redis = require "redis"
+local cjson = require "cjson"
+
+local function ip_to_i(ip)
+  local o1,o2,o3,o4 = ip:match("(%d%d?%d?)%.(%d%d?%d?)%.(%d%d?%d?)%.(%d%d?%d?)")
+  return 2^24*o1 + 2^16*o2 + 2^8*o3 + o4
+end
+
+local function range_lookup(ip)
+  local red = redis:new()
+  red:set_timeout(1000)
+  local ok, err = red:connect("127.0.0.1", 6379)
+  if not ok then
+    return nil, "failed to connect: " .. err
+  end
+
+  if not ip or ip == "" then
+    return nil, "no ip provided"
+  end
+
+  local res, err = red:istab("ip_table", ip_to_i(ip))
+  if not res then
+    return nil, "failed to get range: " .. err
+  end
+
+  if not res[1] then
+    return nil, "range not found"
+  end
+
+  local range = res[1]
+  local metadata, err = red:hgetall("ip_table:" .. range)
+
+  if err then
+    return nil, "no metadata"
+  end
+
+  local response = {}
+  for i = 1, #metadata, 2 do
+    local key = metadata[i]
+    local value = metadata[i + 1]
+    response[key] = value
+  end
+  response.range = range
+  return response, nil
+end
+
+local response, err = range_lookup(ngx.var.ip)
+if err then
+  ngx.say(cjson.encode({status="error", msg=err}))
+else
+  ngx.say(cjson.encode({status="ok", data=response}))
+end

data/nginx/redis.lua

@@ -0,0 +1,466 @@
+-- Copyright (C) Yichun Zhang (agentzh), CloudFlare Inc.
+
+
+local sub = string.sub
+local byte = string.byte
+local tcp = ngx.socket.tcp
+local concat = table.concat
+local null = ngx.null
+local pairs = pairs
+local unpack = unpack
+local setmetatable = setmetatable
+local tonumber = tonumber
+local error = error
+
+
+local ok, new_tab = pcall(require, "table.new")
+if not ok then
+    new_tab = function (narr, nrec) return {} end
+end
+
+
+local _M = new_tab(0, 155)
+_M._VERSION = '0.20'
+
+
+local commands = {
+    "append",            "auth",              "bgrewriteaof",
+    "bgsave",            "bitcount",          "bitop",
+    "blpop",             "brpop",
+    "brpoplpush",        "client",            "config",
+    "dbsize",
+    "debug",             "decr",              "decrby",
+    "del",               "discard",           "dump",
+    "echo",
+    "eval",              "exec",              "exists",
+    "expire",            "expireat",          "flushall",
+    "flushdb",           "get",               "getbit",
+    "getrange",          "getset",            "hdel",
+    "hexists",           "hget",              "hgetall",
+    "hincrby",           "hincrbyfloat",      "hkeys",
+    "hlen",
+    "hmget",             --[[ "hmset", ]]     "hscan",
+    "hset",
+    "hsetnx",            "hvals",             "incr",
+    "incrby",            "incrbyfloat",       "info",
+    "keys",
+    "lastsave",          "lindex",            "linsert",
+    "llen",              "lpop",              "lpush",
+    "lpushx",            "lrange",            "lrem",
+    "lset",              "ltrim",             "mget",
+    "migrate",
+    "monitor",           "move",              "mset",
+    "msetnx",            "multi",             "object",
+    "persist",           "pexpire",           "pexpireat",
+    "ping",              "psetex",       --[[ "psubscribe", ]]
+    "pttl",
+    "publish",      --[[ "punsubscribe", ]]   "pubsub",
+    "quit",
+    "randomkey",         "rename",            "renamenx",
+    "restore",
+    "rpop",              "rpoplpush",         "rpush",
+    "rpushx",            "sadd",              "save",
+    "scan",              "scard",             "script",
+    "sdiff",             "sdiffstore",
+    "select",            "set",               "setbit",
+    "setex",             "setnx",             "setrange",
+    "shutdown",          "sinter",            "sinterstore",
+    "sismember",         "slaveof",           "slowlog",
+    "smembers",          "smove",             "sort",
+    "spop",              "srandmember",       "srem",
+    "sscan",
+    "strlen",       --[[ "subscribe", ]]      "sunion",
+    "sunionstore",       "sync",              "time",
+    "ttl",
+    "type",         --[[ "unsubscribe", ]]    "unwatch",
+    "watch",             "zadd",              "zcard",
+    "zcount",            "zincrby",           "zinterstore",
+    "zrange",            "zrangebyscore",     "zrank",
+    "zrem",              "zremrangebyrank",   "zremrangebyscore",
+    "zrevrange",         "zrevrangebyscore",  "zrevrank",
+    "zscan",
+    "zscore",            "zunionstore",       "evalsha",
+    "istab"
+}
+
+
+local sub_commands = {
+    "subscribe", "psubscribe"
+}
+
+
+local unsub_commands = {
+    "unsubscribe", "punsubscribe"
+}
+
+
+local mt = { __index = _M }
+
+
+function _M.new(self)
+    local sock, err = tcp()
+    if not sock then
+        return nil, err
+    end
+    return setmetatable({ sock = sock }, mt)
+end
+
+
+function _M.set_timeout(self, timeout)
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    return sock:settimeout(timeout)
+end
+
+
+function _M.connect(self, ...)
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    self.subscribed = nil
+
+    return sock:connect(...)
+end
+
+
+function _M.set_keepalive(self, ...)
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    if self.subscribed then
+        return nil, "subscribed state"
+    end
+
+    return sock:setkeepalive(...)
+end
+
+
+function _M.get_reused_times(self)
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    return sock:getreusedtimes()
+end
+
+
+local function close(self)
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    return sock:close()
+end
+_M.close = close
+
+
+local function _read_reply(self, sock)
+    local line, err = sock:receive()
+    if not line then
+        if err == "timeout" and not self.subscribed then
+            sock:close()
+        end
+        return nil, err
+    end
+
+    local prefix = byte(line)
+
+    if prefix == 36 then    -- char '$'
+        -- print("bulk reply")
+
+        local size = tonumber(sub(line, 2))
+        if size < 0 then
+            return null
+        end
+
+        local data, err = sock:receive(size)
+        if not data then
+            if err == "timeout" then
+                sock:close()
+            end
+            return nil, err
+        end
+
+        local dummy, err = sock:receive(2) -- ignore CRLF
+        if not dummy then
+            return nil, err
+        end
+
+        return data
+
+    elseif prefix == 43 then    -- char '+'
+        -- print("status reply")
+
+        return sub(line, 2)
+
+    elseif prefix == 42 then -- char '*'
+        local n = tonumber(sub(line, 2))
+
+        -- print("multi-bulk reply: ", n)
+        if n < 0 then
+            return null
+        end
+
+        local vals = new_tab(n, 0);
+        local nvals = 0
+        for i = 1, n do
+            local res, err = _read_reply(self, sock)
+            if res then
+                nvals = nvals + 1
+                vals[nvals] = res
+
+            elseif res == nil then
+                return nil, err
+
+            else
+                -- be a valid redis error value
+                nvals = nvals + 1
+                vals[nvals] = {false, err}
+            end
+        end
+
+        return vals
+
+    elseif prefix == 58 then    -- char ':'
+        -- print("integer reply")
+        return tonumber(sub(line, 2))
+
+    elseif prefix == 45 then    -- char '-'
+        -- print("error reply: ", n)
+
+        return false, sub(line, 2)
+
+    else
+        return nil, "unkown prefix: \"" .. prefix .. "\""
+    end
+end
+
+
+local function _gen_req(args)
+    local nargs = #args
+
+    local req = new_tab(nargs + 1, 0)
+    req[1] = "*" .. nargs .. "\r\n"
+    local nbits = 1
+
+    for i = 1, nargs do
+        local arg = args[i]
+        nbits = nbits + 1
+
+        if not arg then
+            req[nbits] = "$-1\r\n"
+
+        else
+            if type(arg) ~= "string" then
+                arg = tostring(arg)
+            end
+            req[nbits] = "$" .. #arg .. "\r\n" .. arg .. "\r\n"
+        end
+    end
+
+    -- it is faster to do string concatenation on the Lua land
+    return concat(req)
+end
+
+
+local function _do_cmd(self, ...)
+    local args = {...}
+
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    local req = _gen_req(args)
+
+    local reqs = self._reqs
+    if reqs then
+        reqs[#reqs + 1] = req
+        return
+    end
+
+    -- print("request: ", table.concat(req))
+
+    local bytes, err = sock:send(req)
+    if not bytes then
+        return nil, err
+    end
+
+    return _read_reply(self, sock)
+end
+
+
+local function _check_subscribed(self, res)
+    if type(res) == "table"
+       and (res[1] == "unsubscribe" or res[1] == "punsubscribe")
+       and res[3] == 0
+   then
+        self.subscribed = nil
+    end
+end
+
+
+function _M.read_reply(self)
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    if not self.subscribed then
+        return nil, "not subscribed"
+    end
+
+    local res, err = _read_reply(self, sock)
+    _check_subscribed(self, res)
+
+    return res, err
+end
+
+
+for i = 1, #commands do
+    local cmd = commands[i]
+
+    _M[cmd] =
+        function (self, ...)
+            return _do_cmd(self, cmd, ...)
+        end
+end
+
+
+for i = 1, #sub_commands do
+    local cmd = sub_commands[i]
+
+    _M[cmd] =
+        function (self, ...)
+            self.subscribed = true
+            return _do_cmd(self, cmd, ...)
+        end
+end
+
+
+for i = 1, #unsub_commands do
+    local cmd = unsub_commands[i]
+
+    _M[cmd] =
+        function (self, ...)
+            local res, err = _do_cmd(self, cmd, ...)
+            _check_subscribed(self, res)
+            return res, err
+        end
+end
+
+
+function _M.hmset(self, hashname, ...)
+    local args = {...}
+    if #args == 1 then
+        local t = args[1]
+
+        local n = 0
+        for k, v in pairs(t) do
+            n = n + 2
+        end
+
+        local array = new_tab(n, 0)
+
+        local i = 0
+        for k, v in pairs(t) do
+            array[i + 1] = k
+            array[i + 2] = v
+            i = i + 2
+        end
+        -- print("key", hashname)
+        return _do_cmd(self, "hmset", hashname, unpack(array))
+    end
+
+    -- backwards compatibility
+    return _do_cmd(self, "hmset", hashname, ...)
+end
+
+
+function _M.init_pipeline(self, n)
+    self._reqs = new_tab(n or 4, 0)
+end
+
+
+function _M.cancel_pipeline(self)
+    self._reqs = nil
+end
+
+
+function _M.commit_pipeline(self)
+    local reqs = self._reqs
+    if not reqs then
+        return nil, "no pipeline"
+    end
+
+    self._reqs = nil
+
+    local sock = self.sock
+    if not sock then
+        return nil, "not initialized"
+    end
+
+    local bytes, err = sock:send(reqs)
+    if not bytes then
+        return nil, err
+    end
+
+    local nvals = 0
+    local nreqs = #reqs
+    local vals = new_tab(nreqs, 0)
+    for i = 1, nreqs do
+        local res, err = _read_reply(self, sock)
+        if res then
+            nvals = nvals + 1
+            vals[nvals] = res
+
+        elseif res == nil then
+            if err == "timeout" then
+                close(self)
+            end
+            return nil, err
+
+        else
+            -- be a valid redis error value
+            nvals = nvals + 1
+            vals[nvals] = {false, err}
+        end
+    end
+
+    return vals
+end
+
+
+function _M.array_to_hash(self, t)
+    local n = #t
+    -- print("n = ", n)
+    local h = new_tab(0, n / 2)
+    for i = 1, n, 2 do
+        h[t[i]] = t[i + 1]
+    end
+    return h
+end
+
+
+function _M.add_commands(...)
+    local cmds = {...}
+    for i = 1, #cmds do
+        local cmd = cmds[i]
+        _M[cmd] =
+            function (self, ...)
+                return _do_cmd(self, cmd, ...)
+            end
+    end
+end
+
+
+return _M

data/nginx/reload_nginx.sh

@@ -0,0 +1 @@
+/usr/local/openresty/nginx/sbin/nginx -c `pwd`/nginx.conf -p `pwd` -s reload

data/nginx/start_nginx.sh

@@ -0,0 +1 @@
+/usr/local/openresty/nginx/sbin/nginx -c `pwd`/nginx.conf -p `pwd`

data/spec/iprange_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe IPRange::Range do
+  before do
+    range = IPRange::Range.new()
+    range.remove("0.0.0.0/0")
+    range.remove("192.168.0.1/24")
+  end
+
+  describe ".initialize" do
+    subject do
+      IPRange::Range
+    end
+
+    it "should accept redis config as argument" do
+      redis_config = {host: "127.0.0.1"}
+      expect(subject.new(redis_config))
+    end
+
+    it "should use config to connect to redis" do
+      redis_config = double()
+      Redis.should_receive(:new).with(redis_config)
+      subject.new(redis_config)
+    end
+  end
+
+  describe "when a range is added" do
+    subject do
+      IPRange::Range.new
+    end
+
+    before do
+      subject.add("192.168.0.1/24")
+    end
+
+    it "should find it back" do
+      response = subject.find("192.168.0.20")
+      expect(response).to eq({range: "192.168.0.1/24"})
+    end
+
+    it "should return nil for smaller ip that is not in range" do
+      response = subject.find("192.167.255.255")
+      expect(response).to be_nil
+    end
+
+    it "should return nil for greater ip that is not in range" do
+      response = subject.find("192.169.0.1")
+      expect(response).to be_nil
+    end
+  end
+
+  describe "when a range is added with metadata" do
+    subject do
+      IPRange::Range.new
+    end
+
+    before do
+      subject.add("192.168.0.1/24", some: "data", more: "metadata")
+    end
+
+    it "should find it back" do
+      response = subject.find("192.168.0.20")
+      expect(response[:range]).to eq("192.168.0.1/24")
+      expect(response["some"]).to eq("data")
+      expect(response["more"]).to eq("metadata")
+    end
+  end
+
+  describe "when there is multiple ranges with overlap" do
+    subject do
+      IPRange::Range.new
+    end
+
+    before do
+      subject.add("0.0.0.0/0")
+      subject.add("192.168.0.1/24")
+    end
+
+    it "should find the most specific range" do
+      response = subject.find("192.168.0.20")
+      expect(response[:range]).to eq("192.168.0.1/24")
+    end
+
+    it "should find all the ranges" do
+      response = subject.find_all("192.168.0.20")
+      expect(response).to eq([{:range=>"192.168.0.1/24"}, {:range=>"0.0.0.0/0"}])
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "iprange"

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: iprange
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Juarez Bochi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Save IP ranges on Redis for fast lookup using interval sets.
+email:
+- jbochi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/gixlg_importer.rb
+- iprange.gemspec
+- lib/iprange.rb
+- lib/iprange/version.rb
+- nginx/README.md
+- nginx/logs/.gitkeep
+- nginx/nginx.conf
+- nginx/range_lookup.lua
+- nginx/redis.lua
+- nginx/reload_nginx.sh
+- nginx/start_nginx.sh
+- spec/iprange_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/globocom/iprange
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: IP ranges on Redis
+test_files:
+- spec/iprange_spec.rb
+- spec/spec_helper.rb