idcfcloud 0.1.4 → 0.2.0

data/lib/idcf/cli/extend/update.rb

@@ -3,6 +3,7 @@ require 'active_support/core_ext'
 require 'idcf/cli/conf/const'
 require 'idcf/cli/lib/util/template'
 require_relative 'update_file'
+require 'idcf/cli/lib/util/input'
 module Idcf
   module Cli
     module Extend
@@ -15,83 +16,150 @@ module Idcf
         COMP_N = 'complement'.freeze
 
         def do_update(_o)
-          clients = make_clients
-          writable_setting_file clients.keys
-          infos = {}
-
-          clients.each do |s_name, client|
-            info = make_module_info(client)
-            output_yaml(s_name, info)
-            infos[s_name] = info
-          end
+          s_schemas = schema_data_acquisition
+          output_schema(s_schemas)
           output_complement
         end
 
-        def make_clients
-          {}.tap do |result|
-            self.class.subcommand_classes.each do |k, v|
-              next unless v.ancestors.include?(Idcf::Cli::Controller::Base)
-              client    = v.make_blank_client
-              result[k] = client unless client.nil?
+        def output_schema(s_schemas)
+          s_schemas.each do |service, infos|
+            infos.each do |version, regions|
+              next if regions.nil? || regions.empty?
+              regions.each do |region, schema|
+                path = make_schema_file_path(service, version, region)
+                output_complement_file(JSON.pretty_generate(schema), path)
+              end
+              output_default_schema(service, version, regions)
             end
           end
         end
 
-        def make_module_info(client)
-          {}.tap do |result|
-            module_methods = []
-            client.class.included_modules.each do |m|
-              next unless m.to_s =~ /\AIdcf::.*::ClientExtensions/
-              module_methods.concat(module_instance_methods(m))
-            end
-            module_methods.each do |method|
-              result[method] = make_method_info(client, method)
-            end
+        def output_default_schema(service, version, regions)
+          return nil if regions.keys.include?('default')
+          latist = latest_schema(regions.values)
+          path   = make_schema_file_path(service, version, 'default')
+          output_complement_file(JSON.pretty_generate(latist), path)
+        end
+
+        # get latest schema
+        #
+        # @param schemas [Array]
+        # @return Hash or nil
+        def latest_schema(schemas)
+          result = nil
+          v_str  = '$version'
+          schemas.each do |data|
+            result ||= data
+            v1     = Gem::Version.create(data[v_str])
+            v2     = Gem::Version.create(result[v_str])
+            next unless v1 > v2
+            result = data
+          end
+          result
+        end
+
+        def output_complement
+          view = Idcf::Cli::Lib::Util::Template.new
+          view.set('variables', make_script_variables)
+          paths = {}
+          Idcf::Cli::Conf::Const::COMP_PATHS.each do |k, _v|
+            str      = view.fetch("#{k}/#{COMP_N}.erb")
+            path     = "#{Idcf::Cli::Conf::Const::OUT_DIR}/#{COMP_N}.#{k}"
+            paths[k] = File.expand_path(path)
+            output_complement_file(str, paths[k])
+          end
+
+          output_notification(paths)
+        end
+
+        # output notification
+        #
+        # @param paths [Hash]
+        def output_notification(paths)
+          script = ENV['SHELL'].split('/').pop.to_sym
+          return output_manual_writing(paths) if paths[script].nil?
+          startup_script_qa(paths, script)
+        end
+
+        def startup_script_qa(paths, script)
+          list = %w(y N)
+          puts "Do you want to edit the startup script?(#{list.join('/')})"
+          puts "[#{startup_script_path(script)}]"
+          ans = Idcf::Cli::Lib::Util::Input.qa_answer_input(list)
+          if ans == 'y'
+            output_startup_script(script, paths)
+          else
+            output_manual_writing(paths)
           end
         end
 
-        def module_instance_methods(mc)
-          [].tap do |result|
-            base_name = mc.to_s.underscore.split('/').pop
-            mc.instance_methods.each do |method|
-              result << method unless Regexp.new("\\A#{base_name}s?\\Z") =~ method.to_s
+        # startup script path
+        #
+        # @param script [String]
+        # @return String
+        def startup_script_path(script)
+          File.expand_path(Idcf::Cli::Conf::Const::COMP_PATHS[script])
+        end
+
+        # output start script
+        #
+        # @param paths [Hash]
+        def output_startup_script(script, paths)
+          s_script_path = startup_script_path(script)
+          write_str     = "source #{paths[script]}"
+
+          if write_path?(s_script_path, write_str)
+            File.open(s_script_path, 'a') do |f|
+              f.puts write_str, ''
             end
           end
+
+          puts 'Run the following command:', write_str
         end
 
-        def make_method_info(client, method_sym)
-          params = []
-          client.method(method_sym).parameters.each do |param|
-            next if param[0] == :block
-            params << {
-              name:     param[1].to_s,
-              arg_type: param[0].to_s
-            }
+        # write path?
+        #
+        # @param path [String] setting path
+        # @param check_str
+        # @return Boolean
+        # @raise
+        def write_path?(path, check_str)
+          if File.exist?(path)
+            Idcf::Cli::Lib::Util::CliFile.writable(path)
+            return !write_line_str_exist?(path, check_str)
           end
 
-          { desc: '', params: params }
+          Idcf::Cli::Lib::Util::CliFile.writable(File.expand_path('..', path))
+          true
         end
 
-        def output_complement
-          view = Idcf::Cli::Lib::Util::Template.new
-          view.set('variables', make_script_variables)
-          paths = []
-          %w(bash zsh).each do |e|
-            str  = view.fetch("#{e}/#{COMP_N}.erb")
-            path = "#{Idcf::Cli::Conf::Const::OUT_DIR}/#{COMP_N}.#{e}"
-            paths << File.expand_path(path)
-            output_complement_file(str, paths.last)
+        # write line str exist?
+        #
+        # @param path [String] setting path
+        # @param check_str
+        # @return Boolean
+        # @raise
+        def write_line_str_exist?(path, check_str)
+          File.open(path, 'r') do |f|
+            f.each_line do |line|
+              return true if line.strip == check_str
+            end
           end
-          output_notification(paths)
+          false
         end
 
-        def output_notification(paths)
-          notification = Idcf::Cli::Conf::Const::COMP_NOTIFICATION
-          puts format(notification, *paths)
+        # manual write
+        #
+        # @param paths [Hash]
+        def output_manual_writing(paths)
+          puts 'please write in'
+          Idcf::Cli::Conf::Const::COMP_PATHS.each do |k, v|
+            puts v, paths[k]
+          end
         end
 
         def make_script_variables
-          self.class.init
+          self.class.init({})
           make_flat_variables(self.class.subcommand_structure)
         end
 
@@ -102,7 +170,7 @@ module Idcf
         # @return Hash
         def make_flat_variables(list, names = [])
           {}.tap do |result|
-            name = names.empty? ? 'top' : names.join('_')
+            name         = names.empty? ? 'top' : names.join('_')
             result[name] = list.keys
             list.each do |k, v|
               next unless v.class == Hash
@@ -112,6 +180,23 @@ module Idcf
             end
           end
         end
+
+        def extract_commands(thor_class, commands)
+          thor_class.commands.keys.each do |k_c|
+            commands << k_c if commands.index(k_c).nil?
+          end
+
+          commands.sort
+        end
+
+        def extract_command_infos(t_class, s_name, infos)
+          commands = []
+          return extract_commands(t_class, commands) if infos[s_name].nil?
+          infos[s_name].keys.each do |name|
+            commands << name.to_s
+          end
+          extract_commands(t_class, commands)
+        end
       end
     end
   end

data/lib/idcf/cli/extend/update_file.rb

@@ -1,24 +1,126 @@
 require 'fileutils'
 require 'idcf/cli/conf/const'
+require 'open_uri_redirections'
 
 module Idcf
   module Cli
     module Extend
       # update file
       module UpdateFile
+        BROKEN_UPDATE_FILE = 'The update file is damaged. '\
+                             'Please consult with the administrator.'.freeze
+
         protected
 
-        def writable_setting_file(services)
-          b_dir = File.expand_path(Idcf::Cli::Conf::Const::CMD_FILE_DIR)
-          FileUtils.mkdir_p(b_dir) unless Dir.exist?(b_dir)
-          writable?(File.dirname(b_dir))
+        def schema_data_acquisition
+          {}.tap do |result|
+            self.class.subcommand_classes.each do |s_name, cls|
+              result[s_name] = service_schema_data_acquisition(cls)
+            end
+          end
+        end
 
-          services.each do |v|
-            path = "#{b_dir}/#{v}.#{Idcf::Cli::Conf::Const::CMD_FILE_EXT}"
-            writable?(File.dirname(path)) if File.exist?(path)
+        def service_schema_data_acquisition(cls)
+          {}.tap do |result|
+            schema_file_paths(cls).each do |version, infos|
+              result[version] = {}
+              infos.each do |region, path|
+                j = download_schema_file(path)
+                update_data_check(j)
+                result[version][region] = j
+              end
+            end
           end
         end
 
+        def download_schema_file(path)
+          d = file_load(path)
+          JSON.parse(d)
+        rescue
+          Idcf::Cli::Lib::Util::CliLogger.info("json format error:#{path}")
+          raise Idcf::Cli::Error::CliError, BROKEN_UPDATE_FILE
+        end
+
+        def update_data_check(j)
+          check_json_schema(j)
+          check_api_version_format(j['$version'])
+        end
+
+        def check_json_schema(j)
+          analyst = Idcf::JsonHyperSchema::Analyst.new
+          analyst.schema_links(j)
+        rescue => e
+          Idcf::Cli::Lib::Util::CliLogger.info('json-schema format error')
+          log_msg = "#{BROKEN_UPDATE_FILE}:#{e.message}"
+          Idcf::Cli::Lib::Util::CliLogger.error(log_msg)
+          raise Idcf::Cli::Error::CliError, BROKEN_UPDATE_FILE
+        end
+
+        def file_load(path)
+          open(path).read
+        rescue
+          nil
+        end
+
+        def schema_file_paths(cls)
+          {}.tap do |result|
+            Idcf::Cli::Lib::Configure.get_code_conf(cls.service_name).each do |k, v|
+              regions = {}
+              v['region'].each do |region, info|
+                regions[region] = create_schema_url(info['schema'])
+              end
+
+              result[k] = regions
+            end
+          end
+        end
+
+        def create_schema_url(path)
+          href_regexp = Idcf::Cli::Conf::Const::FULL_HREF_REGEXP
+          return path if path =~ href_regexp
+          path = File.expand_path("../#{path}", Idcf::Cli::Conf::Const::BASE_PATH)
+          return path if File.exist?(path)
+          File.expand_path(path)
+        end
+
+        # check api version format
+        #
+        # @param v_str [String] version string
+        # @return Boolean
+        # @raise
+        def check_api_version_format(v_str)
+          msg = 'Please inform an administrator.'
+          raise Idcf::Cli::Error::CliError, msg unless v_str =~ /\A\d+\.\d+\.\d+\Z/
+          true
+        end
+
+        # make schema file path
+        #
+        # @param service [String]
+        # @param version [String]
+        # @param region [String]
+        # @return String
+        # @raise At a writing in right error
+        def make_schema_file_path(service, version, region)
+          b_dir    = schema_file_output_base_path
+          ext      = Idcf::Cli::Conf::Const::CMD_FILE_EXT
+          path     = "#{b_dir}/#{service}_#{version}_#{region}.#{ext}"
+          cli_file = Idcf::Cli::Lib::Util::CliFile
+          if File.exist?(path)
+            cli_file.writable(path)
+          else
+            cli_file.writable(File.dirname(path))
+          end
+          path
+        end
+
+        def schema_file_output_base_path
+          result = File.expand_path(Idcf::Cli::Conf::Const::CMD_FILE_DIR)
+          FileUtils.mkdir_p(result) unless Dir.exist?(result)
+          Idcf::Cli::Lib::Util::CliFile.writable(File.dirname(result))
+          result
+        end
+
         def output_yaml(s_name, data)
           dir  = Idcf::Cli::Conf::Const::CMD_FILE_DIR
           ext  = Idcf::Cli::Conf::Const::CMD_FILE_EXT
@@ -28,25 +130,18 @@ module Idcf
 
         def output_complement_file(str, outpath)
           dir_path = File.dirname(outpath)
-          unless Dir.exist?(dir_path)
-            writable?(File.dirname(dir_path))
-            Dir.mkdir(dir_path)
-          end
-          writable?(dir_path)
+          cli_file = Idcf::Cli::Lib::Util::CliFile
+          cli_file.mkdir(dir_path)
+          cli_file.writable(dir_path)
 
           write_file(outpath, str)
         end
 
         def write_file(path, str)
-          File.open(path, 'w') do |f|
+          File.open(path, 'w', 0o755) do |f|
             f.puts(str)
           end
         end
-
-        def writable?(path)
-          msg = "Permission error (#{path})"
-          raise Idcf::Cli::CliError, msg unless File.writable?(path)
-        end
       end
     end
   end

data/lib/idcf/cli/gem_ext/thor/init_util.rb

@@ -1,3 +1,6 @@
+require 'idcf/cli/lib/util/cli_logger'
+require 'idcf/cli/lib/util/name'
+
 # Thor extention
 class Thor
   class << self
@@ -15,21 +18,22 @@ class Thor
     #
     # @return String
     def description
-      raise Idcf::Cli::CliError, 'Required Override'
+      raise Idcf::Cli::Error::CliError, 'Required Override'
     end
 
     # register sub command
     #
     # @param dir [String] underlayer path
     # @param parent_dir_path [Stirng]
+    # @param arg [Hash] options
     # @return nil
-    def sub_command_regist(under_path, parent_dir_path = '')
-      b_path = module_path
+    def sub_command_regist(under_path, parent_dir_path = '', arg = {})
+      b_path = Idcf::Cli::Lib::Util::Name.namespace(name).underscore
       Dir.glob(parent_dir_path + "/#{under_path}/*.rb").each do |f|
         file_name = File.basename(f, '.*')
         next if file_name == 'base'
 
-        command_regist file_name, "#{b_path}/#{under_path}/#{file_name}"
+        command_regist file_name, "#{b_path}/#{under_path}/#{file_name}", arg
       end
     end
 
@@ -37,11 +41,12 @@ class Thor
     #
     # @param command [String]
     # @param require_path [String]
-    def command_regist(command, require_path)
+    # @param o [Hash] options
+    def command_regist(command, require_path, arg)
       require require_path
 
       class_const = require_path.classify.constantize
-      class_const.init
+      class_const.init(arg)
       register class_const,
                command,
                "#{command_help_string(command)} [OPTION]",
@@ -78,11 +83,19 @@ class Thor
       end
     end
 
+    def error_exit(e)
+      STDERR.puts e.message
+      Idcf::Cli::Lib::Util::CliLogger.error(e.message)
+      Idcf::Cli::Lib::Util::CliLogger.cleaning(options)
+      STDERR.puts "log path: #{Idcf::Cli::Lib::Util::CliLogger.current_path}"
+      exit 1
+    end
+
     protected
 
     def subcommand_class_structure(result)
       subcommand_classes.each do |k, v|
-        commands = v.subcommand_structure
+        commands       = v.subcommand_structure
         result[k.to_s] = nil
         result[k.to_s] = commands unless commands.empty?
       end

data/lib/idcf/cli/index.rb

@@ -1,3 +1,4 @@
+require 'logger'
 require 'thor'
 require 'active_support'
 require 'active_support/core_ext'
@@ -7,21 +8,29 @@ require 'idcf/cli/error/cli_error'
 require_relative './validate/custom/init'
 require_relative './gem_ext/thor/init_util'
 require_relative './extend/init'
+require 'idcf/cli/error/init'
+require 'idcf/cli/lib/util/cli_file'
+require 'idcf/cli/lib/util/cli_logger'
 
 module Idcf
   module Cli
     # Index
     class Index < Thor
-      @variables   = nil
+      @variables = nil
       # command alias [alias] => [command]
       COMMAND_MAPS = {}.freeze
 
       include Idcf::Cli::Extend::Init
 
       class << self
-        def init
+        # init
+        #
+        # @param arg [Hash] options
+        def init(arg)
           map COMMAND_MAPS
-          sub_command_regist('controller', File.dirname(__FILE__))
+          sub_command_regist('controller', File.dirname(__FILE__), arg)
+        rescue => e
+          error_exit(Idcf::Cli::Error::CliError.new(e.message))
         end
       end
 
@@ -31,14 +40,14 @@ module Idcf
       end
 
       desc 'init', 'initialize'
-      options global: true,
+      options global:  true,
               profile: 'default'
 
       def init
         configure
         update
       rescue => e
-        puts e.message
+        self.class.error_exit(e)
       end
 
       desc 'update', 'list update'
@@ -46,25 +55,26 @@ module Idcf
       def update
         do_update(options)
       rescue => e
-        puts e.message
+        self.class.error_exit(e)
       end
 
       desc 'configure', 'create configure'
-      options global: true,
+      options global:  true,
               profile: 'default'
 
       def configure
-        do_configure(options)
+        init_f = ARGV[0] == 'init'
+        do_configure(options, init_f)
       rescue => e
-        puts e.message
+        self.class.error_exit(e)
       end
 
       desc 'version', 'version string'
 
       def version
-        puts "idcfcloud version #{Idcf::Cli::VERSION}"
+        puts Idcf::Cli::Conf::Const::VERSION_STR
       rescue => e
-        puts e.message
+        self.class.error_exit(e)
       end
     end
   end

data/lib/idcf/cli/lib/convert/formatter/base.rb

@@ -11,7 +11,7 @@ module Idcf
             # @param _err_f [Boolean]
             # @return String
             def format(_data, _err_f)
-              raise Idcf::Cli::CliError, 'override'
+              raise Idcf::Cli::Error::CliError, 'override'
             end
           end
         end

data/lib/idcf/cli/lib/convert/formatter/xml_format.rb

@@ -11,7 +11,7 @@ module Idcf
           # xml formatter
           class XmlFormat < Base
             def format(data, _err_f)
-              data.to_xml
+              data.to_xml(dasherize: false)
             end
           end
         end

data/lib/idcf/cli/lib/convert/helper.rb

@@ -1,8 +1,7 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'idcf/cli/lib/util/name'
 require 'active_support/core_ext/string/inflections'
-require 'idcf/cli/lib/convert/formatter/xml_format'
-require 'idcf/cli/lib/convert/formatter/json_format'
-require 'idcf/cli/lib/convert/formatter/csv_format'
-require 'idcf/cli/lib/convert/formatter/table_format'
 
 module Idcf
   module Cli
@@ -10,6 +9,8 @@ module Idcf
       module Convert
         # format helper
         class Helper
+          FILTER_OPTION = [:json_path, :fields].freeze
+
           # data convert
           #
           # @param data [Hash]
@@ -17,9 +18,44 @@ module Idcf
           # @param f [String] format
           # @return String
           def format(data, err_f, f)
-            base_name = 'Idcf::Cli::Lib::Convert::Formatter'
-            cl = "#{base_name}::#{f.capitalize}Format"
-            cl.constantize.new.format(data, err_f)
+            cls_load("Formatter::#{f.classify}Format").new.format(data, err_f)
+          end
+
+          # is filter target
+          # @param o [Hash]
+          # @return Boolean
+          def filter_target?(o)
+            FILTER_OPTION.each do |k|
+              return true if !o[k].nil? && !o[k].empty?
+            end
+            false
+          end
+
+          # data convert
+          #
+          # @param data [Hash]
+          # @param o [Hash] format
+          # @param table_flag [Boolean]
+          # @return Hash
+          def filter(data, o, table_flag)
+            return data unless [Hash, Array].include?(data.class)
+            result = data.deep_dup
+            FILTER_OPTION.each do |k|
+              next if o[k].nil? || o[k].empty?
+              fo = {
+                table_flag: table_flag
+              }
+              result = cls_load("Filter::#{k.to_s.classify}Filter").new(fo).filter(result, o[k])
+            end
+            result
+          end
+
+          protected
+
+          def cls_load(path)
+            cls = "#{Idcf::Cli::Lib::Util::Name.namespace(self.class.to_s)}::#{path}"
+            require cls.underscore
+            cls.constantize
           end
         end
       end