geoip_redis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54f140c92c744b0979451fa9dcddb338a230d90f
+  data.tar.gz: cce5774f92d358c484ce0251e2aef2c5a3163486
+SHA512:
+  metadata.gz: 61f2320b292e8cdaa900aad00876e841db5c0f84243e42b81007c340da719e529adfef0a993d4bcd092bd7c1f2749654c5de70fe7f89d105c2b2a035b0681b51
+  data.tar.gz: f303d171adf7236e81831c580b3c0e61e1750c3a5fda915f8373a380e15dcd169e6a5ddfe1d377c32b70c342f93d752aa45b70c59d695329942cc41b3b78e21b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sergey Zabolotnov
+
+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,81 @@
+# GeoipRedis
+Puts MaxMind GeoIP2 database to Redis and allows to resolve country/city by ip. The main idea described [here](http://redis4you.com/articles.php?id=018&name=GeoIP+in+Redis).
+
+## Restrictions
+ * lagacy version of GeoIP database isn't supported
+ * working only with IPv4 database
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "geoip_redis"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis_geoip
+
+## Usage
+
+Working with GeoIP2 Country database:
+* load:
+
+```ruby
+require "redis"
+require "geoip_redis/country_loader"
+
+redis = Redis.new(url: "redis://localhost:6379/4")
+loader = GeoipRedis::CountryLoader.new(redis)
+
+loader.load_blocks("path/to/blocks_ipv4.csv")
+loader.load_locations("path/to/locations.csv")
+```
+
+* resolve country by ip:
+
+```ruby
+require "redis"
+require "geoip_redis/resolver"
+
+redis = Redis.new(url: "redis://localhost:6379/4")
+resolver = GeoipRedis::Resolver.new(redis)
+
+country = resolver.resolve("123.234.23.12")
+```
+
+Working with GeoIP2 City database:
+* load:
+
+```ruby
+require "redis"
+require "geoip_redis/city_loader"
+
+redis = Redis.new(url: "redis://localhost:6379/5")
+loader = GeoipRedis::CityLoader.new(redis)
+
+loader.load_blocks("path/to/blocks_ipv4.csv")
+loader.load_locations("path/to/locations.csv")
+```
+
+* resolve city by ip:
+
+```ruby
+require "redis"
+require "geoip_redis/resolver"
+
+redis = Redis.new(url: "redis://localhost:6379/5")
+resolver = GeoipRedis::Resolver.new(redis)
+
+city = resolver.resolve("123.234.23.12")
+```
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/zabolotnov87/geoip_redis. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Licence
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/geoip_redis.rb

@@ -0,0 +1 @@
+require "geoip_redis/version"

data/lib/geoip_redis/blocks_parser.rb

@@ -0,0 +1,30 @@
+require "geoip_redis/ip_range"
+
+module GeoipRedis
+  class BlocksParser
+
+    CIDR = 0
+    GEONAME_ID = 1
+    private_constant :CIDR, :GEONAME_ID
+
+    def ip_range(data)
+      location_id = data[GEONAME_ID]
+      cidr = data[CIDR]
+      IpRange.build_from_network(cidr, location_id)
+    end
+
+    POSTAL_CODE = 6
+    LATITUDE    = 7
+    LONGITUDE   = 8
+    private_constant :POSTAL_CODE, :LATITUDE, :LONGITUDE
+
+    def location(data)
+      {
+        location_id: data[GEONAME_ID],
+        postal_code: data[POSTAL_CODE],
+        latitude:    data[LATITUDE],
+        longitude:   data[LONGITUDE],
+      }
+    end
+  end
+end

data/lib/geoip_redis/city_loader.rb

@@ -0,0 +1,40 @@
+require "geoip_redis/store"
+require "geoip_redis/csv_reader"
+require "geoip_redis/blocks_parser"
+require "geoip_redis/locations_parser"
+
+module GeoipRedis
+  class CityLoader
+    def initialize(redis)
+      @store = Store.new(redis)
+      @csv_reader = CSVReader.new
+      @blocks_parser = BlocksParser.new
+      @locations_parser = LocationsParser.new
+    end
+
+    def load_blocks(path_to_blocks)
+      read_by_batch(path_to_blocks) do |rows|
+        ip_ranges = rows.map { |row| @blocks_parser.ip_range(row) }
+        @store.put_ip_ranges(ip_ranges)
+
+        locations = rows.map { |row| @blocks_parser.location(row) }
+        @store.put_locations(locations)
+      end
+    end
+
+    def load_locations(path_to_locations)
+      read_by_batch(path_to_locations) do |rows|
+        locations = rows.map { |row| @locations_parser.city(row) }
+        @store.put_locations(locations)
+      end
+    end
+
+    private
+
+      def read_by_batch(path_to_file)
+        File.open(path_to_file) do |file|
+          @csv_reader.read_by_batch(file) { |rows| yield rows }
+        end
+      end
+  end
+end

data/lib/geoip_redis/country_loader.rb

@@ -0,0 +1,37 @@
+require "geoip_redis/store"
+require "geoip_redis/csv_reader"
+require "geoip_redis/blocks_parser"
+require "geoip_redis/locations_parser"
+
+module GeoipRedis
+  class CountryLoader
+    def initialize(redis)
+      @store = Store.new(redis)
+      @csv_reader = CSVReader.new
+      @blocks_parser = BlocksParser.new
+      @locations_parser = LocationsParser.new
+    end
+
+    def load_blocks(path_to_blocks)
+      read_by_batch(path_to_blocks) do |rows|
+        ip_ranges = rows.map { |row| @blocks_parser.ip_range(row) }
+        @store.put_ip_ranges(ip_ranges)
+      end
+    end
+
+    def load_locations(path_to_locations)
+      read_by_batch(path_to_locations) do |rows|
+        locations = rows.map { |row| @locations_parser.country(row) }
+        @store.put_locations(locations)
+      end
+    end
+
+    private
+
+      def read_by_batch(path_to_file, &block)
+        File.open(path_to_file) do |file|
+          @csv_reader.read_by_batch(file) { |rows| block.call(rows) }
+        end
+      end
+  end
+end

data/lib/geoip_redis/csv_reader.rb

@@ -0,0 +1,23 @@
+require "csv"
+
+module GeoipRedis
+  class CSVReader
+
+    HEADER = 1
+    private_constant :HEADER
+
+    def read_by_batch(io, batch_size: 1000, &block)
+      batch = []
+      CSV.new(io).each.lazy.drop(HEADER).each_with_index do |row, idx|
+        batch << row
+        if (idx + 1) % batch_size == 0
+          block.call(batch)
+          batch = []
+        end
+      end
+
+      block.call(batch) unless batch.empty?
+    end
+
+  end
+end

data/lib/geoip_redis/ip_range.rb

@@ -0,0 +1,27 @@
+require "ipaddr"
+
+module GeoipRedis
+  IpRange = Struct.new(:location_id, :min_ip_num, :max_ip_num) do
+
+    def self.build_from_network(network, location_id)
+      ip_range = IPAddr.new(network).to_range
+      min_ip_num, max_ip_num = ip_range.first.to_i, ip_range.last.to_i
+      new(location_id, min_ip_num, max_ip_num)
+    end
+
+    def self.decode(encoded)
+      location_id, min_ip_num, max_ip_num = encoded.split(":")
+      min_ip_num, max_ip_num = min_ip_num.to_i, max_ip_num.to_i
+      new(location_id, min_ip_num, max_ip_num)
+    end
+
+    def encode
+      "#{location_id}:#{min_ip_num}:#{max_ip_num}"
+    end
+
+    def member?(ip_num)
+      (min_ip_num..max_ip_num).member?(ip_num)
+    end
+
+  end
+end

data/lib/geoip_redis/locations_parser.rb

@@ -0,0 +1,38 @@
+module GeoipRedis
+  class LocationsParser
+    def country(data)
+      geoname_id, locale_code, continent_code, continent_name,
+        country_iso_code, country_name = data
+
+      {
+        location_id:      geoname_id,
+        locale_code:      locale_code,
+        continent_code:   continent_code,
+        continent_name:   continent_name,
+        country_iso_code: country_iso_code,
+        country_name:     country_name,
+      }
+    end
+
+    SUBDIVISION_1_ISO_CODE = 6
+    private_constant :SUBDIVISION_1_ISO_CODE
+
+    def city(data)
+      subdivision_1_iso_code, subdivision_1_name, subdivision_2_iso_code,
+        subdivision_2_name, city_name, metro_code, time_zone =
+        data[SUBDIVISION_1_ISO_CODE..-1]
+
+      location = {
+        subdivision_1_iso_code: subdivision_1_iso_code,
+        subdivision_1_name:     subdivision_1_name,
+        subdivision_2_iso_code: subdivision_2_iso_code,
+        subdivision_2_name:     subdivision_2_name,
+        city_name:              city_name,
+        metro_code:             metro_code,
+        time_zone:              time_zone,
+      }
+
+      country(data).merge(location)
+    end
+  end
+end

data/lib/geoip_redis/resolver.rb

@@ -0,0 +1,33 @@
+require "ipaddr"
+
+require "geoip_redis/store"
+
+module GeoipRedis
+  class Resolver
+    def initialize(redis)
+      @store = Store.new(redis)
+    end
+
+    def resolve(ip)
+      ip_num = normalize_ip(ip).to_i
+      ip_range = @store.find_ip_range(ip_num)
+
+      return if ip_range.nil? || !ip_range.member?(ip_num)
+
+      @store.find_location(ip_range.location_id)
+    end
+
+    private
+
+      def normalize_ip(ip)
+        case ip
+        when String
+          IPAddr.new(ip)
+        when Numeric
+          IPAddr.new(ip, Socket::AF_INET)
+        else
+          ip
+        end
+      end
+  end
+end

data/lib/geoip_redis/store.rb

@@ -0,0 +1,53 @@
+require "redis"
+
+require "geoip_redis/ip_range"
+
+module GeoipRedis
+  class Store
+    IP_RANGES_KEY = "geoip:ipranges"
+    LOCATIONS_KEY = "geoip:locations"
+
+    def initialize(redis)
+      @redis = redis
+    end
+
+    def put_ip_ranges(ip_ranges)
+      @redis.pipelined do
+        ip_ranges.each { |ip_range| put_ip_range(ip_range) }
+      end
+    end
+
+    def find_ip_range(ip_num)
+      encoded_ip_range = @redis.zrangebyscore(
+        IP_RANGES_KEY, ip_num, "+inf", limit: [0, 1]).first
+
+      IpRange.decode(encoded_ip_range) if encoded_ip_range
+    end
+
+    def put_locations(locations)
+      @redis.pipelined do
+        locations.each { |location| put_location(location) }
+      end
+    end
+
+    def find_location(location_id)
+      @redis.hgetall location_key(location_id)
+    end
+
+    private
+
+      def put_ip_range(ip_range)
+        @redis.zadd(IP_RANGES_KEY, ip_range.max_ip_num, ip_range.encode)
+      end
+
+      def put_location(location)
+        location_id = location.fetch(:location_id)
+        location.delete(:location_id)
+        @redis.hmset location_key(location_id), location.flatten
+      end
+
+      def location_key(location_id)
+        "#{LOCATIONS_KEY}:#{location_id}"
+      end
+  end
+end

data/lib/geoip_redis/version.rb

@@ -0,0 +1,3 @@
+module GeoipRedis
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: geoip_redis
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sergey Zabolotnov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Put MaxMind GeoIP2 database to Redis
+email:
+- sergey.zabolotnov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/geoip_redis.rb
+- lib/geoip_redis/blocks_parser.rb
+- lib/geoip_redis/city_loader.rb
+- lib/geoip_redis/country_loader.rb
+- lib/geoip_redis/csv_reader.rb
+- lib/geoip_redis/ip_range.rb
+- lib/geoip_redis/locations_parser.rb
+- lib/geoip_redis/resolver.rb
+- lib/geoip_redis/store.rb
+- lib/geoip_redis/version.rb
+homepage: https://github.com/zabolotnov87/geoip_redis
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Put MaxMind GeoIP2 database to Redis
+test_files: []
+has_rdoc: