geoloader 0.1.0

data/lib/geoloader/loaders/geonetwork.rb

@@ -0,0 +1,40 @@
+
+module Geoloader
+  module Loaders
+
+    class Geonetwork < Loader
+
+      attr_reader :asset, :geonetwork
+
+      @queue = :geoloader
+
+      #
+      # Configure the asset, connect to Geonetwork.
+      #
+      def initialize(*args)
+
+        super
+
+        # Create and configure the asset.
+        @asset = Geoloader::Assets::Asset.new(@file_path, @workspace, @desc_path)
+        @asset.extend(Geoloader::Assets::Geonetwork)
+
+        # Connect to Geonetwork, create the group.
+        @geonetwork = Geoloader::Services::Geonetwork.new
+        @geonetwork.ensure_group(@workspace)
+
+      end
+
+      #
+      # Push an asset to Geonetwork.
+      #
+      def load
+        @asset.stage do
+          @geonetwork.create_record(@asset)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/geoloader/loaders/geotiff_geoserver.rb

@@ -0,0 +1,47 @@
+
+module Geoloader
+  module Loaders
+
+    class GeotiffGeoserver < Loader
+
+      attr_reader :geotiff, :geoserver
+
+      @queue = :geoloader
+
+      #
+      # Configure the asset, connect to Geoserver.
+      #
+      def initialize(*args)
+
+        super
+
+        # Create and configure the asset.
+        @geotiff = Geoloader::Assets::Asset.new(@file_path, @workspace, @desc_path)
+        @geotiff.extend(Geoloader::Assets::Geotiff)
+
+        # Connect to Geoserver, create the workspace.
+        @geoserver = Geoloader::Services::Geoserver.new
+        @geoserver.ensure_workspace(@workspace)
+
+      end
+
+      #
+      # Push a GeoTIFF to Geoserver.
+      #
+      def load
+        @geotiff.stage do
+
+          # Prepare the file.
+          @geotiff.make_borders_transparent
+          @geotiff.reproject
+
+          # Push to Geoserver.
+          @geoserver.create_coveragestore(@geotiff)
+
+        end
+      end
+
+    end
+
+  end
+end

data/lib/geoloader/loaders/geotiff_solr.rb

@@ -0,0 +1,40 @@
+
+module Geoloader
+  module Loaders
+
+    class GeotiffSolr < Loader
+
+      attr_reader :geotiff, :solr
+
+      @queue = :geoloader
+
+      #
+      # Configure the asset, connect to Solr.
+      #
+      def initialize(*args)
+
+        super
+
+        # Create and configure the asset.
+        @geotiff = Geoloader::Assets::Asset.new(@file_path, @workspace, @desc_path)
+        @geotiff.extend(Geoloader::Assets::Geotiff)
+        @geotiff.extend(Geoloader::Assets::Solr)
+
+        # Connect to Solr.
+        @solr = Geoloader::Services::Solr.new
+
+      end
+
+      #
+      # Push a GeoTIFF to Solr.
+      #
+      def load
+        @geotiff.stage do
+          @solr.create_document(@geotiff)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/geoloader/loaders/loader.rb

@@ -0,0 +1,53 @@
+
+module Geoloader
+  module Loaders
+
+    class Loader
+
+      #
+      # Perform or enqueue an upload.
+      #
+      # @param [String] file_path
+      # @param [Hash] options
+      #
+      def self.load_or_enqueue(file_path, options)
+        if options[:queue]
+          Resque.enqueue(self, file_path, options[:workspace], options[:description])
+        else
+          self.perform(file_path, options[:workspace], options[:description])
+        end
+      end
+
+      #
+      # Perform an upload (used by Resque).
+      #
+      # @param [String] file_path
+      # @param [String] workspace
+      # @param [String] desc_path
+      #
+      def self.perform(file_path, workspace, desc_path = nil)
+        new(file_path, workspace, desc_path).load
+        puts "Loaded #{File.basename(file_path)}."
+      end
+
+      #
+      # Set the file path and workspace.
+      #
+      # @param [String] file_path
+      # @param [String] workspace
+      # @param [String] desc_path
+      #
+      def initialize(file_path, workspace, desc_path = nil)
+
+        @file_path = file_path
+        @desc_path = desc_path
+
+        # If no workspace is provided, revert to the default.
+        @workspace = (workspace or Geoloader.config.workspaces.production)
+
+      end
+
+    end
+
+  end
+end

data/lib/geoloader/loaders/shapefile_geoserver.rb

@@ -0,0 +1,40 @@
+
+module Geoloader
+  module Loaders
+
+    class ShapefileGeoserver < Loader
+
+      attr_reader :shapefile, :geoserver
+
+      @queue = :geoloader
+
+      #
+      # Configure the asset, connect to Geoserver.
+      #
+      def initialize(*args)
+
+        super
+
+        # Create and configure the asset.
+        @shapefile = Geoloader::Assets::Asset.new(@file_path, @workspace, @desc_path)
+        @shapefile.extend(Geoloader::Assets::Shapefile)
+
+        # Connect to Geoserver, create the workspace.
+        @geoserver = Geoloader::Services::Geoserver.new
+        @geoserver.ensure_workspace(@workspace)
+
+      end
+
+      #
+      # Push a Shapefile to Geoserver.
+      #
+      def load
+        @shapefile.stage do
+          @geoserver.create_datastore(@shapefile)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/geoloader/loaders/shapefile_solr.rb

@@ -0,0 +1,40 @@
+
+module Geoloader
+  module Loaders
+
+    class ShapefileSolr < Loader
+
+      attr_reader :shapefile, :solr
+
+      @queue = :geoloader
+
+      #
+      # Configure the shapefile, connect to Solr.
+      #
+      def initialize(*args)
+
+        super
+
+        # Create and configure the asset.
+        @shapefile = Geoloader::Assets::Asset.new(@file_path, @workspace, @desc_path)
+        @shapefile.extend(Geoloader::Assets::Shapefile)
+        @shapefile.extend(Geoloader::Assets::Solr)
+
+        # Connect to Solr.
+        @solr = Geoloader::Services::Solr.new
+
+      end
+
+      #
+      # Push a Shapefile to Solr.
+      #
+      def load
+        @shapefile.stage do
+          @solr.create_document(@shapefile)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/geoloader/services/geonetwork.rb

@@ -0,0 +1,201 @@
+
+require "rest_client"
+require "builder"
+require "nokogiri"
+
+module Geoloader
+  module Services
+
+    class Geonetwork
+
+      attr_reader :resource
+
+      #
+      # Initialize the API wrapper.
+      #
+      def initialize
+        @resource = RestClient::Resource.new(Geoloader.config.geonetwork.url, {
+          :user     => Geoloader.config.geonetwork.username,
+          :password => Geoloader.config.geonetwork.password,
+          :headers  => { :content_type => :xml }
+        })
+      end
+
+      #
+      # List all groups on the node.
+      #
+      def get_groups
+        @resource["xml.group.list"].get
+      end
+
+      #
+      # Get a group with a given name.
+      #
+      # @param [String] group
+      #
+      def get_group(group)
+        Nokogiri::XML(get_groups).at_xpath("//record[name[text()='#{group}']]")
+      end
+
+      #
+      # Does a group with a given name exist?
+      #
+      # @param [String] group
+      #
+      def group_exists?(group)
+        !!get_group(group)
+      end
+
+      #
+      # Get the id of a group with a given name.
+      #
+      # @param [String] group
+      #
+      def get_group_id(group)
+        get_group(group).at_xpath("id").content.to_i
+      end
+
+      #
+      # Create a new group with a given name.
+      #
+      # @param [String] group
+      #
+      def create_group(group)
+        post("group.update", self.class.xml_doc.request { |r|
+          r.name group
+        })
+      end
+
+      #
+      # Check to see if a group exists, and if not, create it.
+      #
+      # @param [String] group
+      #
+      def ensure_group(group)
+        create_group(group) unless group_exists?(group)
+      end
+
+      #
+      # Get a list of the ids of all records in a group.
+      #
+      # @param [String] group
+      #
+      def get_ids_in_group(group)
+        Nokogiri::XML(search_records_by_group(group)).xpath("//metadata//id").map do |m|
+          m.content.to_i
+        end
+      end
+
+      #
+      # Delete group with a given name.
+      #
+      # @param [String] group
+      #
+      def delete_group(group)
+        delete_records_by_group(group)
+        post("group.remove", self.class.xml_doc.request { |r|
+          r.id get_group_id(group)
+        })
+      end
+
+      #
+      # Insert a new record.
+      #
+      # @param [Geoloader::Asset] asset
+      # @param [String] style_sheet
+      # @param [String] category
+      #
+      def create_record(asset, style_sheet = "_none_", category = "_none_")
+        delete_record(asset)
+        post("metadata.insert", self.class.xml_doc.request { |r|
+          r.group get_group_id(asset.workspace)
+          r.data { |d| d.cdata! asset.iso19139_xml }
+          r.category category
+          r.styleSheet style_sheet
+        })
+      end
+
+      #
+      # Get the metadata record for an asset.
+      #
+      # @param [Geoloader::Asset] asset
+      #
+      def get_record(asset)
+        post("xml.metadata.get", self.class.xml_doc.request { |r|
+          r.uuid asset.uuid
+        })
+      end
+
+      #
+      # Get all records in a given group.
+      #
+      # @param [String] group
+      #
+      def search_records_by_group(group)
+        post("xml.search", self.class.xml_doc.request { |r|
+          r.group get_group_id(group)
+        })
+      end
+
+      #
+      # Delete the metadata record for an asset.
+      #
+      # @param [Geoloader::Asset] asset
+      #
+      def delete_record(asset)
+        post("metadata.delete", self.class.xml_doc.request { |r|
+          r.uuid asset.uuid
+        }) rescue nil # Geonetwork 500's if the record doesn't exist...
+      end
+
+      #
+      # Delete a record by id.
+      #
+      # @param [Integer] id
+      #
+      def delete_record_by_id(id)
+        post("metadata.delete", self.class.xml_doc.request { |r|
+          r.id id
+        })
+      end
+
+      #
+      # Delete all records in a group with a given name.
+      #
+      # @param [Integer] group
+      #
+      def delete_records_by_group(group)
+        get_ids_in_group(group).each do |id|
+          delete_record_by_id(id)
+        end
+      end
+
+      #
+      # POST to an XML service.
+      #
+      # @param [String] service
+      # @param [String] payload
+      #
+      def post(service, payload)
+        @resource[service].post(payload) { |response, request, result, &block|
+          if [301, 302, 307].include?(response.code)
+            response.follow_redirection(request, result, &block)
+          else
+            response.return!(request, result, &block)
+          end
+        }
+      end
+
+      #
+      # Get an XML builder instance.
+      #
+      def self.xml_doc
+        xml = Builder::XmlMarkup.new
+        xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+        xml
+      end
+
+    end
+
+  end
+end