iij-dag-client 1.0.1

data/lib/dag/client/api/cluster.rb

@@ -0,0 +1,111 @@
+module Dag
+  class Client::API
+    module Cluster
+      include Dag::Client::API::ListParams
+      include Dag::Client::ClusterValidation
+
+      def cluster_info_list(options = {})
+        resource = '/v1/'
+        query_params = list_params(options)
+        status = options[:status]
+        if status
+          statuses = status.split(',')
+          if statuses.any? { |s| !valid_cluster_info_list_status?(s) }
+            raise Dag::Client::ParameterInvalid.new("status is invalid: #{status}")
+          end
+          query_params = query_params.merge('status' => status)
+        end
+
+        type = options[:type]
+        if type
+          query_params = query_params.merge('type' => type)
+        end
+
+        cluster_name = options[:cluster_name]
+        if cluster_name
+          query_params = query_params.merge('clusterName' => cluster_name)
+        end
+
+        order = options[:order]
+        if order
+          unless ['asc', 'desc'].include?(order)
+            raise Dag::Client::ParameterInvalid.new("order is invalid: #{order}")
+          end
+          query_params = query_params.merge('order' => order)
+        end
+
+        execute(RestParameter.new(:get, resource, cano_resource: 'clusterManagement', query_params: query_params ))
+      end
+
+      def cluster_info(cluster_name)
+        resource = "/v1/#{cluster_name}"
+        execute(RestParameter.new(:get, resource, cano_resource: 'clusterManagement'))
+      end
+
+      def cluster_restart(cluster_name, params = {})
+        resource = "/v1/#{cluster_name}"
+        parameters = {}
+        force = params[:force]
+        unless force.nil?
+          unless [TrueClass, FalseClass].any? { |c| force.kind_of?(c) }
+            raise Dag::Client::ParameterInvalid.new("force is invalid: #{force}")
+          end
+          parameters.merge!('force' => force)
+        end
+
+        type = params[:type]
+        if type.present?
+          parameters.merge!('type' => type)
+        end
+
+        debug = params[:debug]
+        unless debug.nil?
+          unless [TrueClass, FalseClass].any? { |c| debug.kind_of?(c) }
+            raise Dag::Client::ParameterInvalid.new("debug is invalid: #{debug}")
+          end
+
+          parameters.merge!('debug' => debug)
+        end
+
+        execute(RestParameter.new(:put, resource,
+                                  cano_resource: 'clusterManagement',
+                                  content_type: 'application/json',
+                                  parameters: parameters,
+                                  blank_body: true
+                                 ))
+      end
+
+      def statistics(cluster_name, options = {})
+        resource = "/v1/#{cluster_name}/statistics"
+        execute(RestParameter.new(:get, resource, cano_resource: 'clusterManagement'))
+      end
+
+      def cluster_export_log(cluster_name, params = {})
+        parameters = {}
+
+        output_log_path = params[:output_log_path]
+        raise Dag::Client::ParameterInvalid.new('output_log_path is blank') if output_log_path.blank?
+
+        unless output_log_path.start_with?('dag://')
+          raise Dag::Client::ParameterInvalid.new("output_log_path should start with 'dag://'")
+        end
+        unless output_log_path.end_with?('/')
+          raise Dag::Client::ParameterInvalid.new("output_log_path should end with '/'")
+        end
+
+        parameters = parameters.merge('outputLogPath' => output_log_path)
+
+        compress = params[:compress]
+        unless compress.nil?
+          unless [TrueClass, FalseClass].any? { |c| compress.kind_of?(c) }
+            raise Dag::Client::ParameterInvalid.new("compress is invalid: #{compress}")
+          end
+
+          parameters = parameters.merge(compress: params[:compress])
+        end
+        resource = "/v1/#{cluster_name}/log"
+        execute(RestParameter.new(:put, resource, cano_resource: 'clusterManagement', content_type: 'application/json', parameters: parameters))
+      end
+    end
+  end
+end

data/lib/dag/client/api/database.rb

@@ -0,0 +1,58 @@
+module Dag
+  class Client::API
+    module Database
+      include Dag::Client::API::ListParams
+
+      def database_list(cluster_name, options = {})
+        resource = "/v1/#{cluster_name}"
+        execute(RestParameter.new(:get, resource, cano_resource: 'database', query_params: list_params(options)))
+      end
+
+      def create_database(cluster_name, db_name)
+        raise Dag::Client::ParameterInvalid.new('cluster_name is blank') if cluster_name.blank?
+        raise Dag::Client::ParameterInvalid.new('db_name is blank') if db_name.blank?
+
+        if db_name.length < 3
+          raise Dag::Client::ParameterInvalid.new("db name is too short")
+        end
+
+        if db_name.length > 63
+          raise Dag::Client::ParameterInvalid.new("db name is too long")
+        end
+
+        if db_name !~ /\A[a-z0-9]+\Z/
+          raise Dag::Client::ParameterInvalid.new("db name is invalid")
+        end
+
+        if hive_reserved_word?(db_name)
+          raise Dag::Client::ParameterInvalid.new("db name is reserved by hive")
+        end
+
+        execute(RestParameter.new(:put, "/v1/#{cluster_name}/#{db_name}", content_type: 'application/json', cano_resource: "database"))
+      end
+
+      def delete_database(cluster_name, db_name)
+        execute(RestParameter.new(:delete, "/v1/#{cluster_name}/#{db_name}", content_type: 'application/json', cano_resource: "database"))
+      end
+
+      private
+
+      def hive_reserved_word?(word)
+        %w(
+          true false all and or not like asc desc order by group where
+          from as select distinct insert overwrite outer join left right
+          full on partition partitions table tables tblproperties show msck
+          directory local locks transform using cluster distribute sort union load
+          data inpath is null create external alter describe drop reanme to
+          comment boolean tinyint smallint int bigint float double date
+          datetime timestamp string binary array map reduce partitioned
+          clustered sorted into buckets row format delimited fields terminated
+          collection items keys lines stored sequencefile textfile inputformat
+          outputformat location tablesample bucket out of cast add replace
+          columns rlike regexp temporary function explain extended serde with
+          serdeproperties limit set tblproperties
+        ).include?(word)
+      end
+    end
+  end
+end

data/lib/dag/client/api/job.rb

@@ -0,0 +1,116 @@
+module Dag
+  class Client::API
+    module Job
+      include Dag::Client::API::ListParams
+
+      def query_info_list(options = {})
+        resource = "/v1/"
+        query_params = list_params(options)
+
+        status = options[:status]
+        if status
+          statuses = status.split(',')
+          if statuses.any? { |s| !['running', 'finished', 'canceled', 'error'].include?(s) }
+            raise Dag::Client::ParameterInvalid.new("status is invalid: #{status}")
+          end
+          query_params = query_params.merge('status' => status)
+        end
+
+        type = options[:type]
+        if type
+          unless ['select', 'split'].include?(type.to_s)
+            raise Dag::Client::ParameterInvalid.new("type is invalid: #{type}")
+          end
+          query_params = query_params.merge('type' => type)
+        end
+
+        cluster_name = options[:cluster_name]
+        if cluster_name
+          query_params = query_params.merge('clusterName' => cluster_name)
+        end
+
+        label_prefix = options[:label_prefix]
+        if label_prefix
+          query_params = query_params.merge('labelPrefix' => label_prefix)
+        end
+
+        cluster_rebooted = options[:cluster_rebooted]
+        unless cluster_rebooted.nil?
+          unless [TrueClass, FalseClass].any? { |c| cluster_rebooted.kind_of?(c) }
+            raise Dag::Client::ParameterInvalid.new("cluster_rebooted is invalid: #{cluster_rebooted}")
+          end
+          query_params = query_params.merge('clusterRebooted' => cluster_rebooted)
+        end
+
+        order = options[:order]
+        if order
+          unless ['asc', 'desc'].include?(order)
+            raise Dag::Client::ParameterInvalid.new("order is invalid: #{order}")
+          end
+          query_params = query_params.merge('order' => order)
+        end
+
+        execute(RestParameter.new(:get, resource, cano_resource: 'query', query_params: query_params))
+      end
+
+      def query_info(job_id)
+        resource = "/v1/#{job_id}"
+        execute(RestParameter.new(:get, resource, cano_resource: 'query'))
+      end
+
+      def query_log(job_id)
+        resource = "/v1/#{job_id}/log"
+        log_info = execute(RestParameter.new(:get, resource, cano_resource: 'query'))
+
+        if log_info.present?
+          io = StringIO.new('', 'r+')
+          log_info['log'].each_line do |line|
+            io.puts line unless line.include?('CLIService')
+          end
+          return { "log" => io.string }
+        end
+
+        log_info
+      end
+
+      def query_cancel(job_id)
+        resource = "/v1/#{job_id}"
+        execute(RestParameter.new(:delete, resource, cano_resource: 'query', content_type: 'application/json'))
+      end
+
+      def query(query: '', output_format: 'csv', output_resource_path: '', cluster_name: '', label: '')
+        raise Dag::Client::ParameterInvalid.new('query is blank') if query.blank?
+
+        raise Dag::Client::ParameterInvalid.new('query should start with SELECT') if query !~ /\ASELECT/i
+        raise Dag::Client::ParameterInvalid.new('query should not include OVERWRITE') if query =~ /OVERWRITE/i
+
+        if output_format && !['csv', 'tsv'].include?(output_format)
+          raise Dag::Client::ParameterInvalid.new('ouput_format should be csv or tsv')
+        end
+
+        raise Dag::Client::ParameterInvalid.new('output_resource_path is blank') if output_resource_path.blank?
+
+        unless output_resource_path.start_with?('dag://')
+          raise Dag::Client::ParameterInvalid.new("output_resource_path should start with 'dag://'")
+        end
+        unless output_resource_path.end_with?('/')
+          raise Dag::Client::ParameterInvalid.new("output_resource_path should end with '/'")
+        end
+
+        raise Dag::Client::ParameterInvalid.new('cluster_name is blank') if cluster_name.blank?
+
+
+        parameters = {
+          'outputFormat' => output_format || 'csv',
+          'outputResourcePath' => output_resource_path,
+          'query' => query,
+          'clusterName' => cluster_name,
+          'label' => label,
+        }
+
+        resource = "/v1/"
+        execute(RestParameter.new(:post, resource, cano_resource: 'select', content_type: 'application/json', parameters: parameters))
+      end
+    end
+  end
+end

data/lib/dag/client/api/list_params.rb

@@ -0,0 +1,36 @@
+module Dag
+  class Client::API
+    module ListParams
+      def list_params(options)
+        params = {}
+
+        max = options[:max]
+
+        if max.present?
+          unless max.kind_of?(Integer)
+            raise Dag::Client::ParameterInvalid.new("max should be integer")
+          end
+
+          if max < 1
+            raise Dag::Client::ParameterInvalid.new("max should be greater than 0:#{max}")
+          end
+
+          if max > 100
+            raise Dag::Client::ParameterInvalid.new("max should be less than 100 or equal to 100:#{max}")
+          end
+
+          params.merge!('max' => max)
+        end
+
+        marker = options[:marker]
+
+
+        if marker.present?
+          params.merge!('marker' => marker)
+        end
+
+        params
+      end
+    end
+  end
+end

data/lib/dag/client/api/rest_parameter.rb

@@ -0,0 +1,149 @@
+module Dag
+  class Client::API
+    class RestParameter
+
+      def initialize(method, resource, cano_resource: nil, query_params: {},
+                     parameters: {}, bucket: '', content_type: nil, import: false,
+                     raw_data: false, blank_body: false, headers: {}, multipart: false)
+
+        @method = method
+        @resource = resource
+        @cano_resource = cano_resource
+        @query_params = query_params
+        @parameters = parameters
+        @bucket = bucket
+        @content_type = content_type
+        @import = import
+        @raw_data = raw_data
+        @blank_body = blank_body
+        @headers = headers
+        @multipart = multipart
+      end
+
+      attr_reader :method
+      attr_reader :resource
+      attr_reader :cano_resource
+      attr_reader :query_params
+      attr_reader :parameters
+      attr_reader :bucket
+      attr_reader :content_type
+      attr_reader :headers
+
+      def url(uri, force_path_style = false)
+        url = uri.host
+        url += ":#{uri.port}" unless uri.port == 80 || uri.port == 443
+
+        if @bucket.present?
+          if force_path_style
+            url += '/' unless url.end_with? "/"
+            url += @bucket
+          else
+            url = [@bucket, url].join('.')
+            url += '/' unless url.end_with? "/"
+          end
+        end
+
+        if @bucket.blank? || @resource != '/'
+          url = File.join(url, @resource)
+        end
+
+        url += '/' if url.split('/').last == @bucket
+        url += '?' if @cano_resource.present? || @query_params.present?
+        url += @cano_resource if @cano_resource
+        url += '&' if @cano_resource.present? && @query_params.present?
+        url += "#{@query_params.to_param}" if @query_params.present?
+
+        uri.scheme + '://' + url
+      end
+
+      def http_verb
+        @method.to_s.upcase
+      end
+
+      def signature_content_type
+        result = ""
+        if @content_type.present?
+          result << @content_type
+        end
+
+        result << "\n"
+
+        result
+      end
+
+      def authentication(apikey, secret, force_path_style)
+
+        "IIJGIO" + " " + apikey + ":" + signature(secret, force_path_style)
+      end
+
+      def signature(secret, force_path_style = false)
+        http_verb = "#{self.http_verb}\n"
+        content_md5 = "\n"
+        content_type = signature_content_type
+        date = "#{calc_date}\n"
+
+        canonicalized_iijgio_headers = ""
+
+        string_to_sign = http_verb + content_md5 + content_type + date +
+            canonicalized_iijgio_headers + canonicalized_resource(force_path_style)
+
+        digest = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha1'), secret, string_to_sign)
+        Base64.encode64(digest).strip
+      end
+
+      def canonicalized_resource(force_path_style = false)
+        result = ''
+
+        if @bucket.present?
+          result = '/'
+          result += "#{@bucket}/"
+        end
+
+        if @bucket.blank? || @resource != '/'
+          result = File.join(result, @resource)
+        end
+
+        result += '?' if @cano_resource.present?
+        result += @cano_resource if @cano_resource
+
+        result
+      end
+
+      def calc_date
+        return @date if @date
+        @date = Time.now.httpdate
+
+        @date
+      end
+
+      def import?
+        @import
+      end
+
+      def multipart?
+        @multipart
+      end
+
+      def raw_data?
+        @raw_data
+      end
+
+      def blank_body?
+        @blank_body
+      end
+
+      def to_s
+        [
+          "method:#{@method}",
+          "resource: #{@resource}",
+          "cano_resource: #{@cano_resource}",
+          "query_params: #{@query_params}",
+          "bucket: #{@bucket}",
+          "parameters: #{@parameters}",
+          "headers: #{@headers}"
+        ].join(", ")
+      end
+
+    end
+  end
+end