dtk-client 0.9.1 → 0.10.0

data/lib/cli/context/type.rb

@@ -0,0 +1,42 @@
+#
+# 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::Client
+  class CLI::Context
+    module Type
+      require_relative('type/top')
+      require_relative('type/module')
+      require_relative('type/service')
+
+      # This function can have the side of updating base_dsl_file_obj
+      def self.create_context!(base_dsl_file_obj)
+        if path = base_dsl_file_obj.path?
+          case base_dsl_file_obj.file_type.type
+          when :common_module 
+            Module.new(base_dsl_file_obj)
+          when :service_instance  
+            Service.new(base_dsl_file_obj)
+          else 
+            raise Error, "Unexpected file_type '#{file_type.type}'"
+          end
+        else
+          Top.new(base_dsl_file_obj)
+        end
+      end
+    end
+  end
+end

data/lib/cli/context.rb

@@ -0,0 +1,174 @@
+#
+# 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::Client
+  module CLI
+    # Object that provides the context for interpreting commands
+    class Context
+      require_relative('context/type')
+      require_relative('context/attributes')
+
+      def self.determine_context
+#testing stub
+#dir_path = File.expand_path('../../examples/spark', File.dirname(__FILE__))
+#base_dsl_file_obj = base_dsl_file_obj(:dir_path => dir_path)
+        base_dsl_file_obj = base_dsl_file_obj()
+        Type.create_context!(base_dsl_file_obj)
+      end
+
+      def initialize(base_dsl_file_obj)
+        @base_dsl_file_obj   = base_dsl_file_obj
+        @command_processor   = Processor.default
+        @context_attributes  = Attributes.new(self)
+        add_command_defs_defaults_and_hooks!
+      end
+      private :initialize
+
+      def run_and_return_response_object(argv)
+        @flag = true if argv.include?('-d')
+        @command_processor.run_and_return_response_object(argv)
+      end
+      
+      def method_missing(method, *args, &body)
+        command_processor_object_methods.include?(method) ? @command_processor.send(method, *args, &body) : super
+      end
+      
+      def respond_to?(method)
+        command_processor_object_methods.include?(method) or super
+      end
+
+      def value_from_base_dsl_file?(key)
+        case key
+        when :module_ref 
+          module_ref_from_base_dsl_file?
+        when :service_instance 
+          service_instance_from_base_dsl_file?
+        end
+      end
+
+      private
+
+      attr_reader :context_attributes, :base_dsl_file_obj
+
+      def module_ref_from_base_dsl_file?
+        parsed_module = base_dsl_file_obj.parse_content(:common_module_summary)
+        namespace   = parsed_module.val(:Namespace)
+        module_name = parsed_module.val(:ModuleName)
+        version     = parsed_module.val(:ModuleVersion) || 'master'
+        if namespace and module_name
+          client_dir_path = base_dsl_file_obj.parent_dir?
+          ModuleRef.new(:namespace => namespace, :module_name => module_name, :version => version, :client_dir_path => client_dir_path)
+        end
+      end
+
+      def service_instance_from_base_dsl_file?
+        #raise_error_when_missing_context(:service_instance) unless base_dsl_file_obj.file_type == DTK::DSL::FileType::ServiceInstance
+        base_dsl_file_obj.file_type == DTK::DSL::FileType::ServiceInstance
+        base_dsl_file_obj.parse_content(:service_module_summary).val(:Name)
+      end
+
+      # opts can have keys
+      #   :dir_path
+      def set_base_dsl_file_obj!(opts = {})
+        opts[:flag] = @flag
+        @base_dsl_file_obj = self.class.base_dsl_file_obj(opts)
+      end
+
+      # opts can have keys
+      #   :dir_path
+      def  self.base_dsl_file_obj(opts = {}) 
+        opts[:flag] = false if opts[:flag].nil?
+        DirectoryParser.matching_file_obj?(FILE_TYPES, opts)
+      end
+      FILE_TYPES = 
+        [
+         ::DTK::DSL::FileType::CommonModule,
+         ::DTK::DSL::FileType::ServiceInstance
+        ]
+
+      def module_ref_in_options_or_context(options)
+        module_ref_in_options_or_context?(options) || raise_error_when_missing_context(:module_ref, options)
+      end
+
+      def module_ref_in_options_or_context?(options)
+        if options[:module_ref]
+          opts = {:namespace_module_name => options[:module_ref]}
+          opts.merge!(:version => options[:version]) if options[:version]
+          ModuleRef.new(opts)
+        else
+          if module_dir_path = options[:directory_path]
+            set_base_dsl_file_obj!(:dir_path => module_dir_path)
+          end
+          context_attributes[:module_ref]
+        end
+      end
+
+      def service_instance_in_options_or_context(options)
+        service_instance_in_options_or_context?(options) || raise_error_when_missing_context(:service_instance, options)
+      end
+      
+      def service_instance_in_options_or_context?(options)
+        if ret = options[:service_instance]
+          ret
+        else
+          if module_dir_path = options[:directory_path]
+            set_base_dsl_file_obj!(:dir_path => module_dir_path)
+          end
+          context_attributes[:service_instance]
+        end
+      end
+
+
+      ERROR_MSG_MAPPING = {
+        :service_instance => 'service instance',
+        :module_ref       => 'mdoule'
+      }
+      def raise_error_when_missing_context(type, options = {})
+        if options["d"].nil?
+          @base_dsl_file_obj.raise_error_if_no_content
+        else
+          @base_dsl_file_obj.raise_error_if_no_content_flag(type)
+        end
+        # TODO: not sure if below can be reached
+        error_msg = 
+          if options[:directory_path]
+            "Bad #{ERROR_MSG_MAPPING[type]} directory path '#{options[:directory_path]}'"
+          else
+            "This command must be executed from within a #{ERROR_MSG_MAPPING[type]} directory or a directory path must be given using option '#{option_ref(:directory_path)}'"
+          end
+        raise Error::Usage, error_msg
+      end
+
+      # Methods related to adding cli command definitions 
+      def add_command_defs!
+        raise Error::NoMethodForConcreteClass.new(self.class)
+      end
+
+      def add_command_defs_defaults_and_hooks!
+        add_command_defaults!
+        add_command_defs!
+        add_command_hooks!
+        self
+      end
+
+      def command_processor_object_methods
+        @@command_processor_object_methods ||= Processor::Methods.all 
+      end
+
+    end
+  end
+end

data/lib/cli/directory_parser/file_system.rb

@@ -0,0 +1,105 @@
+#
+# 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::Client; module CLI
+  class DirectoryParser
+    # For Finding relevant content when files in a vanilla file system
+    class FileSystem < self 
+      # file_types - a single or array of FileObj objects
+      # opts can have keys
+      #   :file_path - string
+      #   :dir_path - string
+      # Returns FileObj object or nil that match a file_type
+      def matching_file_obj?(file_types, opts = {})
+        ret = nil
+        file_types = [file_types] unless file_types.kind_of?(Array)
+
+        file_type, file_path = matching_type_and_path?(file_types, opts)
+        file_obj_opts = {
+          dir_path: opts[:dir_path],
+          current_dir: OsUtil.current_dir,
+          content: get_content?(file_path)
+        }
+        FileObj.new(file_type, file_path, file_obj_opts)
+      end
+      
+      private
+
+      def get_content?(file_path)
+        File.open(file_path).read if file_path and File.exists?(file_path)
+      end
+
+      # This method finds the base dsl file if it exists and returns its path
+      # opts can have keys:
+      #  :dir_path
+      #  :file_path
+      # returns nil or [file_type, path]
+      def matching_type_and_path?(file_types, opts = {})
+        ret = nil
+        flag = opts[:flag]
+        if path = opts[:file_path]
+          file_types.each do | file_type |
+            if file_type.matches?(path)
+              return [file_type, path]
+            end
+          end
+        else
+          file_types.each do | file_type |
+            path_info = file_type.create_path_info
+            if path = most_nested_matching_file_path?(path_info, flag, :current_dir => opts[:dir_path])
+              return [file_type, path]
+            end
+          end
+        end
+        ret
+      end
+
+      # return either a string file path or of match to path_info working from current directory and 'otwards'
+      # until base_path in path_info (if it exists)
+      # opts can have keys
+      #  :current_dir if set means start from this dir; otherwise start from computed current dir
+      def most_nested_matching_file_path?(path_info, flag, opts = {})
+        base_dir = path_info.base_dir || OsUtil.home_dir
+        current_dir = opts[:current_dir] || OsUtil.current_dir
+        check_match_recurse_on_failure?(path_info, current_dir, base_dir, flag)
+      end
+
+      def check_match_recurse_on_failure?(path_info, current_dir, base_dir, flag)
+        match = matching_file_paths(current_dir, path_info)
+        if match.empty?
+          unless current_dir == base_dir
+            if parent_path = OsUtil.parent_dir?(current_dir)
+              check_match_recurse_on_failure?(path_info, parent_path, base_dir, flag) unless flag
+            end
+          end
+        elsif match.size == 1
+          match.first
+        else
+          raise Error, "Unexpected that more than one match: #{match.join(', ')}"
+        end
+      end
+
+      # returns an array of strings that are file paths
+      def matching_file_paths(dir_path, path_info)
+        Dir.glob("#{dir_path}/*").select { |file_path| File.file?(file_path) and path_info.matches?(file_path) }
+      end
+    end
+  end
+end; end
+
+

data/lib/{execute/command.rb → cli/directory_parser.rb}

@@ -15,26 +15,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class DTK::Client::Execute
-  class Command
-    dtk_require('command/rest_call')
-    dtk_require('command/api_call')
 
-    attr_reader :result_var,:input_hash
-    def initialize(input_hash)
-      @input_hash = input_hash
-      @result_var = optional?(:result_var)
+module DTK::Client::CLI
+  class DirectoryParser < ::DTK::DSL::DirectoryParser
+    require_relative('directory_parser/file_system')
+    # file_types - a single or array of FileObj objects
+    # opts can have keys
+    #   :file_path - string
+    #   :dir_path - string
+    # Returns FileObj that matches a file_typeo bject that matches a file_type in file_types
+    #   or returns nil if no match found
+    def self.matching_file_obj?(file_types, opts = {})
+      adapter.matching_file_obj?(file_types, opts)
     end
 
-   private
-    def required(key)
-      unless @input_hash.has_key?(key)
-        raise ErrorUsage.new("Missing required key '#{key}' in: #{@input_hash.inspect}")
-      end
-      @input_hash[key]
-    end
-    def optional?(key)
-      @input_hash[key]
+    def self.adapter
+      @adapter ||= FileSystem.new
     end
   end
 end
+

data/lib/{execute.rb → cli/file_obj.rb}

@@ -15,15 +15,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-module DTK::Client
-  class Execute
-    # The order matters
-    dtk_require('execute/error_usage')
-    dtk_require('execute/command')
-    dtk_require('execute/command_processor')
-    dtk_require('execute/execute_context')
-    dtk_require('execute/script')
 
-    extend ExecuteContext::ClassMixin
+module DTK::Client
+  module CLI
+    class FileObj < ::DTK::DSL::FileObj
+      def parent_dir
+        parent_dir? || raise(Error, "Unexpected that 'file_obj.path?' is nil")
+      end
+      
+      def parent_dir?
+        if path = path?
+          OsUtil.parent_dir(path)
+        end
+      end
+    end
   end
 end

data/lib/cli/processor/plugin/gli.rb

@@ -0,0 +1,70 @@
+#
+# 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 'gli'
+module DTK::Client; module CLI
+  class Processor
+    module Plugin
+      class Gli
+        include ::GLI::App
+
+        def initialize
+          @response_obj = nil
+        end
+        
+        def run_and_return_response_object(argv)
+          run(argv)
+          @response_obj
+        end
+        
+        # add_command_hooks! works in conjunction with run
+        def add_command_hooks!
+          around do |_global_options, _command, _options, _arguments, code|
+            # It is expected that last line in code block returns response
+            @response_obj = code.call
+          end
+
+          on_error do |err|
+            if err.kind_of?(::GLI::BadCommandLine) or err.kind_of?(::GLI::UnknownCommand)
+              true # so gli mechanism processes it
+            elsif err.kind_of?(Error::ServerNotOkResponse)
+              @response_obj = err.response
+              nil
+            elsif err.kind_of?(Error)
+              raise err
+            else
+              raise Error::Client.new(err.message, :backtrace => err.backtrace)
+            end
+          end
+        end
+
+        def add_command_defaults!
+          program_desc 'DTK CLI tool'
+          version VERSION
+          subcommand_option_handling :normal
+          arguments :strict
+        end
+      end
+    end
+  end
+end; end
+# monkey patch so that [global options] does not appear in help menu
+class GLI::Commands::HelpModules::FullSynopsisFormatter 
+  def global_flags_and_switches
+    {}
+  end
+end

data/lib/cli/processor.rb

@@ -0,0 +1,60 @@
+#
+# 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::Client
+  module CLI
+    # Delegation module for wrapping third party library used to do parsing
+    class Processor
+      module Plugin
+        DEFAULT = :gli
+        DEFAULT_CLASS_NAME = "#{DEFAULT.to_s.capitalize}"
+        # autoload DEFAULT_CLASS_NAME.to_sym, "plugin/#{DEFAULT_PLUGIN}"
+        require_relative("processor/plugin/#{DEFAULT}")
+        def self.default_class
+          const_get DEFAULT_CLASS_NAME
+        end
+      end
+      
+      module Methods
+        def self.all
+          [:arg_name, :command, :default_value, :desc, :flag, :switch, :add_command_defaults!, :add_command_hooks!, :run_and_return_response_object]
+        end
+      end
+      
+      def self.default
+        new(Plugin.default_class)
+      end
+      
+      def initialize(plugin_class)
+        @plugin = plugin_class.new
+      end
+      private :initialize
+
+      def method_missing(method, *args, &body)
+        Methods.all.include?(method) ? @plugin.send(method, *args, &body) : super
+      end
+      
+      def respond_to?(method)
+        Methods.all.include?(method) or super
+      end
+    end
+  end
+end
+
+  
+
+

data/lib/cli/runner/dtkn_access.rb

@@ -0,0 +1,75 @@
+#
+# 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::Client; module CLI
+  class Runner
+    module DTKNAccess
+      include ::DTK::Client
+      # check if .add_direct_access file exists, if not then add direct access and create .add_direct_access file
+      def self.resolve_direct_access(config_existed)
+        params = Configurator.check_direct_access
+        return if params[:username_exists]
+        
+        OsUtil.print_info('Processing ...') if config_existed
+        # check to see if catalog credentials are set
+        conn = Session.get_connection
+        response = conn.post 'account/check_catalog_credentials'
+        
+        # set catalog credentails
+        if response.ok? && !response.data(:catalog_credentials_set)
+          # setting up catalog credentials
+          catalog_creds = Configurator.ask_catalog_credentials
+          unless catalog_creds.empty?
+            post_body = {
+              :username => catalog_creds[:username], 
+              :password => catalog_creds[:password], 
+              :validate => true
+            }
+            response = conn.post 'account/set_catalog_credentials', post_body 
+            unless response.ok?
+              error_message = response.error_message.gsub(/\.[ ]*$/,'')
+              OsUtil.print_error("#{error_message}. You will have to set catalog credentials manually ('dtk account set-catalog-credentials').")
+            end
+          end
+        end
+        add_key_opts = {
+          :first_registration => true, 
+          :name => "#{Session.connection_username}-client"
+        }
+        response = Operation::Account.add_key(params[:ssh_key_path], add_key_opts)
+        matched_pub_key = response.data(:matched_pub_key)
+        matched_username = response.data(:matched_username)
+        
+        if !response.ok?
+          error_message = response.error_message.gsub(/\.[ ]*$/,'')
+          OsUtil.print_warning("We were not able to add access for current user. #{error_message}. In order to properly use dtk-shell you will have to add access manually ('dtk account add-ssh-key').\n")
+        elsif matched_pub_key
+          # message will be displayed by add key # TODO: Refactor this flow
+          OsUtil.print_warning("Provided SSH PUB key has already been added.")
+          Configurator.add_current_user_to_direct_access
+        elsif matched_username
+          OsUtil.print_warning("User with provided name already exists.")
+        else
+          # commented out because 'add_key' method called above will also print the same message
+          # OsUtil.print_info("Your SSH PUB key has been successfully added.")
+          Configurator.add_current_user_to_direct_access
+        end
+        response
+      end
+    end
+  end
+end; end

data/lib/cli/runner.rb

@@ -0,0 +1,58 @@
+#
+# 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::Client
+  module CLI
+    # Top-level entry class for dtk CLI executable
+    class Runner
+      require_relative('runner/dtkn_access')
+      
+      def self.run(argv)
+        Error.top_level_trap_error do
+          Configurator.check_git
+          Configurator.create_missing_client_dirs
+          
+          # checks if config exists and if not prompts user with questions to create a config
+          config_existed = Configurator.check_config_exists
+          
+          raise_error_if_invalid_connection
+          
+          # check if .add_direct_access file exists, if not then add direct access and create .add_direct_access file
+          DTKNAccess.resolve_direct_access(config_existed)
+
+          context =  Context.determine_context
+          if response_obj = context.run_and_return_response_object(argv)
+            # render_response will raise Error in case of error response
+            render_response(response_obj)
+          end
+        end
+      end
+      
+      private
+      
+      def self.raise_error_if_invalid_connection
+        connection = Session.get_connection
+        raise Error::InvalidConnection.new(connection) if connection.connection_error?
+      end
+
+      def self.render_response(response_obj)
+        Response::ErrorHandler.raise_if_error(response_obj)
+        response_obj.render_data
+      end
+    end
+  end
+end

data/lib/cli/version.rb

@@ -0,0 +1,8 @@
+module DTK
+  module Client
+    module CLI
+      VERSION = '0.10.0'
+    end
+  end
+end
+

data/lib/client/config/default.conf

@@ -0,0 +1,20 @@
+development_mode=false
+debug_grit=false
+meta_table_ttl=7200000     	# time to live (ms)
+meta_constants_ttl=7200000     	# time to live (ms)
+meta_pretty_print_ttl=7200000   # time to live (ms)
+task_check_frequency=60     	# check frequency for task status threads (seconds)
+tail_log_frequency=2      	# assembly - frequency between requests (seconds)
+debug_task_frequency=5     	# assembly - frequency between requests (seconds)
+auto_commit_changes=false       # autocommit for modules
+verbose_rest_calls=false        # logging of REST calls
+
+service_instance_location=service
+module_location=component-modules
+service_location=service-modules
+assembly_module_base_location=assemblies
+backups_location=backups
+
+server_port=80
+secure_connection=true
+secure_connection_server_port=443