rgeoserver 0.5.9 → 0.7

data/lib/rgeoserver/coverage.rb

@@ -7,21 +7,33 @@ module RGeoServer
       :catalog => "catalog", 
       :workspace => "workspace", 
       :coverage_store => "coverage_store", 
+      :enabled => "enabled",
       :name => "name", 
       :title => "title", 
       :abstract => "abstract", 
+      :keywords => "keywords", 
+      :metadata => "metadata", 
       :metadata_links => "metadataLinks" 
     }
     OBJ_DEFAULT_ATTRIBUTES = {
       :catalog => nil, 
       :workspace => nil, 
       :coverage_store => nil, 
+      :enabled => "true",
       :name => nil, 
       :title => nil, 
       :abstract => nil,  
+      :keywords => [],  
+      :metadata => {},  
       :metadata_links => [] 
     } 
    
+    # see http://inspire.ec.europa.eu/schemas/common/1.0/common.xsd
+    @@metadata_types = {
+      'ISO19139' => 'application/vnd.iso.19139+xml',
+      'TC211' => 'application/vnd.iso.19139+xml'
+    }
+   
     define_attribute_methods OBJ_ATTRIBUTES.keys
     update_attribute_accessors OBJ_ATTRIBUTES
 
@@ -45,24 +57,36 @@ module RGeoServer
       @@route % [@workspace.name , @coverage_store.name]
     end
 
+    def to_mimetype(type, default = 'text/xml')
+      return @@metadata_types[type.upcase] if @@metadata_types.include?(type.upcase) 
+      default
+    end
+
     def message
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.coverage {
           xml.name @name
           xml.title @title 
-          unless new?
+          xml.enabled @enabled if enabled_changed? or new?
+          if new?
             xml.nativeName @name
             xml.abstract @abtract if abstract_changed?
             xml.metadataLinks {
-              @metadata_links.each{ |m|
+              @metadata_links.each do |m|
                 xml.metadataLink {
-                  xml.type_ m['type']
+                  xml.type_ to_mimetype(m['metadataType'])
                   xml.metadataType m['metadataType']
                   xml.content m['content']
                 }
-              }
-            } if metadata_links_changed?
+              end
+            } if @metadata_links
           end
+          xml.keywords {
+            @keywords.each do |k|
+              xml.keyword RGeoServer::Metadata::to_keyword(k)
+            end
+          } if @keywords and new? or keywords_changed?
+          
         }
       end
       @message = builder.doc.to_xml 
@@ -71,9 +95,8 @@ module RGeoServer
     # @param [RGeoServer::Catalog] catalog
     # @param [Hash] options
     def initialize catalog, options 
-      super({})
+      super(catalog)
       _run_initialize_callbacks do
-        @catalog = catalog
         workspace = options[:workspace] || 'default'
         if workspace.instance_of? String
           @workspace = @catalog.get_workspace(workspace)
@@ -94,9 +117,10 @@ module RGeoServer
         @name = options[:name]
         @enabled = options[:enabled] || true
         @route = route
-      end        
+      end
     end
 
+    # @return [Hash] extraction from GeoServer XML for this coverage
     def profile_xml_to_hash profile_xml
       doc = profile_xml_to_ng profile_xml
       h = {
@@ -123,17 +147,21 @@ module RGeoServer
         },
         "abstract" => doc.at_xpath('//abstract/text()').to_s, 
         "supportedFormats" => doc.xpath('//supportedFormats/string').collect{ |t| t.to_s },
-        "metadataLinks" => doc.xpath('//metadataLinks/metadataLink').collect{ |m| 
-          { 
-            'type' => m.at_xpath('//type/text()').to_s, 
+        "keywords" => doc.at_xpath('//keywords').collect { |kl|
+          {
+            'keyword' => kl.at_xpath('//string/text()').to_s
+          }
+        },
+        "metadataLinks" => doc.xpath('//metadataLinks/metadataLink').collect{ |m|
+          {
+            'type' => m.at_xpath('//type/text()').to_s,
             'metadataType' => m.at_xpath('//metadataType/text()').to_s,
-            'content' => m.at_xpath('//content').text.strip
-          } 
-        }
+            'content' => m.at_xpath('//content/text()').to_s
+          }
+        },
       }.freeze
       h  
     end
 
-
   end
 end 

data/lib/rgeoserver/coveragestore.rb

@@ -3,8 +3,24 @@ module RGeoServer
   # A coverage store is a source of spatial data that is raster based.
   class CoverageStore < ResourceInfo
 
-    OBJ_ATTRIBUTES = {:catalog => 'catalog', :workspace => 'workspace', :url => 'url', :data_type => 'type', :name => 'name', :enabled => 'enabled', :description => 'description'}  
-    OBJ_DEFAULT_ATTRIBUTES = {:catalog => nil, :workspace => nil, :url => '', :data_type => 'GeoTIFF', :name => nil, :enabled => 'true', :description=>nil}  
+    OBJ_ATTRIBUTES = {
+      :catalog => 'catalog', 
+      :workspace => 'workspace', 
+      :url => 'url', 
+      :data_type => 'type', 
+      :name => 'name', 
+      :enabled => 'enabled', 
+      :description => 'description'
+    }  
+    OBJ_DEFAULT_ATTRIBUTES = {
+      :catalog => nil, 
+      :workspace => nil, 
+      :url => '', 
+      :data_type => 'GeoTIFF', 
+      :name => nil, 
+      :enabled => 'true', 
+      :description=>nil
+    }  
     define_attribute_methods OBJ_ATTRIBUTES.keys
     update_attribute_accessors OBJ_ATTRIBUTES
 
@@ -56,9 +72,8 @@ module RGeoServer
     # @param [RGeoServer::Workspace|String] workspace
     # @param [String] name
     def initialize catalog, options 
-      super({})
+      super(catalog)
       _run_initialize_callbacks do
-        @catalog = catalog
         workspace = options[:workspace] || 'default'
         if workspace.instance_of? String
           @workspace = @catalog.get_workspace(workspace)
@@ -72,21 +87,41 @@ module RGeoServer
       end        
     end
 
-    def coverages &block
-      self.class.list Coverage, @catalog, profile['coverages'], {:workspace => @workspace, :coverage_store => self}, check_remote = true, &block
+    def coverages
+      yield self.class.list Coverage, @catalog, profile['coverages'], {:workspace => @workspace, :coverage_store => self}, true
     end
 
+    # <coverageStore>
+    # <name>antietam_1867</name>
+    # <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.
+    # </description>
+    # <type>GeoTIFF</type>
+    # <enabled>true</enabled>
+    # <workspace>
+    # <name>druid</name>
+    # <atom:link xmlns:atom="http://www.w3.org/2005/Atom" rel="alternate" href="http://localhost:8080/geoserver/rest/workspaces/druid.xml" type="application/xml"/>
+    # </workspace>
+    # <__default>false</__default>
+    # <url>
+    # file:///var/geoserver/current/staging/rumsey/g3881015alpha.tif
+    # </url>
+    # <coverages>
+    # <atom:link xmlns:atom="http://www.w3.org/2005/Atom" rel="alternate" href="http://localhost:8080/geoserver/rest/workspaces/druid/coveragestores/antietam_1867/coverages.xml" type="application/xml"/>
+    # </coverages>
+    # </coverageStore>
     def profile_xml_to_hash profile_xml
-      doc = profile_xml_to_ng profile_xml 
+      doc = profile_xml_to_ng profile_xml
       h = {
         'name' => doc.at_xpath('//name').text.strip, 
-        'workspace' => @workspace.name, 
+        'description' => doc.at_xpath('//description/text()').to_s,
         'type' => doc.at_xpath('//type/text()').to_s,
         'enabled' => doc.at_xpath('//enabled/text()').to_s,
-        'description' => doc.at_xpath('//description/text()').to_s,
-        'url' => doc.at_xpath('//url/text()').to_s
+        'url' => doc.at_xpath('//url/text()').to_s,
+        'workspace' => @workspace.name # Assume correct workspace
       }
-      doc.xpath('//coverages/atom:link/@href', "xmlns:atom"=>"http://www.w3.org/2005/Atom" ).each{ |l| 
+      doc.xpath('//coverages/atom:link[@rel="alternate"]/@href', 
+                "xmlns:atom"=>"http://www.w3.org/2005/Atom" ).each{ |l| 
         h['coverages'] = begin
           response = @catalog.do_url l.text
           Nokogiri::XML(response).xpath('//name/text()').collect{ |a| a.text.strip }

data/lib/rgeoserver/datastore.rb

@@ -23,8 +23,23 @@ module RGeoServer
       end
     end
 
-    OBJ_ATTRIBUTES = {:enabled => "enabled", :catalog => "catalog", :workspace => "workspace", :name => "name", :connection_parameters => "connection_parameters"}
-    OBJ_DEFAULT_ATTRIBUTES = {:enabled => 'true', :catalog => nil, :workspace => nil, :name => nil, :connection_parameters => {}}
+    OBJ_ATTRIBUTES = {
+      :workspace => 'workspace', 
+      :connection_parameters => "connection_parameters",
+      :name => 'name', 
+      :data_type => 'type', 
+      :enabled => 'enabled', 
+      :description => 'description'
+    }  
+    OBJ_DEFAULT_ATTRIBUTES = {
+      :workspace => nil, 
+      :connection_parameters => {}, 
+      :name => nil, 
+      :data_type => :shapefile,
+      :enabled => true, 
+      :description => nil
+    }  
+    
     define_attribute_methods OBJ_ATTRIBUTES.keys
     update_attribute_accessors OBJ_ATTRIBUTES
 
@@ -62,33 +77,36 @@ module RGeoServer
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.dataStore {
           xml.name @name
-          xml.enabled enabled
+          xml.enabled @enabled
+          xml.description @description
+          xml.type_ @data_type if (data_type_changed? || new?)
           xml.connectionParameters {  # this could be empty
-            connection_parameters.each_pair { |k,v|
+            @connection_parameters.each_pair { |k,v|
               xml.entry(:key => k) {
                 xml.text v
               }
-            } unless connection_parameters.nil? || connection_parameters.empty?
+            } unless @connection_parameters.nil? || @connection_parameters.empty?
           }
         }
       end
+      # ap builder.doc
       builder.doc.to_xml
     end
 
     # @param [RGeoServer::Catalog] catalog
-    # @param [RGeoServer::Workspace|String] workspace
-    # @param [String] name
+    # @param [RGeoServer::Workspace|String] options `:workspace`
+    # @param [String] options `:name`
     def initialize catalog, options
       super({})
       _run_initialize_callbacks do
         @catalog = catalog
         workspace = options[:workspace] || 'default'
         if workspace.instance_of? String
-          @workspace = @catalog.get_workspace(workspace)
+          @workspace = catalog.get_workspace(workspace)
         elsif workspace.instance_of? Workspace
           @workspace = workspace
         else
-          raise "Not a valid workspace"
+          raise ArgumentError, "Not a valid workspace: #{workspace}"
         end
 
         @name = options[:name].strip
@@ -97,60 +115,48 @@ module RGeoServer
     end
 
     def featuretypes &block
-      self.class.list FeatureType, @catalog, profile['featureTypes'], {:workspace => @workspace, :data_store => self}, check_remote = true, &block
+      self.class.list FeatureType, catalog, profile['featureTypes'], {:workspace => @workspace, :data_store => self}, true, &block
     end
 
-    # @param [String] file_path
-    # @param [Hash] options { data_type: [:shapefile] }. optional
-    def upload_file file_path, options = {}
-      raise DataStoreAlreadyExists, @name unless new?
+    def upload_file local_file, publish = {}
+      upload local_file, :file, data_type, publish
+    end
+    def upload_external remote_file, publish = {}
+      puts "Uploading external file #{remote_file} #{publish}"
+      upload remote_file, :external, data_type, publish
+    end
+    def upload_url url, publish = {}
+      upload url, :url, data_type, publish
+    end
+    
+    # @param [String] path - location of upload data
+    # @param [Symbol] upload_method -- flag for :file, :url, or :external
+    # @param [Symbol] data_type -- currently only :shapefile
+    # @param [Boolean] publish -- only valid for :file  
+    def upload path, upload_method = :file, data_type = :shapefile, publish = false
+      ap({ :path => path, :upload_method => upload_method, :data_type => data_type, :publish => publish, :self => self}) if $DEBUG
 
-      options = options.dup
-
-      data_type = options.delete(:data_type) || :shapefile
-      data_type = data_type.to_sym
-
-      publish = options.delete(:publish) || false
-
-      upload_url_suffix = case data_type
-                          when :shapefile then "#{update_route}/file.shp"
-                          else
-                            raise DataTypeNotExpected, data_type
-                          end
-
-      @catalog.client[upload_url_suffix].put File.read(file_path), :content_type => 'application/zip'
-
-      clear
-      connection_parameters['url'] = connection_parameters['url'].gsub(/.*data/, '').insert(0, 'file:data') #correct to relative path
-      save
-      clear
-
-      if publish
-        ft = RGeoServer::FeatureType.new @catalog, :workspace => @workspace, :data_store => self, :name => @name
-        ft.title = ft.name.capitalize
-        ft.abstract = ft.name.capitalize
-        ft.enabled = true
-
-        bounds = case data_type
-                 when :shapefile
-                   shpInfo = ShapefileInfo.new file_path
-                   shpInfo.bounds
-                 else
-                   raise DataTypeNotExpected, data_type
-                 end
-
-        ft.native_bounds['minx'], ft.native_bounds['miny'], ft.native_bounds['maxx'], ft.native_bounds['maxy'] =
-          bounds.to_a
-        ft.projection_policy = :force
-        ft.save
-
-        layers = catalog.get_layers workspace: @workspace
-        layers.find_all{ |layer| layer.name == ft.name }.each do |layer|
-          layer.enabled = true
-          layer.save
+      raise DataStoreAlreadyExists, @name unless new?
+      raise DataTypeNotExpected, data_type unless [:shapefile].include? data_type
+
+      ext = 'shp'
+      case upload_method
+      when :file then # local file that we post
+        local_file = File.expand_path(path)
+        unless local_file =~ %r{\.zip$} and File.exist? local_file
+          raise ArgumentError, "Shapefile upload must be ZIP file: #{local_file}" 
         end
+        puts "Uploading #{File.size(local_file)} bytes from file #{local_file}..."
+        
+        catalog.client["#{route}/#{name}/file.#{ext}"].put File.read(local_file), :content_type => 'application/zip'
+        refresh
+      when :external then # remote file that we reference
+        catalog.client["#{route}/#{name}/external.#{ext}"].put path, :content_type => 'text/plain'
+      when :url then
+        catalog.client["#{route}/#{name}/url.#{ext}"].put path, :content_type => 'text/plain'
+      else
+        raise NotImplementedError, "Unsupported upload method #{upload_method}"
       end
-
       self
     end
 
@@ -158,17 +164,22 @@ module RGeoServer
       doc = profile_xml_to_ng profile_xml
       h = {
         "name" => doc.at_xpath('//name').text.strip,
+        "description" => doc.at_xpath('//description/text()').to_s,
         "enabled" => doc.at_xpath('//enabled/text()').to_s,
-        "connection_parameters" => doc.xpath('//connectionParameters/entry').inject({}){ |h, e| h.merge(e['key']=> e.text.to_s) }
+        'type' => doc.at_xpath('//type/text()').to_s,
+        "connection_parameters" => doc.xpath('//connectionParameters/entry').inject({}){ |x, e| x.merge(e['key']=> e.text.to_s) }
       }
-      doc.xpath('//featureTypes/atom:link/@href', "xmlns:atom"=>"http://www.w3.org/2005/Atom" ).each{ |l|
+      # XXX: assume that we know the workspace for <workspace>...</workspace>
+      doc.xpath('//featureTypes/atom:link[@rel="alternate"]/@href', 
+                "xmlns:atom"=>"http://www.w3.org/2005/Atom" ).each do |l|
         h["featureTypes"] = begin
-                              response = @catalog.do_url l.text
+                              response = catalog.do_url l.text
+                              # lazy loading: only loads featuretype names
                               Nokogiri::XML(response).xpath('//name/text()').collect{ |a| a.text.strip }
                             rescue RestClient::ResourceNotFound
                               []
                             end.freeze
-      }
+      end
       h
     end
   end