maxminddb 0.1.20 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49781843be08dc83d3cc593d9754cdf344d270c1
-  data.tar.gz: 5d0d83b7ba2a3cb6945db5d34fc38c579ea13a91
+  metadata.gz: ab8d608c0e8a6e577bdf66c0d2523c33f8d61154
+  data.tar.gz: 7e2ab98277eef7c50c62e8878082ac404aade464
 SHA512:
-  metadata.gz: 7519d4cce445664ee6d1de8ad297e4cefff016971878130d71b472416167506bd484cb16decbb4bbdeaaee8bef4a6dde1908940dfee3c04b65a268ae2beebac6
-  data.tar.gz: 0d9a52e16cb853e4139eb452f807d8aec78702b0b566d6b814560d075abe9fa856afb1fc14be1cb6ffdc839862202ad982f5e9704f50a0a26a8c35e8e5f7ad44
+  metadata.gz: 3c002cc49899ffa54ee320eb2c867e7b88d50e343da99a88217b5a7f0251863c1be4c8fc98c70c2038efd6362df78db1b8c2ff7ce77782d3d14fee561d2bdd75
+  data.tar.gz: a4888c65e1bf9bc8381f16c837f3b86cbd12f9dbf62eb840767ece6e8c18b2180cddff71c14b0630a49357635404176bf5dd9417a960c1bb6b01212c48db781d

data/.travis.yml

@@ -6,6 +6,8 @@ rvm:
   - 2.2
   - 2.3
   - 2.4.0
+  - 2.5.1
+  - 2.6.0-preview2
   - jruby-19mode
 
 script: bundle exec rake

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+### 0.1.21 (July 20, 2018)
+
+- Make the low-memory file reader opt-in
+
 ### 0.1.20 (July 9, 2018)
 
 - Add local_ip_alias

data/README.md

@@ -81,10 +81,23 @@ A MaxMindDB instance doesn't do any write operation after it is created. So we c
 
 maxminddb-docker: https://github.com/samnissen/maxminddb-docker
 
+### File reading strategies
+
+By default, `MaxMinDB.new` will read the entire database into memory. This makes subsequent lookups fast, but can result in a fairly large memory overhead.
+
+If having a low memory overhead is important, you can use the `LowMemoryReader` by passing a `file_reader` argument to `MaxMindDB.new`. For example:
+
+```ruby
+db = MaxMindDB.new('./GeoLite2-City.mmdb', MaxMindDB::LOW_MEMORY_FILE_READER)
+ret = db.lookup('74.125.225.224')
+```
+
+The `LowMemoryReader` will not load the entire database into memory. It's important to note that for Ruby versions lower than `2.5.0`, the `LowMemoryReader` is not process safe. Forking a process after initializing a `MaxMindDB` instance can lead to unexpected results. For Ruby versions >= `2.5.0`, `LowMemoryReader` uses `File.pread` which works safely in forking environments.
+
 ## Contributing
 
-1. Fork it ( http://github.com/yhirose/maxminddb/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
+1.  Fork it ( http://github.com/yhirose/maxminddb/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/lib/maxminddb.rb

@@ -5,7 +5,13 @@ require 'ipaddr'
 
 module MaxMindDB
 
-  DEFAULT_FILE_READER = proc { |path| MaxMindDB::Reader.new(path) }
+  # The default reader for MaxMindDB files. Reads the database into memory.
+  # This creates a higher memory overhead, but faster lookup times.
+  DEFAULT_FILE_READER = proc { |path| File.binread(path) }
+
+  # A low memory file reader for MaxMindDB files. Avoids reading the database
+  # into memory. Has a lower memory footprint but slower lookup times.
+  LOW_MEMORY_FILE_READER = proc { |path| MaxMindDB::LowMemoryReader.new(path) }
 
   def self.new(path, file_reader=DEFAULT_FILE_READER)
     Client.new(path, file_reader)

data/lib/maxminddb/reader.rb

@@ -1,6 +1,8 @@
 
+require 'thread'
+
 module MaxMindDB
-  class Reader
+  class LowMemoryReader
     METADATA_MAX_SIZE = 128 * 1024
 
     def initialize(path)
@@ -21,9 +23,15 @@ module MaxMindDB
     end
 
     def atomic_read(length, pos)
-      @mutex.synchronize do
-        @file.seek(pos)
-        @file.read(length)
+      # Prefer `pread` in environments where it is available. `pread` provides
+      # atomic file access across processes.
+      if @file.respond_to?(:pread)
+        @file.pread(length, pos)
+      else
+        @mutex.synchronize do
+          @file.seek(pos)
+          @file.read(length)
+        end
       end
     end
   end

data/lib/maxminddb/version.rb

@@ -1,3 +1,3 @@
 module MaxMindDB
-  VERSION = "0.1.20"
+  VERSION = "0.1.21"
 end

data/spec/maxminddb_spec.rb

@@ -1,215 +1,224 @@
 require 'maxminddb'
 
 describe MaxMindDB do
-  let(:city_db) { MaxMindDB.new('spec/cache/GeoLite2-City.mmdb') }
-  let(:country_db) { MaxMindDB.new('spec/cache/GeoLite2-Country.mmdb') }
-  let(:rec32_db) { MaxMindDB.new('spec/data/32bit_record_data.mmdb') }
+  [
+    ['default file reader', MaxMindDB::DEFAULT_FILE_READER],
+    ['low memory file reader', MaxMindDB::LOW_MEMORY_FILE_READER],
+  ].each do |file_reader|
+    description, reader = file_reader
 
-  context 'for the ip 74.125.225.224' do
-    let(:ip) { '74.125.225.224' }
+    describe description do
+      let(:city_db) { MaxMindDB.new('spec/cache/GeoLite2-City.mmdb', reader) }
+      let(:country_db) { MaxMindDB.new('spec/cache/GeoLite2-Country.mmdb', reader) }
+      let(:rec32_db) { MaxMindDB.new('spec/data/32bit_record_data.mmdb', reader) }
 
-    it 'returns a MaxMindDB::Result' do
-      expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
-    end
+      context 'for the ip 74.125.225.224' do
+        let(:ip) { '74.125.225.224' }
 
-    it 'finds data' do
-      expect(city_db.lookup(ip)).to be_found
-    end
+        it 'returns a MaxMindDB::Result' do
+          expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
+        end
 
-    it 'returns Mountain View as the English name' do
-      expect(city_db.lookup(ip).city.name).to eq('Alameda')
-    end
+        it 'finds data' do
+          expect(city_db.lookup(ip)).to be_found
+        end
 
-    it 'returns -122.0574 as the longitude' do
-      expect(city_db.lookup(ip).location.longitude).to eq(-122.2788)
-    end
+        it 'returns Mountain View as the English name' do
+          expect(city_db.lookup(ip).city.name).to eq('Alameda')
+        end
 
-    it 'returns nil for is_anonymous_proxy' do
-      expect(city_db.lookup(ip).traits.is_anonymous_proxy).to eq(nil)
-    end
+        it 'returns -122.0574 as the longitude' do
+          expect(city_db.lookup(ip).location.longitude).to eq(-122.2788)
+        end
 
-    it 'returns United States as the English country name' do
-      expect(country_db.lookup(ip).country.name).to eq('United States')
-    end
+        it 'returns nil for is_anonymous_proxy' do
+          expect(city_db.lookup(ip).traits.is_anonymous_proxy).to eq(nil)
+        end
 
-    it 'returns false for the is_in_european_union' do
-      expect(country_db.lookup(ip).country.is_in_european_union).to eq(nil)
-    end
+        it 'returns United States as the English country name' do
+          expect(country_db.lookup(ip).country.name).to eq('United States')
+        end
 
-    it 'returns US as the country iso code' do
-      expect(country_db.lookup(ip).country.iso_code).to eq('US')
-    end
+        it 'returns false for the is_in_european_union' do
+          expect(country_db.lookup(ip).country.is_in_european_union).to eq(nil)
+        end
 
-    context 'as a Integer' do
-      let(:integer_ip) { IPAddr.new(ip).to_i }
+        it 'returns US as the country iso code' do
+          expect(country_db.lookup(ip).country.iso_code).to eq('US')
+        end
 
-      it 'returns a MaxMindDB::Result' do
-        expect(city_db.lookup(integer_ip)).to be_kind_of(MaxMindDB::Result)
-      end
+        context 'as a Integer' do
+          let(:integer_ip) { IPAddr.new(ip).to_i }
 
-      it 'returns Mountain View as the English name' do
-        expect(city_db.lookup(integer_ip).city.name).to eq('Alameda')
-      end
+          it 'returns a MaxMindDB::Result' do
+            expect(city_db.lookup(integer_ip)).to be_kind_of(MaxMindDB::Result)
+          end
+
+          it 'returns Mountain View as the English name' do
+            expect(city_db.lookup(integer_ip).city.name).to eq('Alameda')
+          end
 
-      it 'returns United States as the English country name' do
-        expect(country_db.lookup(integer_ip).country.name).to eq('United States')
+          it 'returns United States as the English country name' do
+            expect(country_db.lookup(integer_ip).country.name).to eq('United States')
+          end
+        end
       end
-    end
-  end
 
-  context 'for the ip 2001:708:510:8:9a6:442c:f8e0:7133' do
-    let(:ip) { '2001:708:510:8:9a6:442c:f8e0:7133' }
+      context 'for the ip 2001:708:510:8:9a6:442c:f8e0:7133' do
+        let(:ip) { '2001:708:510:8:9a6:442c:f8e0:7133' }
 
-    it 'finds data' do
-      expect(city_db.lookup(ip)).to be_found
-    end
+        it 'finds data' do
+          expect(city_db.lookup(ip)).to be_found
+        end
 
-    it 'returns true for the is_in_european_union' do
-      expect(country_db.lookup(ip).country.is_in_european_union).to eq(true)
-    end
+        it 'returns true for the is_in_european_union' do
+          expect(country_db.lookup(ip).country.is_in_european_union).to eq(true)
+        end
 
-    it 'returns FI as the country iso code' do
-      expect(country_db.lookup(ip).country.iso_code).to eq('FI')
-    end
+        it 'returns FI as the country iso code' do
+          expect(country_db.lookup(ip).country.iso_code).to eq('FI')
+        end
 
-    context 'as an integer' do
-      let(:integer_ip) { IPAddr.new(ip).to_i }
+        context 'as an integer' do
+          let(:integer_ip) { IPAddr.new(ip).to_i }
 
-      it 'returns FI as the country iso code' do
-        expect(country_db.lookup(integer_ip).country.iso_code).to eq('FI')
+          it 'returns FI as the country iso code' do
+            expect(country_db.lookup(integer_ip).country.iso_code).to eq('FI')
+          end
+        end
       end
-    end
-  end
 
-  context 'for a Canadian ipv6' do
-    let(:ip) { '2607:5300:60:72ba::' }
+      context 'for a Canadian ipv6' do
+        let(:ip) { '2607:5300:60:72ba::' }
 
-    it 'finds data' do
-      expect(city_db.lookup(ip)).to be_found
-    end
+        it 'finds data' do
+          expect(city_db.lookup(ip)).to be_found
+        end
 
-    it 'returns true for the is_in_european_union' do
-      expect(country_db.lookup(ip).country.is_in_european_union).to be_falsey
-    end
+        it 'returns true for the is_in_european_union' do
+          expect(country_db.lookup(ip).country.is_in_european_union).to be_falsey
+        end
 
-    it 'returns CA as the country iso code' do
-      expect(country_db.lookup(ip).country.iso_code).to eq('CA')
-    end
-  end
+        it 'returns CA as the country iso code' do
+          expect(country_db.lookup(ip).country.iso_code).to eq('CA')
+        end
+      end
 
-  context 'for a German IPv6' do
-    let(:ip) { '2a01:488:66:1000:2ea3:495e::1' }
+      context 'for a German IPv6' do
+        let(:ip) { '2a01:488:66:1000:2ea3:495e::1' }
 
-    it 'finds data' do
-      expect(city_db.lookup(ip)).to be_found
-    end
+        it 'finds data' do
+          expect(city_db.lookup(ip)).to be_found
+        end
 
-    it 'returns false for the is_in_european_union' do
-      expect(country_db.lookup(ip).country.is_in_european_union).to eq(true)
-    end
+        it 'returns true for the is_in_european_union' do
+          expect(country_db.lookup(ip).country.is_in_european_union).to eq(true)
+        end
 
-    it 'returns DE as the country iso code' do
-      expect(country_db.lookup(ip).country.iso_code).to eq('DE')
-    end
-  end
+        it 'returns DE as the country iso code' do
+          expect(country_db.lookup(ip).country.iso_code).to eq('DE')
+        end
+      end
 
-  context 'for the ip 127.0.0.1' do
-    let(:ip) { '127.0.0.1' }
+      context 'for the ip 127.0.0.1' do
+        let(:ip) { '127.0.0.1' }
 
-    it 'returns a MaxMindDB::Result' do
-      expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
-    end
+        it 'returns a MaxMindDB::Result' do
+          expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
+        end
 
-    it "doesn't find data" do
-      expect(city_db.lookup(ip)).to_not be_found
-    end
-  end
+        it "doesn't find data" do
+          expect(city_db.lookup(ip)).to_not be_found
+        end
+      end
 
-  context 'for local ip addresses' do
-    let(:ip) { '127.0.0.1' }
+      context 'for local ip addresses' do
+        let(:ip) { '127.0.0.1' }
 
-    context 'for city_db' do
-      before do
-        city_db.local_ip_alias = '74.125.225.224'
-      end
+        context 'for city_db' do
+          before do
+            city_db.local_ip_alias = '74.125.225.224'
+          end
 
-      it 'returns a MaxMindDB::Result' do
-        expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
-      end
+          it 'returns a MaxMindDB::Result' do
+            expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
+          end
 
-      it 'finds data' do
-        expect(city_db.lookup(ip)).to be_found
-      end
+          it 'finds data' do
+            expect(city_db.lookup(ip)).to be_found
+          end
 
-      it 'returns Mountain View as the English name' do
-        expect(city_db.lookup(ip).city.name).to eq('Alameda')
-      end
+          it 'returns Mountain View as the English name' do
+            expect(city_db.lookup(ip).city.name).to eq('Alameda')
+          end
 
-      it 'returns -122.0574 as the longitude' do
-        expect(city_db.lookup(ip).location.longitude).to eq(-122.2788)
-      end
+          it 'returns -122.0574 as the longitude' do
+            expect(city_db.lookup(ip).location.longitude).to eq(-122.2788)
+          end
 
-      it 'returns nil for is_anonymous_proxy' do
-        expect(city_db.lookup(ip).traits.is_anonymous_proxy).to eq(nil)
-      end
-    end
+          it 'returns nil for is_anonymous_proxy' do
+            expect(city_db.lookup(ip).traits.is_anonymous_proxy).to eq(nil)
+          end
+        end
 
-    context 'for country_db' do
-      before do
-        country_db.local_ip_alias = '74.125.225.224'
-      end
+        context 'for country_db' do
+          before do
+            country_db.local_ip_alias = '74.125.225.224'
+          end
 
-      it 'returns United States as the English country name' do
-        expect(country_db.lookup(ip).country.name).to eq('United States')
-      end
+          it 'returns United States as the English country name' do
+            expect(country_db.lookup(ip).country.name).to eq('United States')
+          end
 
-      it 'returns false for the is_in_european_union' do
-        expect(country_db.lookup(ip).country.is_in_european_union).to eq(nil)
-      end
+          it 'returns false for the is_in_european_union' do
+            expect(country_db.lookup(ip).country.is_in_european_union).to eq(nil)
+          end
 
-      it 'returns US as the country iso code' do
-        expect(country_db.lookup(ip).country.iso_code).to eq('US')
+          it 'returns US as the country iso code' do
+            expect(country_db.lookup(ip).country.iso_code).to eq('US')
+          end
+        end
       end
-    end
-  end
 
-  context 'for 32bit record data' do
-    let(:ip) { '1.0.16.1' }
-
-    it 'finds data' do
-      expect(rec32_db.lookup(ip)).to be_found
-    end
-  end
+      context 'for 32bit record data' do
+        let(:ip) { '1.0.16.1' }
 
-  context 'test ips' do
-    [
-      ['185.23.124.1', 'SA'],
-      ['178.72.254.1', 'CZ'],
-      ['95.153.177.210', 'RU'],
-      ['200.148.105.119', 'BR'],
-      ['195.59.71.43', 'GB'],
-      ['179.175.47.87', 'BR'],
-      ['202.67.40.50', 'ID'],
-    ].each do |ip, iso|
-      it 'returns a MaxMindDB::Result' do
-        expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
+        it 'finds data' do
+          expect(rec32_db.lookup(ip)).to be_found
+        end
       end
 
-      it "returns #{iso} as the country iso code" do
-        expect(country_db.lookup(ip).country.iso_code).to eq(iso)
+      context 'test ips' do
+        [
+          ['185.23.124.1', 'SA'],
+          ['178.72.254.1', 'CZ'],
+          ['95.153.177.210', 'RU'],
+          ['200.148.105.119', 'BR'],
+          ['195.59.71.43', 'GB'],
+          ['179.175.47.87', 'BR'],
+          ['202.67.40.50', 'ID'],
+        ].each do |ip, iso|
+          it 'returns a MaxMindDB::Result' do
+            expect(city_db.lookup(ip)).to be_kind_of(MaxMindDB::Result)
+          end
+
+          it "returns #{iso} as the country iso code" do
+            expect(country_db.lookup(ip).country.iso_code).to eq(iso)
+          end
+        end
       end
-    end
-  end
 
-  context 'test boolean data' do
-    let(:ip) { '41.194.0.1' }
+      context 'test boolean data' do
+        let(:ip) { '41.194.0.1' }
 
-    it 'returns true for the is_satellite_provider trait' do
-      expect(city_db.lookup(ip).traits.is_satellite_provider).to eq(nil)
-    end
+        it 'returns true for the is_satellite_provider trait' do
+          expect(city_db.lookup(ip).traits.is_satellite_provider).to eq(nil)
+        end
 
-    # There are no false booleans in the database that we can test.
-    # False values are simply omitted.
+        # There are no false booleans in the database that we can test.
+        # False values are simply omitted.
+      end
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maxminddb
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.1.21
 platform: ruby
 authors:
 - yhirose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-09 00:00:00.000000000 Z
+date: 2018-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler