rgeoserver 0.5.9 → 0.7

data/examples/batch_demo.rb

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+# -*- encoding : utf-8 -*-
+#
+# RGeoServer Batch load layers (batch_demo.rb)
+# Usage: #{File.basename(__FILE__)} [input.yml]
+
+require 'rubygems'
+require 'yaml'
+require 'rgeoserver'
+require 'awesome_print'
+require 'optparse'
+
+#=  Input data. *See DATA section at end of file*
+# The input file is in YAML syntax with each record is a Hash with keys:
+# - layername
+# - filename
+# - format
+# - title
+# and optionally
+# - description
+# - keywords
+# - metadata_links
+
+#= Configuration constants
+WORKSPACE_NAME = 'rgeoserver'
+NAMESPACE = 'urn:rgeoserver'
+
+# GeoWebCache configuration
+SEED = true
+SEED_OPTIONS = {
+  :srs => {
+    :number => 4326 
+  },
+  :zoomStart => 1,
+  :zoomStop => 8,
+  :format => 'image/png',
+  :threadCount => 1
+}
+
+def main layers, flags = {}
+  return unless layers
+  datadir = flags[:datadir]
+  # Connect to the GeoServer catalog
+  cat = RGeoServer::Catalog.new
+
+  # Obtain a handle to the workspace and clean it up. 
+  ws = RGeoServer::Workspace.new cat, :name => WORKSPACE_NAME
+  ws.delete :recurse => true if flags[:delete] and not ws.new?
+  ws.save if ws.new?
+
+  # Iterate over all records in YAML file and create stores in the catalog
+  layers.each do |k, v|
+    ['layername', 'format', 'filename', 'title'].each do |id|
+      raise ArgumentError, "Layer is missing #{id}" unless v.include?(id)
+    end
+    ap v
+
+    layername = v['layername'].strip
+    format = v['format'].strip
+
+    ap "Layer: #{layername} #{format}"
+    if format == 'GeoTIFF'
+      # Create of a coverage store
+      cs = RGeoServer::CoverageStore.new cat, :workspace => ws, :name => layername
+      cs.url = File.join(datadir, v['filename'])
+      cs.description = v['description'] 
+      cs.enabled = 'true'
+      cs.data_type = format
+      cs.save
+
+      # Now create the actual coverage
+      cv = RGeoServer::Coverage.new cat, :workspace => ws, :coverage_store => cs, :name => layername 
+      cv.title = v['title'] 
+      cv.keywords = v['keywords']
+      cv.metadata_links = v['metadata_links']
+      cv.save
+
+    elsif format == 'Shapefile'
+      # Create data stores for shapefiles
+      ds = RGeoServer::DataStore.new cat, :workspace => ws, :name => layername
+      ds.description = v['description']
+      ds.connection_parameters = {
+        "url" => File.join(datadir, v['filename']),
+        "namespace" => NAMESPACE
+      }
+      ds.enabled = 'true'
+      ds.save
+
+      ft = RGeoServer::FeatureType.new cat, :workspace => ws, :data_store => ds, :name => layername 
+      ft.title = v['title'] 
+      ft.abstract = v['description']
+      ft.keywords = v['keywords']
+      ft.metadata_links = v['metadata_links']
+      ft.save
+    end
+
+    # Check if a layer has been created, extract some metadata
+    lyr = RGeoServer::Layer.new cat, :name => layername
+    if not lyr.new? and SEED
+      lyr.seed :issue, SEED_OPTIONS
+    else
+      raise NotImplementedError, "Unsupported format #{format}"
+    end
+  end
+end
+
+begin
+  flags = {
+    :delete => true,
+    :verbose => false,
+    :datadir => 'file:///data'
+  }
+  
+  OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename(__FILE__)} [-v] [--delete] [input.yml ...]"
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      flags[:verbose] = v
+    end
+    opts.on(nil, "--[no-]delete", "Delete workspaces recursively") do |v|
+      flags[:delete] = v
+    end
+    opts.on("-d DIR", "--datadir DIR", "Data directory on GeoServer (default: file:///data)") do |v|
+      flags[:datadir] = v
+    end
+  end.parse!
+  ap flags
+
+  if ARGV.size > 0
+    ARGV.each do |fn|
+      main(YAML::load_file(fn), flags)
+    end
+  else
+    main(YAML::load(DATA), flags)
+  end
+rescue SystemCallError => e
+  $stderr.puts "ERROR: #{e.message}"
+  exit(-1)
+end
+
+__END__
+---
+example_vector:
+  layername: "Precincts_Jan262012_5"
+  filename: "branner/Precincts_Jan262012_5/Precincts_Jan262012_5.shp"
+  format: "Shapefile"
+  title: "US Precincts, 2008"
+  description: "This is a dataset developed by Prof. Jonathan Rodden at Stanford University showing precinct polygon data for the United States for the year 2008."
+  keywords: ["vector", "precinct", "political", "US", "voting", "2008", "elections", { 
+      keyword: "California", language: "en", vocabulary: "ISOTC211/19115:place"}]
+  metadata_links: [{
+    metadataType: TC211, 
+    content: "http://purl.stanford.edu/catalog/aa111aa1111/iso19139.xml"}] 
+  metadata:
+    druid: aa111aa1111
+    publisher: "Jonathan Rodden, Stanford University"
+
+example_raster:
+  layername: antietam_1867
+  filename: rumsey/g3881015alpha.tif
+  format: GeoTIFF
+  title: "U.S. Civil War battle of Antietam, 1867"
+  description: "Map shows the U.S. Civil War battle of Antietam.  It indicates fortifications, roads, railroads, houses, names of residents, fences, drainage, vegetation, and relief by hachures."
+  keywords: ["civil war", "battles", { 
+      keyword: "Sharpsburg, MD", language: "en", vocabulary: "urn:geonames.org?GeoNameId=4369352"}]
+  metadata_links: [{
+    metadataType: TC211, 
+    content: "http://purl.stanford.edu/catalog/bb222bb2222/iso19139.xml"}] 
+  metadata:
+    druid: bb222bb2222
+    publisher: Unknown

data/examples/catalog_migration.rb

@@ -6,10 +6,10 @@
 require 'rgeoserver'
 
 # The source catalog is a GeoServer instance version 2.1.0
-$source_gs = RGeoServer::Catalog.new :url=> 'https://oldgeodata.example.com/geoserver/rest', :user=>'admin', :password=>'changeme'
+$source_gs = RGeoServer::Catalog.new
 
 # The target catalog is a GeoServer instance version 2.1.3
-$target_gs = RGeoServer::Catalog.new :url=> 'http://newgeodata.example.com/geoserver/rest', :user=> 'admin', :password => 'geoserver'
+$target_gs = RGeoServer::Catalog.new
 
 # We don't migrate all workspaces except the following:
 $workspaces_to_migrate = [

data/examples/cluster_demo.rb

@@ -17,7 +17,7 @@ layers = {
 }
 
 (1..7).each do |cat_id| 
-  cat = RGeoServer::Catalog.new :user=>'admin', :url => "http://geoserver-app#{cat_id}/rest", :password => "osgeo!"
+  cat = RGeoServer::Catalog.new
   ws = cat.get_workspace('cite')
   RGeoServer::ResourceInfo.list(RGeoServer::CoverageStore, cat, layers.keys, :workspace => ws) do |cs|
     cs.description = layers[cs.name]['description']  

data/examples/coverage_stores.rb

@@ -0,0 +1,42 @@
+
+require 'rgeoserver'
+
+layers = {
+  'south_america_1787' => {
+    'url' => 'file:///geo_data/rumsey/g0411047.tif',
+    'description' => "Map of South America by D'Anville",
+    'type' => 'GeoTIFF'
+   },
+  'city_of_san_francisco_1859' => {
+    'url' => 'file:///geo_data/rumsey/g1030000alpha.tif',
+    'description' => 'Map of San Francisco by the U.S. Coast Survey, with detail of the unsettled lands',
+    'type' => 'GeoTIFF'
+  }
+}
+
+(1..7).each do |cat_id|
+  cat = RGeoServer::Catalog.new
+  ws = cat.get_default_workspace
+  cat.list(RGeoServer::CoverageStore, layers.keys, :workspace => ws) do |cs|
+    cs.url = layers[cs.name]['url']
+    cs.data_type = layers[cs.name]['type']
+    cs.enabled = 'true'
+    cs.save
+    # Create the corresponding layer
+    c = RGeoServer::Coverage.new cat, :workspace => ws, :coverage_store => cs, :name => cs.name 
+    c.title = cs_name.gsub('_',' ').titleize
+    c.abstract = layers[cs.name]['description']
+    c.save
+    # Seed the tile cache
+    l = RGeoServer::Layer.new cat, :name => cs.name
+    l.seed :issue, {
+      :srs => {
+        :number => 4326
+      },
+      :zoomStart => 1,
+      :zoomStop => 10,
+      :format => 'image/png',
+      :threadCount => 1
+    }
+  end
+end

data/examples/demo_druid_workspace.rb

@@ -0,0 +1,6 @@
+require 'rgeoserver'
+
+c = RGeoServer::Catalog.new
+w = c.get_default_workspace
+ds = w.data_stores
+ds.first.profile

data/examples/deploy_dor_layer.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rgeoserver'
+require 'awesome_print'
+
+RestClient.log = '/tmp/restclient.log'
+@config = RGeoServer::Config
+ap @config
+@c = RGeoServer.Catalog.new
+ap @c
+@w = @c.get_workspace 'druid'
+ap @w
+
+@w.data_stores do |ds|
+  ds.featuretypes do |ft|
+    ap [ft, ft.name, ft.message]
+  end
+  ap [ds, ds.name]
+end

data/examples/sql_layer_demo.rb

@@ -5,7 +5,7 @@
 
 require 'rgeoserver'
 
-$catalog = RGeoServer::Catalog.new :url => 'http://localhost:8080/geoserver/rest', :user => 'admin', :password => 'geoserver'
+$catalog = RGeoServer::Catalog.new
 
 # 1. Register a POSTGIS database as data store in GeoServer
 connection_parameters = {

data/lib/rgeoserver/catalog.rb

@@ -1,29 +1,35 @@
 module RGeoServer
-  # This class represents the main class of the data model.
+  # This class represents the main class of the data model, and provides all REST APIs to GeoServer.
   # Refer to
   # - http://geoserver.org/display/GEOS/Catalog+Design
-  # - http://docs.geoserver.org/stable/en/user/restconfig/rest-config-api.html#workspaces
+  # - http://docs.geoserver.org/stable/en/user/rest/api/
 
   class Catalog
     include RGeoServer::RestApiClient
 
     attr_reader :config
 
-    # @param [OrderedHash] options
-    # @option options [String] :url
-    # @option options [String] :user
-    # @option options [String] :password
-    def initialize options = {}
-      @config = options
+    # @param [OrderedHash] options, if nil, uses RGeoServer::Config[:geoserver] loaded from $RGEOSERVER_CONFIG or config/defaults.yml
+    # @param [String] options :url
+    # @param [String] options :user
+    # @param [String] options :password
+    def initialize options = nil
+      @config = options || RGeoServer::Config[:geoserver]
+      unless config.include?(:url)
+        raise ArgumentError.new("Catalog: Requires :url option: #{config}") 
+      end
+      RestClient.log = config[:logfile] || nil
     end
 
     def to_s
-      "Catalog: #{@config[:url]}"
+      "Catalog: #{config[:url]}"
     end
 
-    def headers format
-      sym = :xml || format.to_sym
-      {:accept => sym, :content_type=> sym}
+    def headers format = :xml
+      { 
+        :accept => format.to_sym, 
+        :content_type => format.to_sym
+      }
     end
 
     #== Resources
@@ -35,7 +41,10 @@ module RGeoServer
     # @param [Hash] options
     # @param [bool] check_remote if already exists in catalog and cache it
     # @yield [RGeoServer::ResourceInfo]
-    def list klass, names, options, check_remote = false,  &block
+    def list klass, names, options = {}, check_remote = false, &block
+      unless names.is_a? Array and not names.empty?
+        raise ArgumentError, "Missing names #{names}" 
+      end
       ResourceInfo.list klass, self, names, options, check_remote, &block
     end
 
@@ -43,28 +52,23 @@ module RGeoServer
 
     # List of available workspaces
     # @return [Array<RGeoServer::Workspace>]
-    def get_workspaces &block
-      response = self.search :workspaces => nil
-      doc = Nokogiri::XML(response)
-      workspaces = doc.xpath(Workspace.root_xpath).collect{|w| w.text.to_s }
-      list Workspace, workspaces, {}, &block
+    def get_workspaces
+      doc = Nokogiri::XML(search :workspaces => nil)
+      workspaces = doc.xpath("#{Workspace.root_xpath}/name/text()").collect {|w| w.to_s }
+      list Workspace.class, workspaces
     end
 
-    # @param [String] workspace name
+    # @param ws [String] workspace name
     # @return [RGeoServer::Workspace]
-    def get_workspace workspace
-      response = self.search :workspaces => workspace
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath(Workspace.member_xpath)
-      return Workspace.new self, :name => name.text if name
+    def get_workspace ws
+      doc = Nokogiri::XML(search :workspaces => ws)
+      Workspace.new self, :name => parse_name(doc, Workspace)
     end
+    
 
-    # @return [RGeoServer::Workspace]
+    # @return [RGeoServer::Workspace] get_workspace('default')
     def get_default_workspace
-      response = self.search :workspaces => 'default'
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath("#{Workspace.member_xpath}/name/text()").to_s
-      return Workspace.new self, :name => name
+      get_workspace 'default'
     end
 
     # Assign default workspace
@@ -77,6 +81,7 @@ module RGeoServer
       dws
     end
 
+    # @deprecated see RGeoServer::Workspace
     # @param [String] store
     # @param [String] workspace
     def reassign_workspace store, workspace
@@ -87,30 +92,29 @@ module RGeoServer
 
     # List of available layers
     # @return [Array<RGeoServer::Layer>]
-    def get_layers options = {}, &block
-      response = self.search :layers => nil
-      doc = Nokogiri::XML(response)
-      workspace_name = Workspace === options[:workspace] ? options[:workspace].name : options[:workspace]
-      layer_nodes = doc.xpath(Layer.root_xpath).collect{|l| l.text.to_s }
-      layers = list(Layer, layer_nodes, {}, &block)
-      layers = layers.find_all { |layer| layer.workspace.name == workspace_name } if options[:workspace]
-      layers
+    def each_layer options = {}
+      doc = Nokogiri::XML(self.search :layers => nil)
+      ap({:each_layer_doc => doc, :xpath => Layer.root_xpath}) if $DEBUG
+      doc.xpath(Layer.root_xpath + '/name/text()').each { |l|
+        ap({:layer => l.to_s.strip}) if $DEBUG
+        yield get_layer l.to_s.strip unless l.nil?
+      }
     end
 
-    # @param [String] layer name
+    # @param [String] layername
     # @return [RGeoServer::Layer]
-    def get_layer layer
-      response = self.search :layers => layer
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath("#{Layer.member_xpath}/name/text()").to_s
-      return Layer.new self, :name => name
+    def get_layer layername
+      raise ArgumentError, "#get_layer requires String #{layername}" unless layername.is_a? String
+      ap({:layers => layername}) if $DEBUG
+      doc = Nokogiri::XML(search :layers => layername)
+      Layer.new self, :name => layername
     end
 
     #= LayerGroups
 
     # List of available layer groups
     # @return [Array<RGeoServer::LayerGroup>]
-    def get_layergroups options = {}, &block
+    def get_layergroups options = {}
       response = unless options[:workspace]
                    self.search :layergroups => nil
                  else
@@ -118,36 +122,31 @@ module RGeoServer
                  end
       doc = Nokogiri::XML(response)
       layer_groups = doc.xpath(LayerGroup.root_xpath).collect{|l| l.text.to_s }.map(&:strip)
-      list LayerGroup, layer_groups, {workspace: options[:workspace]}, &block
+      list LayerGroup, layer_groups, :workspace => options[:workspace]
     end
 
     # @param [String] layer group name
     # @return [RGeoServer::LayerGroup]
     def get_layergroup layergroup
-      response = self.search :layergroups => layergroup
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath("#{LayerGroup.member_xpath}/name/text()").to_s
-      return LayerGroup.new self, :name => name
+      doc = Nokogiri::XML(search :layergroups => layergroup)
+      LayerGroup.new self, :name => parse_name(doc, LayerGroup)
     end
 
     #= Styles (SLD Style Layer Descriptor)
 
     # List of available styles
     # @return [Array<RGeoServer::Style>]
-    def get_styles &block
-      response = self.search :styles => nil
-      doc = Nokogiri::XML(response)
-      styles = doc.xpath(Style.root_xpath).collect{|l| l.text.to_s }
-      list Style, styles, {}, &block
+    def get_styles
+      doc = Nokogiri::XML(search :styles => nil)
+      styles = doc.xpath("#{Style.root_xpath}/name/text()").collect {|s| s.to_s }
+      list Style, styles
     end
 
     # @param [String] style name
     # @return [RGeoServer::Style]
     def get_style style
-      response = self.search :styles => style
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath("#{Style.member_xpath}/name/text()").to_s
-      return Style.new self, :name => name
+      doc = Nokogiri::XML(search :styles => style)
+      Style.new self, :name => parse_name(doc, Style)
     end
 
 
@@ -161,11 +160,9 @@ module RGeoServer
 
     # @return [RGeoServer::Namespace]
     def get_default_namespace
-      response = self.search :namespaces => 'default'
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath("#{Namespace.member_xpath}/prefix/text()").to_s
-      uri = doc.at_xpath("#{Namespace.member_xpath}/uri/text()").to_s
-      return Namespace.new self, :name => name, :uri => uri
+      doc = Nokogiri::XML(search :namespaces => 'default')
+      Namespace.new self, :name => parse_name(doc, Namespace, 'prefix'), 
+                          :uri => parse_name(doc, Namespace, 'uri')
     end
 
     def set_default_namespace id, prefix, uri
@@ -178,27 +175,24 @@ module RGeoServer
     # @param [String] workspace
     # @return [Array<RGeoServer::DataStore>]
     def get_data_stores workspace = nil
-      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)]
-      ds = []
-      ws.each{ |w| ds += w.data_stores if w.data_stores }
-      ds
+      ws = workspace.nil?? get_workspaces : [get_workspace(workspace)]
+      ws.map { |w| w.data_stores }.flatten
     end
 
     # @param [String] workspace
     # @param [String] datastore
     # @return [RGeoServer::DataStore]
     def get_data_store workspace, datastore
-      response = self.search({:workspaces => workspace, :name => datastore})
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath(DataStore.member_xpath)
-      return DataStore.new self, workspace, name.text if name
+      doc = Nokogiri::XML(search :workspaces => workspace, :datastores => datastore)
+      DataStore.new self, :workspace => workspace, 
+                          :name => parse_name(doc, DataStore)
     end
 
     # List of feature types
     # @param [String] workspace
     # @param [String] datastore
     # @return [Array<RGeoServer::FeatureType>]
-    def get_feature_types workspace, datastore
+    def get_feature_types workspace, datastore, &block
       raise NotImplementedError
     end
 
@@ -210,17 +204,14 @@ module RGeoServer
       raise NotImplementedError
     end
 
-
     #= Coverages (Raster datasets)
 
     # List of coverage stores
     # @param [String] workspace
     # @return [Array<RGeoServer::CoverageStore>]
     def get_coverage_stores workspace = nil
-      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)]
-      cs = []
-      ws.each{ |w| cs += w.coverage_stores if w.coverage_stores }
-      cs
+      ws = workspace.nil?? get_workspaces : [get_workspace(workspace)]
+      ws.map { |w| w.coverage_stores }.flatten
     end
 
     # @param [String] workspace
@@ -232,7 +223,10 @@ module RGeoServer
     end
 
     def get_coverage workspace, coverage_store, coverage
-      c = Coverage.new self, :workspace => workspace, :coverage_store => coverage_store, :name => coverage
+      c = Coverage.new self, 
+                       :workspace => workspace, 
+                       :coverage_store => coverage_store, 
+                       :name => coverage
       return c.new?? nil : c
     end
 
@@ -242,20 +236,16 @@ module RGeoServer
     # @param [String] workspace
     # @return [Array<RGeoServer::WmsStore>]
     def get_wms_stores workspace = nil
-      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)]
-      cs = []
-      ws.each{ |w| cs += w.wms_stores if w.wms_stores }
-      cs
+      ws = workspace.nil?? get_workspaces : [get_workspace(workspace)]
+      ws.map { |w| w.wms_stores }.flatten
     end
 
     # @param [String] workspace
     # @param [String] wmsstore
     # @return [RGeoServer::WmsStore]
     def get_wms_store workspace, wmsstore
-      response = self.search({:workspaces => workspace, :name => wmsstore})
-      doc = Nokogiri::XML(response)
-      name = doc.at_xpath(WmsStore.member_xpath)
-      return WmsStore.new self, workspace, name.text if name
+      doc = Nokogiri::XML(search :workspaces => workspace, :name => wmsstore)
+      WmsStore.new self, workspace, parse_name(doc, WmsStore)
     end
 
     #= Configuration reloading
@@ -270,6 +260,13 @@ module RGeoServer
       do_url 'reset', :put
     end
 
+    private
+    def parse_name doc, klass, k = 'name'
+      name = doc.at_xpath("#{klass.member_xpath}/#{k}/text()")
+      name = name.to_s unless name.nil?
+      name
+    end
+
   end
 
 end

data/lib/rgeoserver/config.rb

@@ -1,7 +1,17 @@
 require 'confstruct/configuration'
 
+# Uses config/defaults.yml or $RGEOSERVER_CONFIG from environment
+# See https://rubygems.org/gems/confstruct for details on file format
 module RGeoServer
-  Config = Confstruct::Configuration.new(YAML.load(File.read(File.expand_path('../../../config/config_defaults.yml', __FILE__))))
+    Config = Confstruct::Configuration.new(
+    YAML.load(
+      File.read(
+        ENV['RGEOSERVER_CONFIG'] ||
+        File.join(File.dirname(__FILE__), '..', '..', 'config', 'defaults.yml')
+        )
+      )
+    )
+
 end