voruby 1.1 → 1.1.1

data/lib/voruby/services/schema/schema.rb

@@ -0,0 +1,644 @@
+
+module VORuby
+  module Services
+    module Schema
+      
+      module SSException
+        # An exception thrown when the incoming type does not match
+        # the expected value.
+        class TypeException < Exception
+          # [_obj_:]
+          #  The object itself.
+          # [_prototype_:]
+          #  The prototype of the expected class.
+          def initialize(obj=nil, prototype=nil)
+            super("Invalid type: #{obj.class} (#{obj}) != #{prototype}")
+          end
+        end
+    	
+    	# A class which checks to see whether the type of the incoming class
+    	# matches expectation.
+        class TypeCheck
+          attr_accessor :obj, :proto
+    	  
+    	  # [_obj_:]
+    	  #  The object in question.
+    	  # [_proto_:]
+    	  #  The prototype of the expected class.
+          def initialize(obj=nil, proto=nil)
+    		@obj = obj
+    		@proto = proto
+          end
+          
+          # Check to see whether the class is of the expected type.
+          def check
+    		raise SSException::TypeException.new(@obj, @proto) if @obj == nil and !@obj.is_a?(@proto)
+          end
+          
+          def to_s
+    		"{object=#{@obj};prototype=#{@proto}}"
+          end
+        end
+      end
+      
+      module SchemaDefinition
+        class Table
+          #It's the same that MetaTable
+        end
+        
+        class MetaTable
+          attr_reader :name, :description, :rows
+          
+          def initialize(name=nil, description=nil, rows=nil)
+            @name = name
+            @description = description
+            @rows = rows
+          end
+          
+          # The node is MetaTable
+          def self.from_xml(node)
+            name_node = REXML::XPath.first(node, 'Name')
+            name = name_node.get_text.value.strip if name_node.get_text
+            
+            description_node = REXML::XPath.first(node, 'Description')
+            description = description_node.get_text.value.strip if description_node.get_text
+            
+            rows_node = REXML::XPath.first(node, 'Rows')
+            rows = rows_node.get_text.value.strip if rows_node.get_text
+            
+            return MetaTable.new(name, description, rows)
+          end
+          
+          def to_s
+            "{name=#{self.name};description=#{self.description};rows=#{self.rows}}"
+          end
+        end
+        
+        class ArrayOfMetaTable
+          attr_reader :meta_tables
+          
+          def initialize(meta_tables=[])
+            @meta_tables = meta_tables
+          end
+          
+          # The node is MetaTable
+          def self.from_xml(node)
+            meta_tbls = []
+            
+            node.elements.each('MetaTable') do |elem|
+              meta_table = MetaTable.from_xml(elem)
+              meta_tbls.push(meta_table) if meta_table
+            end
+            
+            return ArrayOfMetaTable.new(meta_tbls)
+          end
+          
+          def to_s
+            meta_tbls = []
+            @meta_tables.each do |meta_table|
+              meta_tbls.push(meta_table.to_s)
+            end
+            
+            return "{meta_tables=[#{meta_tbls.join(',')}]}"
+          end
+        end
+        
+        class Column
+          attr_reader :name
+          
+          def initialize(name=nil)
+            @name = name
+          end
+          
+          # The node is String
+          def self.from_xml(node)
+            return Column.new(node.get_text.value.strip) if node.has_text?
+          end
+          
+          def to_s
+            "name=#{self.name}"
+          end
+        end
+        
+        class ArrayOfString
+          attr_reader :columns
+          
+          def initialize(columns=[])
+            @columns = columns
+          end
+          
+          # The node is String
+          def self.from_xml(node)
+            cols = []
+            
+            node.elements.each('string') do |elem|
+              column = Column.from_xml(elem)
+              cols.push(column) if column
+            end
+            
+            return ArrayOfString.new(cols)
+          end
+          
+          def to_s
+            cols = []
+            @columns.each do |col|
+              cols.push(col.to_s)
+            end
+            
+            return "{columns=[#{cols.join(',')}]}"
+          end
+        end
+        
+        class MetaColumn
+          attr_reader :name, :type, :unit, :description, :ucd
+          
+          def initialize(name=nil, type=nil, unit=nil, description=nil, ucd=nil)
+            @name = name
+            @type = type
+            @unit = unit
+            @description = description
+            @ucd = ucd
+          end
+          
+          # The node is MetaColumn
+          def self.from_xml(node)
+            name_node = REXML::XPath.first(node, 'Name')
+            name = name_node.get_text.value.strip if name_node.get_text
+            
+            type_node = REXML::XPath.first(node, 'Type')
+            type = type_node.get_text.value.strip if type_node.get_text
+            
+            unit_node = REXML::XPath.first(node, 'Unit')
+            unit = unit_node.get_text.value.strip if unit_node.get_text
+            
+            description_node = REXML::XPath.first(node, 'Description')
+            description = description_node.get_text.value.strip if description_node.get_text
+            
+            ucd_node = REXML::XPath.first(node, 'UCD')
+            ucd = ucd_node.get_text.value.strip if ucd_node.get_text
+            
+            return MetaColumn.new(name, type, unit, description, ucd)
+          end
+          
+          def to_s
+            "{name=#{self.name};type=#{self.type};unit=#{self.unit};" +
+            "description=#{self.description};ucd=#{self.ucd}}"
+          end
+        end
+        
+        class ArrayOfMetaColumn
+          attr_reader :meta_columns
+          
+          def initialize(meta_columns=[])
+            @meta_columns = meta_columns
+          end
+          
+          # The node is String
+          def self.from_xml(node)
+            meta_cols = []
+            
+            node.elements.each('MetaColumn') do |elem|
+              meta_column = MetaColumn.from_xml(elem)
+              meta_cols.push(meta_column) if meta_column
+            end
+            
+            return ArrayOfMetaColumn.new(meta_cols)
+          end
+          
+          def to_s
+            meta_cols = []
+            @meta_columns.each do |meta_col|
+              meta_cols.push(meta_col.to_s)
+            end
+            
+            return "{meta_columns=[#{meta_cols.join(',')}]}"
+          end
+        end
+      end
+      
+      module HTTPGetQuery
+        require 'net/http'
+        require 'net/https'
+        require 'uri'
+        
+        def fetch
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.read_timeout = query_timeout()
+          http.use_ssl = (uri.scheme == 'https')# enable SSL/TLS
+          
+          if http.use_ssl
+            http.ca_path = ssl_files[:ca_path]
+            http.cert = OpenSSL::X509::Certificate.new(File.read(ssl_files[:cert_file]))
+            http.key = OpenSSL::PKey::RSA.new(File.read(ssl_files[:key_file]), ssl_files[:password])
+          end
+          
+          res = http.start {|http|
+            http.get(uri.path + '?' + required_parameters().join('&'))
+          }
+          
+          self.response = res.body
+        end
+        
+        # URI::InvalidURIError: Raised if URI given is not a correct one.
+        def uri=(u)
+          @uri = URI.parse(u)
+        end
+        
+        def ssl_files=(sf)
+          if sf != nil
+            SSException::TypeCheck.new(sf, Hash).check()
+            raise "CA certification path isn't directory" if sf[:ca_path] == nil and 
+                !File.directory?(sf[:ca_path])
+            raise "SSL Certificate file doesn't exists" if sf[:cert_file] == nil and 
+                !File.exist?(sf[:cert_file])
+            raise "SSL Key file doesn't exists" if sf[:key_file] == nil and 
+                !File.exist?(sf[:key_file])
+            @ssl_files = sf
+          end
+        end
+        
+        def query_timeout=(qt)
+          SSException::TypeCheck.new(qt, Integer).check()
+          @query_timeout = qt
+        end
+      end
+      
+      module SSParameters
+        require 'uri'
+        
+        class Method
+          attr_reader :method
+          
+          def initialize(method)
+            self.method = method
+          end
+          
+          def method=(m)
+            SSException::TypeCheck.new(m, String).check()
+            raise "method parameter is empty" if m.empty?
+            @method = m
+          end
+          
+          def to_p
+            URI.escape("method=#{self.method}")
+          end
+          
+          def to_s
+            "#{self.method}"
+          end
+        end
+        
+        class TableName
+          attr_reader :table_name
+          
+          def initialize(table_name)
+            self.table_name = table_name
+          end
+          
+          def table_name=(t)
+            SSException::TypeCheck.new(t, String).check()
+            raise "table_name parameter is empty" if t.empty?
+            @table_name = t
+          end
+          
+          def to_p
+            URI.escape("tableName=#{self.table_name}")
+          end
+          
+          def to_s
+            "#{self.table_name}"
+          end
+        end
+        
+        class ColumnName
+          attr_reader :column_name
+          
+          def initialize(column_name)
+            self.column_name = column_name
+          end
+          
+          def column_name=(c)
+            SSException::TypeCheck.new(c, String).check()
+            raise "column_name parameter is empty" if c.empty?
+            @column_name = c
+          end
+          
+          def to_p
+            URI.escape("columnName=#{self.column_name}")
+          end
+          
+          def to_s
+            "#{self.column_name}"
+          end
+        end
+      end
+      
+      module SSResponse
+        require 'rexml/document'
+        
+        class ResponseParser
+          attr_reader :xml_doc
+          
+          def initialize(src)
+            begin
+              @xml_doc = REXML::Document.new(src)
+            rescue Exception => e
+              raise "REXML Exception, is a XML?: #{e.message}"
+            end
+          end
+          
+          def parse
+            return ResponseDocument.from_xml(self.xml_doc.root)
+          end
+        end
+        
+        class ObjectBuilder
+          def self.classes
+            {:ArrayOfMetaTable => SchemaDefinition::ArrayOfMetaTable,
+             :MetaTable => SchemaDefinition::MetaTable,
+             :ArrayOfString => SchemaDefinition::ArrayOfString,
+             :ArrayOfMetaColumn => SchemaDefinition::ArrayOfMetaColumn,
+             :MetaColumn => SchemaDefinition::MetaColumn}
+          end
+          
+          def self.get_class_for(type)
+            klass = self.classes()[type.to_sym] || self.classes()[type]
+            raise "Unable to find type #{type}" if !klass
+            return klass
+          end
+        end
+        
+        class ResponseContent
+          def self.from_xml(node)
+            return ObjectBuilder.get_class_for(node.name).from_xml(node)
+          end
+        end
+        
+        class ResponseDocument
+          attr_reader :response, :status, :message
+          
+          def initialize(response=nil, status=nil, message=nil)
+            @response = response
+            @status = status
+            @message = message
+          end
+          
+          def self.from_xml(root)
+            raise "root element is null." if root == nil
+            
+            response = ResponseContent.from_xml(root)
+            
+            if !response
+              status = root.attributes['status']
+              message = root.get_text.value.strip if root.has_text?
+            end
+            
+            return ResponseDocument.new(response, status, message)
+          end
+          
+          def to_s
+            "{response=#{self.response};status=#{self.status};message=#{self.message}}"
+          end
+        end
+      end
+      
+      module SchemaRetrieval
+        class SchemaRetrievalGeneric
+          def method=(m)
+            @method = SSParameters::Method.new(m)
+          end
+          
+          def marshall
+            raise "response parameter is null" if self.response == nil
+            return SSResponse::ResponseParser.new(self.response).parse()
+          end
+          
+          def to_s
+            "uri=#{self.uri.to_s};method=#{self.method.to_s};" +
+                "response=#{self.response.to_s};" +
+                "query_timeout=#{query_timeout.to_s}"
+          end
+        end
+        
+        # Gets the list of table names.
+        class GetTables < SchemaRetrievalGeneric
+          include HTTPGetQuery
+          
+          attr_reader :uri, :ssl_files, :query_timeout, :method
+          attr_accessor :response
+          
+          def initialize(uri, ssl_files=nil, query_timeout=30)
+            self.uri = uri
+            
+            self.ssl_files = ssl_files
+            self.query_timeout = query_timeout
+            
+            self.method = 'getTables'
+            
+            self.response = nil
+          end
+          
+          def required_parameters
+            [self.method.to_p]
+          end
+          
+          def to_s
+            super.to_s
+          end
+        end
+        
+        # Just like getTables class but with additional metadata info.
+        class GetMetaTables < SchemaRetrievalGeneric
+          include HTTPGetQuery
+          
+          attr_reader :uri, :ssl_files, :query_timeout, :method
+          attr_accessor :response
+          
+          def initialize(uri, ssl_files=nil, query_timeout=30)
+            self.uri = uri
+            
+            self.ssl_files = ssl_files
+            self.query_timeout = query_timeout
+            
+            self.method = 'getMetaTables'
+            
+            self.response = nil
+          end
+          
+          def required_parameters
+            [self.method.to_p]
+          end
+          
+          def to_s
+            super.to_s
+          end
+        end
+        
+        # Gets the info associated to a table
+        class GetTableInfo < SchemaRetrievalGeneric
+          include HTTPGetQuery
+          
+          attr_reader :uri, :ssl_files, :query_timeout, :method, :table_name
+          attr_accessor :response
+          
+          def initialize(uri, table_name, ssl_files=nil, query_timeout=30)
+            self.uri = uri
+            self.table_name = table_name
+            
+            self.ssl_files = ssl_files
+            self.query_timeout = query_timeout
+            
+            self.method = 'getTableInfo'
+            
+            self.response = nil
+          end
+          
+          def table_name=(t)
+            @table_name = SSParameters::TableName.new(t)
+          end
+          
+          def required_parameters
+            [self.method.to_p, self.table_name.to_p]
+          end
+          
+          def to_s
+            super.to_s + ";table_name=#{self.table_name.to_s}"
+          end
+        end
+        
+        # Gets the list of column names for a particular table.
+        class GetColumns < SchemaRetrievalGeneric
+          include HTTPGetQuery
+          
+          attr_reader :uri, :ssl_files, :query_timeout, :method, :table_name
+          attr_accessor :response
+          
+          def initialize(uri, table_name, ssl_files=nil, query_timeout=30)
+            self.uri = uri
+            self.table_name = table_name
+            
+            self.ssl_files = ssl_files
+            self.query_timeout = query_timeout
+            
+            self.method = 'getColumns'
+            
+            self.response = nil
+          end
+          
+          def table_name=(t)
+            @table_name = SSParameters::TableName.new(t)
+          end
+          
+          def required_parameters
+            [self.method.to_p, self.table_name.to_p]
+          end
+          
+          def to_s
+            super.to_s + ";table_name=#{self.table_name.to_s}"
+          end
+        end
+        
+        # Just like getColumns but with additional metadata info.
+        class GetMetaColumns < SchemaRetrievalGeneric
+          include HTTPGetQuery
+          
+          attr_reader :uri, :ssl_files, :query_timeout, :method, :table_name
+          attr_accessor :response
+          
+          def initialize(uri, table_name, ssl_files=nil, query_timeout=30)
+            self.uri = uri
+            self.table_name = table_name
+            
+            self.ssl_files = ssl_files
+            self.query_timeout = query_timeout
+            
+            self.method = 'getMetaColumns'
+            
+            self.response = nil
+          end
+          
+          def table_name=(t)
+            @table_name = SSParameters::TableName.new(t)
+          end
+          
+          def required_parameters
+            [self.method.to_p, self.table_name.to_p]
+          end
+          
+          def to_s
+            super.to_s + ";table_name=#{self.table_name.to_s}"
+          end
+        end
+        
+        # Gets the info associated to a column.
+        class GetColumnInfo < SchemaRetrievalGeneric
+          include HTTPGetQuery
+          
+          attr_reader :uri, :ssl_files, :query_timeout, :method, :table_name, :column_name
+          attr_accessor :response
+          
+          def initialize(uri, table_name, column_name, ssl_files=nil, query_timeout=30)
+            self.uri = uri
+            self.table_name = table_name
+            self.column_name = column_name
+            
+            self.ssl_files = ssl_files
+            self.query_timeout = query_timeout
+            
+            self.method = 'getColumnInfo'
+            
+            self.response = nil
+          end
+          
+          def table_name=(t)
+            @table_name = SSParameters::TableName.new(t)
+          end
+          
+          def column_name=(c)
+            @column_name = SSParameters::ColumnName.new(c)
+          end
+          
+          def required_parameters
+            [self.method.to_p, self.table_name.to_p, self.column_name.to_p]
+          end
+          
+          def to_s
+            super.to_s + ";table_name=#{self.table_name.to_s};column_name=#{self.column_name}"
+          end
+        end
+      end
+      
+      class QueryExecutor
+        attr_reader :queries, :results
+        
+        def initialize(queries=[], abort_on_exception=false)
+          self.queries = queries
+          Thread::abort_on_exception = abort_on_exception
+          
+          @results = {}
+          begin_queries()
+        end
+        
+        def queries=(q)
+          SSException::TypeCheck.new(q, Array).check()
+          raise "queries Array is empty" if q.empty?
+          @queries = q
+        end
+        
+        def begin_queries
+          threads = []
+          
+          queries.each do |query|
+            threads << Thread.new(query){ |the_query|
+              the_query.fetch()
+              @results[the_query] = the_query.marshall()
+            }
+          end
+          
+          threads.each{ |thread| thread.join() }
+        end
+      end
+      
+    end
+  end
+end

data/lib/voruby/simple/sap.rb

@@ -47,7 +47,7 @@ module VORuby
       #    * Simple::ConeSearch (Simple Cone Search queries)
       # [_converter_:]
       #    An anonymous subroutine that can be used to convert the result of a
-      #    query into another form--often a VOTABLE::VOTable for our purposes.
+      #    query into another form--often a VOTable::VOTable for our purposes.
       #    By default, it simply returns the completed query. 
       # [_abort_on_exeception_:]
       #     A flag which indicates whether or not if one query fails, the other queries
@@ -121,7 +121,7 @@ module VORuby
     end
 
     # Mixin a method that converts an XML VOTable into an object using
-    # a VOTABLE::TreeParsedVOTable.
+    # a VOTable::TreeParsedVOTable.
     module VOTableMarshaller
       # Interpret the response into an object.
       def marshall