voruby 1.1.1 → 2.0.0

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

@@ -1,644 +0,0 @@
-
-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