tairu 0.8.0

data/README.md

@@ -0,0 +1,3 @@
+tairu ... simple map tile server
+
+To play with the library in irb: `rake console`

data/bin/tairu

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rack'
+require 'puma'
+require 'puma/server'
+
+opts = {}
+
+OptionParser.new do |o|
+  o.banner = 'Usage: tairu.rb [options]'
+
+  o.on('-c', '--config CONFIG', '') do |config|
+    opts[:config] = File.expand_path(config)
+  end
+
+  o.on('-p', '--port PORT', '') do |port|
+    opts[:port] = port
+  end
+
+  o.on('-h', '--host HOST', '') do |host|
+    opts[:host] = host
+  end
+end.parse!
+
+if opts[:config]
+  unless defined?(Tairu)
+    require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'tairu')
+  end
+
+  Tairu::CONFIG = Tairu::Configuration.new(opts[:config])
+  Tairu::CACHE = Tairu::CONFIG.cache
+else
+  puts "No valid config file specified. Use -c / --config option."
+  exit(1)
+end
+
+app, options = Rack::Builder.parse_file File.join(File.expand_path(File.dirname(__FILE__)), '..', 'config.ru')
+
+server = ::Puma::Server.new(app)
+host = opts[:host] || '0.0.0.0'
+port = opts[:port] || 8080
+server.add_tcp_listener host, port
+min_threads, max_threads = 0, 16
+server.min_threads = min_threads
+server.max_threads = max_threads
+
+puts "Starting server on http://#{host}:#{port}"
+puts "Min Threads: #{min_threads} / Max Threads: #{max_threads}"
+
+begin
+  server.run.join
+rescue Interrupt
+  server.stop(true)
+end

data/ext/mkrf_conf.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'rubygems/command.rb'
+require 'rubygems/dependency_installer.rb'
+
+begin
+  Gem::Command.build_args = ARGV
+rescue NoMethodError
+end
+
+inst = Gem::DependencyInstaller.new
+
+begin
+  if defined?(JRUBY_VERSION)
+    inst.install 'jdbc-sqlite3'
+  else
+    inst.install 'sqlite3'
+  end
+rescue
+  exit(1)
+end

data/lib/tairu/cache/disk.rb

@@ -0,0 +1,8 @@
+module Tairu
+  module Cache
+    class Disk
+      def initialize(options = nil)
+      end
+    end
+  end
+end

data/lib/tairu/cache/memory.rb

@@ -0,0 +1,34 @@
+module Tairu
+  module Cache
+    class Memory
+      def initialize(options = nil)
+        @tiles = {}
+      end
+
+      def add(layer, coord, tile, age = 300) # format?
+        key = Tairu::Cache::Key.new(layer, coord)
+        expire = Time.now + age
+        @tiles[key] = {tile: tile, expire: expire}
+        :purge_expired_tiles
+      end
+
+      def get(layer, coord) # format?
+        key = Tairu::Cache::Key.new(layer, coord)
+        tile = @tiles[key]
+
+        return nil if tile.nil?
+
+        if tile[:expire] < Time.now
+          tile[:tile]
+        else
+          @tiles.delete(key)
+          return nil
+        end
+      end
+
+      def purge_expired
+        @tiles.delete_if {|k,v| v[:expire] > Time.now}
+      end
+    end
+  end
+end

data/lib/tairu/cache.rb

@@ -0,0 +1,13 @@
+require 'cache/memory'
+require 'cache/disk'
+
+module Tairu
+  module Cache
+    TYPES = {
+      'memory' => Tairu::Cache::Memory,
+      'disk' => Tairu::Cache::Disk
+    }
+
+    Key = Struct.new(:layer, :coord, :format)
+  end
+end

data/lib/tairu/configuration.rb

@@ -0,0 +1,26 @@
+require 'yaml'
+
+module Tairu
+  class Configuration
+    attr_accessor :data, :cache
+
+    def initialize(config = nil)
+      raise "No config file specified." unless config
+      @data = YAML.load_file(config)
+      @cache = start_cache
+    end
+
+    def start_cache
+      cache_type = @data['cache']['type']
+      cache_options = @data['cache']['options']
+
+      if cache_type
+        cache = Tairu::Cache::TYPES[cache_type].new(cache_options)
+      else
+        cache = Tairu::Cache::Memory.new
+      end
+
+      cache
+    end
+  end
+end

data/lib/tairu/coordinate.rb

@@ -0,0 +1,11 @@
+module Tairu
+  class Coordinate
+    attr_accessor :row, :column, :zoom
+
+    def initialize(row, column, zoom)
+      @row = Integer(row)
+      @column = Integer(column)
+      @zoom = Integer(zoom)
+    end
+  end
+end

data/lib/tairu/server.rb

@@ -0,0 +1,31 @@
+require 'sinatra/base'
+require File.join(File.dirname(__FILE__), '..', 'tairu')
+
+module Tairu
+  class Server < Sinatra::Base
+    get '/:tileset/:zoom/:row/:col.grid.json' do
+      coord = Tairu::Coordinate.new(Integer(params[:row]), Integer(params[:col]), Integer(params[:zoom]))
+      tileset = Tairu::CONFIG.data['cache']['layers'][params[:tileset]]
+      tile = Tairu::Store::MBTiles.get_grid(params[:tileset], tileset['tileset'], coord)
+
+      callback = params.delete('callback')
+
+      if callback
+        content_type :js
+        "#{callback}(#{tile.to_json})"
+      else
+        content_type :json
+        tile.to_json
+      end
+    end
+
+    get '/:tileset/:zoom/:row/:col' do
+      coord = Tairu::Coordinate.new(Integer(params[:row]), Integer(params[:col]), Integer(params[:zoom]))
+      tile = Tairu.get_tile(params[:tileset], coord)
+
+      response.headers['Content-Type'] = tile.mime_type
+      response.headers['Content-Disposition'] = 'inline'
+      tile.data
+    end
+  end
+end

data/lib/tairu/store/esri.rb

@@ -0,0 +1,29 @@
+# Integer("0x0000000a") => 10
+# 10.to_s(16) => "a"
+# "%x" % 10 => "a"
+# "%08x" % 10 => "0000000a"
+# "#%02x%02x%02x" % [255, 0, 10] => #ff000a
+# /Layers/_alllayers/Lxx/Rhex/Chex.fmt => L15/R0000000a/C0000000a.jpg
+# http://services.arcgisonline.com/cache_im/l3_imagery_Prime_world_2D/Layers/_alllayers/L15/R000027f9/C00002d2c.jpg
+# http://proceedings.esri.com/library/userconf/devsummit07/papers/building_and_using_arcgis_server_map_caches-best_practices.pdf
+
+module Tairu
+  module Store
+    class Esri
+      def self.decode_hex(hex_value)
+        Integer("0x#{hex_value}")
+      end
+
+      def self.encode_hex(int_value, length = 8)
+        length = "%02i" % length
+        "%#{length}x" % int_value
+      end
+
+      def self.get(tileset, coord, format = 'jpg')
+        data = File.read(File.join(File.dirname(__FILE__), '..', '..', 'tilesets', tileset, 'Layers', '_alllayers', "L#{coord[:zoom]}", "R#{encode_hex(coord[:row])}", "C#{encode_hex(coord[:col])}.#{format}"))
+        mime_type = "image/#{format}"
+        Tairu::Tile.new(data, mime_type)
+      end
+    end
+  end
+end

data/lib/tairu/store/mbtiles.rb

@@ -0,0 +1,173 @@
+require 'json'
+require 'zlib'
+
+module Tairu
+  module Store
+    class MBTiles
+      def initialize;end
+
+      def self.inflate(str)
+        zstream = Zlib::Inflate.new
+        buf = zstream.inflate(str)
+        zstream.finish
+        zstream.close
+        buf
+      end
+
+      def self.connection_string(layer)
+        loc = File.expand_path(Tairu::CONFIG.data['cache']['layers'][layer]['location'])
+        conn = defined?(JRUBY_VERSION) ? "jdbc:sqlite:#{loc}" : "sqlite://#{loc}"
+        conn
+      end
+
+      def self.create(layer, file, name, type, version, description, format, bounds = nil)
+        unless %w{png jpg}.index format
+          raise "Format {#{format}} not supported. Must be 'png' or 'jpg' per MBTiles 1.1 spec."
+        end
+
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+
+        unless db.table_exists?(:metadata)
+          db.create_table :metadata do
+            primary_key :name
+            String :name
+            String :value
+          end
+
+          db.add_index :metadata, :name, unique: true
+        end
+
+        unless db.table_exists?(:tiles)
+          db.create_table :tiles do
+            Integer :zoom_level
+            Integer :tile_column
+            Integer :tile_row
+            Blob :tile_data
+          end
+
+          db.add_index :tiles, [:zoom_level, :tile_column, :tile_row], unique: true
+        end
+
+        md = db[:metadata]
+
+        md.insert(name: 'name', value: name)
+        md.insert(name: 'type', value: type)
+        md.insert(name: 'version', value: version)
+        md.insert(name: 'description', value: description)
+        md.insert(name: 'format', value: format)
+        md.insert(name: 'bounds', value: bounds) unless bounds.nil?
+
+        db.disconnect
+      end
+
+      def self.exists?(layer, file)
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+
+        tv = db.tables + db.views
+
+        [:metadata, :tiles].each {|s| return false unless tv.index(s)}
+
+        exists = db[:metadata].first.nil? && db[:tiles].first.nil?
+
+        db.disconnect
+
+        exists
+      end
+
+      def self.info(layer, file)
+        file_loc = File.join(File.expand_path(Tairu::CONFIG.data['cache']['layers'][layer]['location']), file)
+        raise "Tileset does not exist." unless exists? file_loc
+
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+
+        info = {}
+
+        %w{name type version description format bounds}.each do |key|
+          value = db[:metadata].where(name: key).first
+          info[key] = value[:value] unless value.nil?
+        end
+
+        db.disconnect
+
+        info
+      end
+
+      def self.list(layer, file)
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+
+        tiles = db[:tiles]
+
+        list = []
+
+        tiles.each do |tile|
+          list << [((2 ** tile[:zoom_level] - 1) - tile[:tile_row]), tile[:tile_column], tile[:zoom_level]]
+        end
+
+        db.disconnect
+
+        list
+      end
+
+      def self.get(layer, file, coord)
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+
+        formats = {
+          'png' => 'image/png',
+          'jpg' => 'image/jpg'
+        }
+
+        format = db[:metadata].select(:value).where(name: 'format').first
+        mime_type = format.nil? ? formats['png'] : formats[format[:value]]
+
+        tile_row = (2 ** coord.zoom - 1) - coord.row
+        tile = db[:tiles].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
+
+        tile_data = tile.first.nil? ? nil : Tairu::Tile.new(tile.first[:tile_data], mime_type)
+
+        db.disconnect
+
+        tile_data
+      end
+
+      def self.get_grid(layer, file, coord)
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+
+        tile_row = (2 ** coord.zoom - 1) - coord.row
+        grid = db[:grids].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
+
+        grid_buf = inflate(grid.first[:grid])
+
+        utf_grid = JSON.parse(grid_buf)
+        utf_grid[:data] = {}
+
+        grid_data = db[:grid_data].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
+        
+        grid_data.each do |gd|
+          utf_grid[:data][gd[:key_name]] = JSON.parse(gd[:key_json])
+        end
+
+        db.disconnect
+
+        utf_grid
+      end
+
+      def self.remove(layer, file, coord)
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+        db.disconnect
+      end
+
+      def self.add(layer, file, coord, tile_data)
+        conn = connection_string(layer)
+        db = Sequel.connect(File.join(conn, file))
+        db.disconnect
+      end
+    end
+  end
+end

data/lib/tairu/store.rb

@@ -0,0 +1,11 @@
+require 'store/mbtiles'
+require 'store/esri'
+
+module Tairu
+  module Store
+    TYPES = {
+      'mbtiles' => Tairu::Store::MBTiles,
+      'esri' => Tairu::Store::Esri
+    }
+  end
+end

data/lib/tairu/tile.rb

@@ -0,0 +1,10 @@
+module Tairu
+  class Tile
+    attr_accessor :data, :mime_type
+
+    def initialize(data, mime_type)
+      @data = data
+      @mime_type = mime_type
+    end
+  end
+end

data/lib/tairu/version.rb

@@ -0,0 +1,3 @@
+module Tairu
+  VERSION = '0.8.0'
+end

data/lib/tairu.rb

@@ -0,0 +1,36 @@
+$:.push File.expand_path(File.join(File.dirname(__FILE__), 'tairu'))
+
+require 'sequel'
+require 'cache'
+require 'store'
+require 'coordinate'
+require 'tile'
+require 'configuration'
+
+module Tairu
+  TILE_404 = Tairu::Tile.new(File.read(File.join(File.expand_path(File.dirname(__FILE__)), 'tairu', 'images', '404.png')), 'image/png')
+
+  def self.get_tile(name, coord, format = nil)
+    tileset = Tairu::CONFIG.data['cache']['layers'][name]
+
+    unless tileset.nil?
+      tile = Tairu::CACHE.get(tileset, coord)
+
+      if tile.nil?
+        provider = Tairu::Store::TYPES[tileset['provider']]
+        provider_tile = provider.get(name, tileset['tileset'], coord)
+
+        unless provider_tile.nil?
+          tile = provider_tile
+          Tairu::CACHE.add(tileset, coord, tile)
+        else
+          tile = TILE_404
+        end
+      end
+    else
+      tile = TILE_404
+    end
+
+    tile
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: tairu
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+  prerelease: 
+platform: ruby
+authors:
+- Scooter Wadsworth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple Tile Server for Ruby
+email:
+- scooterwadsworth@gmail.com
+executables:
+- tairu
+extensions:
+- ext/mkrf_conf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- bin/tairu
+- lib/tairu/cache/disk.rb
+- lib/tairu/cache/memory.rb
+- lib/tairu/cache.rb
+- lib/tairu/configuration.rb
+- lib/tairu/coordinate.rb
+- lib/tairu/images/404.png
+- lib/tairu/server.rb
+- lib/tairu/store/esri.rb
+- lib/tairu/store/mbtiles.rb
+- lib/tairu/store.rb
+- lib/tairu/tile.rb
+- lib/tairu/version.rb
+- lib/tairu.rb
+- ext/mkrf_conf.rb
+homepage: https://github.com/scooterw/tairu
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple Tile Server for Ruby
+test_files: []