dtk-client 0.9.1 → 0.10.0

data/lib/domain/response.rb

@@ -1,285 +0,0 @@
-#
-# Copyright (C) 2010-2016 dtk contributors
-#
-# This file is part of the dtk project.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# This is wrapper for holding rest response information as well as
-# passing selection of ViewProcessor from Thor selection to render view
-# selection
-require 'git'
-
-module DTK
-  module Client
-    #TODO: should make higher level class be above whether it is 'rest'
-    class Response < Common::Response
-      require File.expand_path('response/error_handler',File.dirname(__FILE__))
-      include ErrorHandlerMixin
-
-      # :render_view        => symbol specifing type of data to be rendered e.g. :assembly
-      # :skip_render        => flag that specifies that render is not needed (default: false)
-      # :print_error_table  => we use it if we want to print 'error legend' for given tables (default: false)
-      attr_accessor :render_view, :skip_render, :print_error_table
-
-      # Amar: had to add this in order to get json meta for PP that's not for domain class
-      def override_command_class(json_top_type)
-        @command_class = json_top_type
-      end
-
-      def initialize(command_class=nil,hash={})
-        super(hash)
-        @command_class     = command_class
-        @skip_render       = false
-        @print_error_table = false
-        # default values
-        @render_view = RenderView::AUG_SIMPLE_LIST
-        @render_data_type = nil
-      end
-
-      def clone_me()
-        return Marshal.load(Marshal.dump(self))
-      end
-
-      def self.wrap_helper_actions(data={},&block)
-        begin
-          results = (block ? yield : data)
-          Ok.new(results)
-
-        rescue Git::GitExecuteError => e
-          if e.message.include?('Please make sure you have the correct access rights')
-            error_msg  = "You do not have git access from this client, please add following SSH key in your git account: \n\n"
-            error_msg += SSHUtil.rsa_pub_key_content() + "\n"
-            raise DTK::Client::DtkError, error_msg
-          end
-          handle_error_in_wrapper(e)
-        rescue ErrorUsage => e
-          Error::Usage.new("message"=> e.to_s)
-        rescue => e
-          handle_error_in_wrapper(e)
-        end
-      end
-
-      def self.handle_error_in_wrapper(exception)
-        error_hash =  {
-          "message"=> exception.message,
-          "backtrace" => exception.backtrace,
-          "on_client" => true
-          }
-
-        if DTK::Configuration.get(:development_mode)
-          DtkLogger.instance.error_pp("Error inside wrapper DEV ONLY: #{exception.message}", exception.backtrace)
-        end
-
-        Error::Internal.new(error_hash)
-      end
-
-      def get_label_for_column_name(column, type)
-        if type.eql?('node')
-          mappings = {
-            column => column
-          }
-        else
-          mappings = {
-            "#{type}_id:" => "ID:",
-            "#{type}_name:" => "NAME:",
-            "node_type:" => "TYPE:",
-            "instance_id:" => "INSTANCE ID:",
-            "size:" => "SIZE:",
-            "os_type:" => "OS:",
-            "op_status:" => "OP STATUS:",
-            "dns_name:" => "DNS NAME:",
-            "target:" => "TARGET:"
-          }
-        end
-
-        mappings[column]
-      end
-
-      # used just for printing workspace node info
-      def render_workspace_node_info(type)
-        info_list = ""
-        if type.eql?("component")
-          info_list = ["component_name","component_id","basic_type","description"]
-        else
-          info_list = ["type", "node_id", "node_name","os_type", "instance_id", "admin_op_status", "size", "target", "dns_name", "image_id", "ec2_public_address", "privete_dns_name", "keypair", "security_groups", "security_group", "security_group_set"]
-        end
-
-        columns = []
-        puts "--- \n"
-        if data.kind_of?(String)
-          data.each_line do |l|
-            print = "#{l.gsub(/\s+\-*\s+/,'')}"
-            print.gsub!(/-\s+/,"")
-            info_list.each do |i|
-              if match = print.to_s.match(/^(#{i}:)(.+)/)
-                label = get_label_for_column_name(match[1], type)
-                columns << " #{label}#{match[2]}\n"
-              end
-            end
-          end
-        end
-
-        if type.eql?('node')
-          # move target from first place
-          columns.rotate!
-        else
-          columns.sort!()
-        end
-
-        columns.each do |column|
-          STDOUT << column
-        end
-        puts "\n"
-      end
-
-      def render_custom_info(type)
-        puts "--- \n"
-
-        unless data.empty?
-          data.each do |k,v|
-            label = get_custom_labels(k, type)
-            v = array_to_string(v) if v.is_a?(Array)
-            STDOUT << " #{label} #{v}\n" if label
-          end
-        end
-
-        puts "\n"
-      end
-
-      def get_custom_labels(label, type)
-        mappings = {}
-
-        mappings["module"] = {
-          "id" => "ID:",
-          "display_name" => "NAME:",
-          "versions" => "VERSION(S):",
-          "remote_repos" => "LINKED REMOTE(S):",
-          "dsl_parsed" => "DSL PARSED:"
-        }
-
-        mappings[type][label] if mappings[type]
-      end
-
-      def array_to_string(array_data)
-        info = ""
-        array_data.each do |a|
-          info << "#{a.values.first},"
-        end
-
-        "#{info.gsub!(/,$/,'')}"
-      end
-
-
-      def render_data(print_error_table=false)
-        unless @skip_render
-          if ok?()
-
-            @print_error_table ||= print_error_table
-
-            # if response is empty, response status is ok but no data is passed back
-            if data.empty? or (data.is_a?(Array) ? data.first.nil? : data.nil?)
-              @render_view = RenderView::SIMPLE_LIST
-              if data.kind_of?(Array)
-                set_data('Message' => "List is empty.")
-              else #data.kind_of?(Hash)
-                set_data('Status' => 'OK')
-              end
-            end
-
-            # sending raw data from response
-            rendered_data = ViewProcessor.render(@command_class, data, @render_view, @render_data_type, nil, @print_error_table)
-
-            puts "\n" unless rendered_data
-            return rendered_data
-          else
-            hash_part()
-          end
-        end
-      end
-
-      def render_arg_list!
-        @render_view = RenderView::AUG_SIMPLE_LIST
-      end
-
-      def set_datatype(data_type)
-        @render_data_type = symbol_to_data_type_upcase(data_type)
-        self
-      end
-
-      def render_table(default_data_type=nil, use_default=false)
-        unless ok?
-          return self
-        end
-        unless data_type = (use_default ? default_data_type : (response_datatype() || default_data_type))
-          raise DTK::Client::DtkError, "Server did not return datatype."
-        end
-
-        @render_data_type = symbol_to_data_type_upcase(data_type)
-        @render_view = RenderView::TABLE
-        self
-      end
-
-      def response_datatype()
-        self["datatype"] && self["datatype"].to_sym
-      end
-
-      def hash_part()
-        keys.inject(Hash.new){|h,k|h.merge(k => self[k])}
-      end
-
-      def symbol_to_data_type_upcase(data_type)
-        return data_type.nil? ? nil : data_type.to_s.upcase
-      end
-
-      private :hash_part
-
-      class Ok < self
-        def initialize(data={})
-          super(nil,{"data"=> data, "status" => "ok"})
-        end
-      end
-
-      class NotOk < self
-        def initialize(data={})
-          super(nil,{"data"=> data, "status" => "notok"})
-        end
-      end
-
-      class Error < self
-        include Common::Response::ErrorMixin
-        def initialize(hash={})
-          super(nil,{"errors" => [hash]})
-        end
-
-        class Usage < self
-          def initialize(hash_or_string={})
-            hash = (hash_or_string.kind_of?(String) ? {'message' => hash_or_string} : hash_or_string)
-            super({"code" => "error"}.merge(hash))
-          end
-        end
-
-        class Internal < self
-          def initialize(hash={})
-            super({"code" => "error"}.merge(hash).merge("internal" => true))
-          end
-        end
-      end
-
-      class NoOp < self
-        def render_data
-        end
-      end
-    end
-  end
-end

data/lib/dtk-client/version.rb

@@ -1,20 +0,0 @@
-#
-# Copyright (C) 2010-2016 dtk contributors
-#
-# This file is part of the dtk project.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-module DtkClient
-  VERSION="0.9.1"
-end

data/lib/dtk_constants.rb

@@ -1,40 +0,0 @@
-#
-# Copyright (C) 2010-2016 dtk contributors
-#
-# This file is part of the dtk project.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-require 'singleton'
-dtk_require("config/disk_cacher")
-
-class PPColumns
-
-  include Singleton
-
-  def initialize
-    # content = DiskCacher.new.fetch("http://localhost/mockup/get_const_metadata", ::DTK::Configuration.get(:meta_constants_ttl))
-    content = DiskCacher.new.fetch("const_metadata", ::DTK::Configuration.get(:meta_constants_ttl))
-    raise DTK::Client::DtkError, "Require constants metadata is empty, please contact DTK team." if content.empty?
-    @constants = JSON.parse(content)
-  end
-
-  def self.get(symbol_identifier)
-    return PPColumns.instance.get(symbol_identifier)
-  end
-
-  def get(symbol_identifier)
-    return @constants[symbol_identifier.to_s]
-  end
-
-end

data/lib/dtk_error.rb

@@ -1,114 +0,0 @@
-#
-# Copyright (C) 2010-2016 dtk contributors
-#
-# This file is part of the dtk project.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-module DTK
-  module Client
-    class DtkError < Error
-      def initialize(msg,opts={})
-        super(msg)
-        @backtrace = opts[:backtrace]
-      end
-      attr_reader :backtrace
-
-      def self.raise_error(response)
-        raise_if_error?(response,:default_error_if_nil => true)
-      end
-      def self.raise_if_error?(response,opts={})
-        # check for errors in response
-        unless error = response.error_info?(opts)
-          return
-        end
-        
-        # if error_internal.first == true
-        case error.code
-          when :unauthorized
-            raise self, "[UNAUTHORIZED] Your session has been suspended, please log in again."
-          when :session_timeout
-            raise self, "[SESSION TIMEOUT] Your session has been suspended, please log in again."
-          when :broken
-            raise self, "[BROKEN] Unable to connect to the DTK server at host: #{Config[:server_host]}"
-          when :forbidden
-            raise DTK::Client::DtkLoginRequiredError, "[FORBIDDEN] Access not granted, please log in again."
-          when :timeout
-            raise self, "[TIMEOUT ERROR] Server is taking too long to respond."
-          when :connection_refused
-            raise self, "[CONNECTION REFUSED] Connection refused by server."
-          when :resource_not_found
-            raise self, "[RESOURCE NOT FOUND] #{error.msg}"
-          when :pg_error
-            raise self, "[PG_ERROR] #{error.msg}"
-          when :server_error
-            raise Server.new(error.msg,:backtrace => error.backtrace)
-          when :client_error
-            raise Client.new(error.msg,:backtrace => error.backtrace)
-          else
-          # if usage error occurred, display message to console and display that same message to log
-            raise Usage.new(error.msg)
-        end
-      end
-
-
-      class Usage < self
-        def initialize(error_msg,opts={})
-          msg_to_pass_to_super = "[ERROR] #{error_msg}"
-          super(msg_to_pass_to_super,opts)
-        end
-      end
-
-      class InternalError < self
-        def initialize(error_msg,opts={})
-          msg_to_pass_to_super = "[#{label(opts[:where])}] #{error_msg}"
-          super(msg_to_pass_to_super,opts)
-        end
-        def self.label(where=nil)
-          prefix = (where ? "#{where.to_s.upcase} " : '')
-          "#{prefix}#{InternalErrorLabel}"
-        end
-        InternalErrorLabel = 'INTERNAL ERROR'
-
-       private
-        def label(where=nil)
-          self.class.label(where)
-        end
-      end
-
-      class Client < InternalError
-        def initialize(error_msg,opts={})
-          super(error_msg,opts.merge(:where => :client))
-        end
-        def self.label(*args)
-          super(:client)
-        end
-      end
-
-      class Server < InternalError
-        def initialize(error_msg,opts={})
-          super(error_msg,opts.merge(:where => :server))
-        end
-        def self.label(*args)
-          super(:server)
-        end
-      end
-
-      class InteractiveWizardError < self
-        def initialize(error_msg, opts={})
-          super(error_msg, opts)
-        end
-      end
-    end
-  end
-end

data/lib/dtk_logger.rb

@@ -1,113 +0,0 @@
-#
-# Copyright (C) 2010-2016 dtk contributors
-#
-# This file is part of the dtk project.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-##
-# DtkLogger singleton to be used for logging.
-#
-require 'singleton'
-require 'logger'
-require 'colorize'
-require 'pp'
-
-require File.expand_path('./util/os_util', File.dirname(__FILE__))
-
-class DtkLogger
-
-  #
-  LOG_FILE_NAME           = 'client.log'
-  LOG_MB_SIZE             = 2
-  LOG_NUMBER_OF_OLD_FILES = 10
-  DEVELOPMENT_MODE        = DTK::Configuration.get(:development_mode)
-
-  include Singleton
-
-  def initialize
-    log_location_dir = DTK::Client::OsUtil.get_log_location()
-    begin
-      if File.directory?(log_location_dir)
-        file = File.open(file_path(), "a")
-        file.sync = true
-        @logger = Logger.new(file, LOG_NUMBER_OF_OLD_FILES, LOG_MB_SIZE * 1024000)
-
-        @logger.formatter = proc do |severity, datetime, progname, msg|
-          "[#{datetime}] #{severity} -- : #{msg}\n"
-        end
-      else
-        no_log_dir(log_location_dir)
-      end
-     rescue Errno::EACCES
-      no_log_permissions(log_location_dir)
-    end
-  end
-
-  def file_path()
-    "#{DTK::Client::OsUtil.get_log_location()}/#{LOG_FILE_NAME}"
-  end
-
-  def debug(log_text, sttdout_out=false)
-    puts log_text if sttdout_out || DEVELOPMENT_MODE
-    @logger.debug(log_text) if log_created?
-  end
-
-  def info(log_text, sttdout_out=false)
-    puts log_text if sttdout_out || DEVELOPMENT_MODE
-    @logger.info(log_text) if log_created?
-  end
-
-  def warn(log_text, sttdout_out=false)
-    DTK::Client::OsUtil.print(log_text, :yellow) if sttdout_out || DEVELOPMENT_MODE
-    @logger.warn(log_text) if log_created?
-  end
-
-  def error(log_text, sttdout_out=false)
-    DTK::Client::OsUtil.print(log_text, :red) if sttdout_out || DEVELOPMENT_MODE
-    @logger.error(log_text) if log_created?
-  end
-
-  def error_pp(message, backtrace, sttdout_out = true)
-    error(message, sttdout_out)
-    # we do not print this to STDOUT (will be overriden with DEVELOPMENT_MODE)s
-    error("#{message}\n" + PP.pp(backtrace, ""), false) if backtrace
-  end
-
-  def fatal_pp(message, backtrace, sttdout_out = true)
-    fatal(message, sttdout_out)
-    # we do not print this to STDOUT (will be overriden with DEVELOPMENT_MODE)
-    fatal("#{message}\n" + PP.pp(backtrace, ""), false) if backtrace
-  end
-
-
-  def fatal(log_text, sttdout_out=false)
-    puts log_text if sttdout_out || DEVELOPMENT_MODE
-    @logger.fatal(log_text) if log_created?
-  end
-
-  private
-
-  def log_created?
-    #no log found if @logger.nil?
-    return !@logger.nil?
-  end
-
-  def no_log_dir(dir)
-    puts "[WARNING] Log directory (#{dir}) does not exist; please add it manually or re-install DTK client."
-  end
-
-  def no_log_permissions(dir)
-    puts "[WARNING] User (#{DTK::Common::Aux.running_process_user()}) does not have permissions to create a log file in log directory (#{dir})"
-  end
-end

data/lib/error.rb

@@ -1,85 +0,0 @@
-#
-# Copyright (C) 2010-2016 dtk contributors
-#
-# This file is part of the dtk project.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-##
-# Application expected errors will be handled trough DtkError. All else will be treaded 
-# as Internal Server error. Logs will be added to ~/dtk.log for developers to investigate
-# issues more closely.
-
-module DTK
-  module Client
-    class Error < NameError
-    end
-
-   # DtkError is child of Error; so order matters
-    require File.expand_path('dtk_error', File.dirname(__FILE__))
-
-    class DSLParsing < Error
-      def initialize(base_json_error,file_path=nil)
-        super(err_msg(base_json_error,file_path))
-      end
-      private
-      def err_msg(base_json_error,file_path=nil)
-        "#{base_json_error}: #{file_path}"
-      end
-
-      class JSONParsing < self
-      end
-
-      class YAMLParsing < self
-      end
-    end
-
-    # class DtkValidationError < Error
-
-    #   attr_accessor :skip_usage_info
-
-    #   def initialize(msg, skip_usage_info = false)
-    #     @skip_usage_info = skip_usage_info
-    #     super(msg)
-    #   end
-    # end
-
-    class DtkValidationError < Error
-
-      attr_accessor :display_usage_info
-
-      def initialize(msg, display_usage_info = false)
-        @display_usage_info = display_usage_info
-        super(msg)
-      end
-    end
-
-    # raise by developers to signal wrong usage of components
-    class DtkImplementationError < Error
-    end
-
-    class DtkLoginRequiredError < Error
-    end
-
-  end
-end
-
-module DTK
-  module Shell
-    class Error < DTK::Client::Error
-    end
-
-    class ExitSignal < DTK::Client::Error
-    end
-  end
-end