iij-dag-client 1.0.1

data/lib/dag/client/cluster.rb

@@ -0,0 +1,26 @@
+module Dag
+  class Client
+    module Cluster
+      include Dag::Client::ClusterValidation
+
+      attr_reader :cluster_name
+
+      def open(cluster_name)
+        @cluster_name = cluster_name
+        self
+      end
+
+      def clusters
+        Dag::ClusterCollection.new(@api)
+      end
+
+      def cluster
+        if @cluster_name.blank?
+          raise Dag::Client::ClusterNotOpen.new("cluster not opened")
+        end
+        cluster_status
+        Dag::Cluster.new(@api, @cluster_info.merge("name" => @cluster_name))
+      end
+    end
+  end
+end

data/lib/dag/client/cluster_validation.rb

@@ -0,0 +1,59 @@
+module Dag
+  class Client
+    module ClusterValidation
+      def cluster_status
+        return @cluster_status if @cluster_status
+
+        if @cluster_info
+          return @cluster_info['status']
+        end
+
+        return unless @cluster_name
+        @cluster_info = @api.cluster_info(@cluster_name)
+        @cluster_status = @cluster_info['status']
+
+        @cluster_status
+      end
+
+      def valid_cluster_status?
+        ['init', 'reserved', 'stopped', 'restarting', 'norm', 'failed', 'ptfailed'].include?(cluster_status)
+      end
+
+      def valid_cluster_info_list_status?(status = nil)
+        status = cluster_status if status.nil?
+        ['init', 'reserved', 'stopped', 'starting', 'restarting', 'norm', 'failed', 'ptfailed', 'error'].include?(status)
+      end
+
+      def cluster_norm?
+        'norm' == cluster_status
+      end
+
+      def cluster_norm_or_ptfailed?
+        ['norm', 'ptfailed'].include?(cluster_status)
+      end
+
+      def cluster_restart_status?
+        ['norm', 'failed', 'ptfailed'].include?(cluster_status)
+      end
+
+      def validate_cluster
+        raise Dag::Client::ClusterNotOpen.new("cluster not opened") if @cluster_name.blank?
+        raise Dag::Client::StatusInvalid.new("cluster is not valid status: #{cluster_status}") unless valid_cluster_status?
+      end
+
+      VALID_WHERE_KEYS = [
+        :status,
+        :type,
+        :cluster_name
+      ]
+
+      def validate_cluster_param_keys(params)
+        params.keys.each do |k|
+          unless VALID_WHERE_KEYS.include?(k.to_sym)
+            raise Dag::Client::ParameterInvalid.new("Invalid where condition: #{k}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dag/client/database.rb

@@ -0,0 +1,79 @@
+module Dag
+  class Client
+    module Database
+      include Dag::Client::ClusterValidation
+
+      def databases
+        validate_cluster
+
+        Dag::DatabaseCollection.new(@api, @cluster_name, cluster_status: @cluster_status)
+      end
+
+      def create_database(db_name)
+        validate_cluster
+
+        @api.create_database(@cluster_name, db_name)
+        Dag::Database.new(@api, @cluster_name, db_name)
+      end
+
+      def database(db_name)
+        validate_cluster
+
+        raise Dag::Client::ParameterInvalid.new("db_name is blank")if db_name.blank?
+
+        unless db = databases.detect { |d| d.db_name == db_name }
+          raise Dag::Client::DatabaseNotFound.new('Database not found')
+        end
+
+        db
+      end
+
+      def table(db_name, tbl_name)
+        validate_cluster
+
+        raise Dag::Client::ParameterInvalid.new("db_name is blank")if db_name.blank?
+        raise Dag::Client::ParameterInvalid.new("tbl_name is blank")if tbl_name.blank?
+
+        unless table_info = @api.table(@cluster_name, db_name, tbl_name)
+          raise Dag::Client::TableNotFound.new('Table not found')
+        end
+
+        Dag::Table.new(@api, @cluster_name, db_name, params: table_info)
+      end
+
+      #
+      # == parameters ==
+      # * <tt>table</tt> - table name
+      # * <tt>format</tt> - 'csv' or 'tsv' or 'json' or 'json_agent'
+      # * <tt>schema/tt> - schema
+      # * <tt>comment</tt> - comment
+      def create_table(db_name, tbl_name, format: nil, schema: nil, comment: nil)
+        validate_cluster
+
+        params = {
+          table: tbl_name,
+          schema: schema,
+          create_api: true
+        }
+        params.merge!({ format: format }) if format
+        params.merge!({ comment: comment }) if comment
+
+        @api.create_table(@cluster_name, db_name, params: params)
+        table_info = @api.table(@cluster_name, db_name, tbl_name)
+        Dag::Table.new(@api, @cluster_name, db_name, params: table_info)
+      end
+
+      def split_table(db_name, tbl_name, params)
+        unless cluster_norm?
+          raise Dag::Client::StatusInvalid.new("cluster status is invalid: #{cluster_status}")
+        end
+
+        split_info = @api.split_table(@cluster_name, db_name, tbl_name, params)
+        job_id = split_info['queryId']
+
+        query_info = @api.query_info(job_id)
+        Dag::Job.new(@api, query_info)
+      end
+    end
+  end
+end

data/lib/dag/client/exception.rb

@@ -0,0 +1,43 @@
+module Dag
+  class Client
+    class APIFailure < StandardError
+      attr_accessor :api_code
+      attr_accessor :api_message
+      attr_accessor :api_status
+      attr_accessor :api_request_id
+      attr_accessor :api_resource
+    end
+
+    # API
+    class ParameterInvalid < StandardError
+    end
+
+    class APIOptionInvalid < StandardError
+    end
+
+    class StatusInvalid < StandardError
+    end
+
+    # Job
+    class JobTypeInvalid < StandardError
+    end
+
+    # Cluster
+    class ClusterNotOpen < StandardError
+    end
+
+    class ClusterRebooted < StandardError
+    end
+
+    # Database
+    class DatabaseNotFound < StandardError
+    end
+
+    # Table
+    class TableAlreadyExists < StandardError
+    end
+
+    class TableNotFound < StandardError
+    end
+  end
+end

data/lib/dag/client/job.rb

@@ -0,0 +1,56 @@
+require 'active_support/core_ext/integer/time'
+
+module Dag
+  class Client
+    module Job
+
+      def jobs
+        Dag::JobCollection.new(@api)
+      end
+
+      def job(job_id)
+        job_info = @api.query_info(job_id)
+        Dag::Job.new(@api, job_info)
+      end
+
+      def job_log(job_id)
+
+        job = job(job_id)
+        job.validate_log_condition
+        log_info = @api.query_log(job_id)
+        log_info ? log_info['log'] : ''
+      end
+
+      def job_cancel(job_id)
+
+        job = job(job_id)
+        job.validate_cancel_condition
+        @api.query_cancel(job_id)
+      end
+
+      #
+      # == parameters ==
+      # * <tt>query</tt> - query
+      # * <tt>output_format</tt> - 'csv' or 'tsv'
+      # * <tt>output_resource_path</tt> - "${bucketname}/${output_object}"
+      # * <tt>label</tt> - label
+      def query(query: '', output_format: 'csv', output_resource_path: '', label: '')
+        validate_cluster
+
+        select_info = @api.query(query: query,
+                                 output_format: output_format,
+                                 output_resource_path: output_resource_path,
+                                 cluster_name: @cluster_name,
+                                 label: label)
+        job_id = select_info['queryId']
+
+        job(job_id)
+      end
+
+      def job_download_urls(job_id)
+        job = job(job_id)
+        job.download_urls
+      end
+    end
+  end
+end

data/lib/dag/client/job_validation.rb

@@ -0,0 +1,22 @@
+module Dag
+  class Client
+    module JobValidation
+
+      VALID_WHERE_KEYS = [
+        :status,
+        :type,
+        :cluster_name,
+        :label,
+        :cluster_rebooted
+      ]
+
+      def validate_job_param_keys(params)
+        params.keys.each do |k|
+          unless VALID_WHERE_KEYS.include?(k.to_sym)
+            raise Dag::Client::ParameterInvalid.new("Invalid where condition: #{k}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dag/client/model.rb

@@ -0,0 +1,9 @@
+module Dag
+  class Model
+    def initialize(api)
+      @api = api
+    end
+
+    attr_reader :api
+  end
+end

data/lib/dag/client/model/bucket.rb

@@ -0,0 +1,20 @@
+module Dag
+  class Bucket < Model
+    def initialize(api, bucket_name)
+      super(api)
+      @name = bucket_name
+    end
+
+    def name
+      @name
+    end
+
+    def delete
+      @api.delete_bucket(@name)
+    end
+
+    def objects(prefix: nil)
+      Dag::ObjectCollection.new(@api, @name)
+    end
+  end
+end

data/lib/dag/client/model/bucket_collection.rb

@@ -0,0 +1,34 @@
+module Dag
+  class BucketCollection < Model
+    include Enumerable
+
+    def create(bucket_name)
+      @api.create_bucket(bucket_name)
+      bucket_named(bucket_name)
+    end
+
+    # @example
+    #
+    #   bucket = client.buckets[:mybucket],
+    #   bucket = client.buckets['mybucket'],
+    #
+    # @param [String] bucket_name
+    # @return [Bucket]
+    def [] bucket_name
+      bucket_named(bucket_name)
+    end
+
+    def each
+      buckets = @api.buckets.buckets
+      buckets.each do |bucket|
+        yield bucket_named(bucket)
+      end
+    end
+
+    private
+
+    def bucket_named(bucket)
+      Dag::Bucket.new(@api, bucket.to_s)
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'active_support/core_ext/string/inflections'
+require 'ostruct'
+
+module Dag
+  class Cluster < Model
+    include Dag::Client::ClusterValidation
+
+    def initialize(api, cluster)
+      super(api)
+
+      @name = cluster['name']
+      @status = cluster['status']
+      @cluster_status = @status
+      @type = cluster['type']
+      @instances = cluster['instances']
+      @debug = cluster['debug']
+    end
+
+    attr_reader :name, :status, :type, :debug
+
+    # restart cluster
+    #
+    # ==== Parameters
+    # * <tt>:force</tt> - restart forcely. false by default
+    # * <tt>:type</tt> - cluster type 'DAG5-Hive-Hadoop'
+    def restart(force: false, type: nil)
+      unless cluster_restart_status?
+        raise Dag::Client::StatusInvalid.new("cluster status is invalid: #{cluster_status}")
+      end
+
+      params = {
+        force: force,
+        type: type || @type,
+        debug: false
+      }
+
+      @api.cluster_restart(@name, params)
+    end
+
+    def export_log(params = {})
+      unless cluster_norm_or_ptfailed?
+        raise Dag::Client::StatusInvalid.new("cluster status is invalid: #{cluster_status}")
+      end
+
+      default = {
+        compress: false
+      }
+
+      @api.cluster_export_log(@name, default.merge(params))
+    end
+
+    # return instance infomation
+    #
+    # == instance detail
+    # * <tt>grade</tt>
+    # * <tt>quantity</tt>
+    def instances
+      @instances.map { |instance| os = OpenStruct.new(instance); os.freeze; os }
+    end
+
+    # return statistics information
+    #
+    # == instance detail ==
+    # * <tt>instances</tt>
+    #   * <tt>instance_id</tt>
+    #   * <tt>grade</tt>
+    #   * <tt>disk</tt>
+    #     * <tt>dfs_used</tt>
+    #     * <tt>non_dfs_used</tt>
+    #     * <tt>capacity</tt>
+    # * <tt>disk</tt>
+    #   * <tt>capacity</tt>
+    #   * <tt>used</tt>
+    def statistics
+      statistics_info = if valid_cluster_status? && cluster_norm_or_ptfailed?
+                          @api.statistics(@name)
+                        end
+
+      if statistics_info.present?
+        statistics_info = {
+            "instances" => statistics_info['instances'],
+            "disk" => statistics_info['disk']
+        }
+      end
+
+      return nil unless statistics_info
+      key_to_underscore(statistics_info)
+    end
+
+    private
+
+    def key_to_underscore(hash)
+      OpenStruct.new(hash.each_with_object({}) {|(k, v), new_hash|
+        v = v.map {|s| send(__method__, s) } if v.class == Array
+        v = send(__method__, v) if v.class == Hash
+        new_hash[k.underscore] = v
+      }).freeze
+    end
+  end
+end