dtk-client 0.9.1 → 0.10.0

data/lib/execute/cli_pure/cli_rerouter.rb

@@ -1,102 +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
-  class CLIRerouter
-
-    ROUTER_DATA = {
-      :service_module => [
-          { :regex => /service-module (?<service_module_id>[\w:\-]+) (?<method_name>stage) (?<assembly_id>[\w:\-]+) (?<instance_name>[\w:\-\.\:]+)/, :entity => 'assembly' },
-          { :regex => /service-module (?<service_module_id>[\w:\-]+) (?<method_name>deploy) (?<assembly_id>[\w:\-]+) (?<instance_name>[\w:\-\.\:]+)/ }
-        ],
-      :component_module => [
-          { :regex => /component-module (?<component_module_id>[\w:\-]+) (?<method_name>clone)/ }
-        ],
-      :service        => [
-          { :regex => /service (?<service_id>[\w:\-]+) (?<method_name>set-attribute) (?<name>[\w:\-\.\:]+) (?<value>[\w:\-\.\:]+)/ },
-          { :regex => /service (?<service_id>[\w:\-]+) (?<method_name>converge)/ },
-          { :regex => /service (?<method_name>delete-and-destroy) (?<instance_name>[\w:\-]+)/ }
-        ]
-    }
-
-    def initialize(entity_name, args)
-      @cli_string  = CLIRerouter.formulate_command_string(entity_name, args)
-      @entity_name = CLIRerouter.norm(entity_name)
-
-      ROUTER_DATA[@entity_name].each do |defintion|
-        if match = @cli_string.match(defintion[:regex])
-          @method_name = CLIRerouter.norm(match[:method_name])
-
-          # sometimes we need to override entity
-          @entity_name = defintion[:entity] if defintion[:entity]
-
-          # we need to filter out IDs
-          @entity_ids  = match.names.collect { |k| k.to_s.end_with?('_id') ? { k => match[k] } : nil }.compact
-
-          if @entity_ids.empty?
-            # match 1 is method name, there is no id
-            @args = match[2, match.size]
-          else
-            # match 1, 2 are id and method name rest are args
-            @args = match[@entity_ids.size + 2, match.size]
-          end
-
-          break
-        end
-      end
-
-      @conn = ::DTK::Client::Session.get_connection()
-      exit if validate_connection(@conn)
-    end
-
-    def run
-      new_context_params = DTK::Shell::ContextParams.new
-
-      @entity_ids.each do |value_hash|
-        key    = value_hash.keys.first
-        value  = value_hash.values.first
-        entity_name_of_param = key.gsub('_id', '')
-        new_context_params.add_context_name_to_params(entity_name_of_param, entity_name_of_param, value)
-      end
-
-      new_context_params.method_arguments = @args
-      new_context_params.pure_cli_mode    = true
-      DTK::Client::ContextRouter.routeTask(@entity_name, @method_name, new_context_params, @conn)
-    end
-
-    def self.is_candidate?(entity_name, args)
-      cli = formulate_command_string(entity_name, args)
-      if definitions = ROUTER_DATA[norm(entity_name)]
-        is_match = definitions.find { |d| cli.match(d[:regex]) }
-
-        return true if is_match
-      end
-
-      return false
-    end
-
-  private
-
-    def self.norm(string_value)
-      return string_value ? string_value.gsub('-','_').to_sym : nil
-    end
-
-    def self.formulate_command_string(entity_name, args)
-      "#{entity_name} #{args.join(' ')}".strip()
-    end
-  end
-end

data/lib/execute/command/api_call/map.rb

@@ -1,60 +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.
-#
-class DTK::Client::Execute
-  class Command::APICall
-    class Map < Hash
-      def initialize(hash={})
-        super()
-        replace(hash)
-      end
-
-      def translate(api_params={},opts={})
-        if Rest::Post.matches?(type())
-          Command::RestCall::Post.new(:path => path(),:body => translate_to_rest_body(api_params,opts))
-        else
-          raise "Type in following map is not defined not defined: #{self.inspect}"
-        end
-      end
-
-     private
-      def translate_to_rest_body(api_params,opts)
-        body().inject(Hash.new) do |h,(k,v)|
-          # if TranslationTerm.matches is false then v is a constant
-          processed_v = 
-            if TranslationTerm.matches?(v)
-              v.instance_form().translate(k,api_params,opts)
-            else 
-              v
-            end
-          h.merge(k => processed_v)
-        end
-      end
-
-      def type()
-        self[:type]
-      end
-      def path()
-        self[:path]
-      end
-      def body()
-        self[:body]
-      end
-
-    end
-  end
-end

data/lib/execute/command/api_call/service.rb

@@ -1,91 +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.
-#
-class DTK::Client::Execute
-  class Command::APICall
-    class Service < self
-      def self.object_type()
-        :service
-      end
-
-      CommandMap = {
-        :add_component => Map.new(
-          :type => Rest::Post,                             
-          :path => 'assembly/add_component',
-          :body => {
-            :assembly_id           => Required(:service),
-            :subtype               => 'instance',
-            :node_id               => Required(:node),
-            :component_template_id => Required(:component),
-            :namespace             => Required(:namespace),
-            :idempotent            => Equal::OrDefault(true),
-            :donot_update_workflow => Equal::OrDefault(false)
-          }
-        ),
-
-        :set_attribute => Map.new(
-          :type => Rest::Post,                             
-          :path => 'assembly/set_attributes',
-          :body => {
-            :assembly_id => Required(:service),
-            :pattern     => Required(:attribute_path),
-            # TODO: support FN
-            # :pattern   => FN{"#{Required(:node)}/#{Required(:component)}/#{Required(:attribute)}"
-            :value       => Required::Equal
-          }
-        ),
-
-        :link_components => Map.new(
-          :type => Rest::Post,                             
-          :path => 'assembly/add_service_link',
-          :body => {
-            :assembly_id         => Required(:service),
-            :input_component_id  => Required(:input_component),
-            :output_component_id => Required(:output_component),
-          }
-        ),
-
-        :execute_workflow  => 
-        [
-         Map.new(
-           :type => Rest::Post,                             
-           :path => 'assembly/create_task',
-           :body => {
-             :assembly_id => Required(:service),
-             :task_action => Required(:workflow_name),       
-             :task_params => Required(:workflow_params)
-            }
-         ),
-         Map.new(
-           :type => Rest::Post,                             
-           :path => 'task/execute',
-           :body => {
-             :task_id => PreviousResponse(:task_id)
-           }
-         )]
-      }
-
-      module CustomMapping
-        # example would be
-        # def self.command(params)
-        #  ...
-        # end
-      end
-      
-    end
-  end
-end

data/lib/execute/command/api_call/translation_term.rb

@@ -1,119 +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.
-#
-class DTK::Client::Execute
-  class Command::APICall
-
-    # abstract classes
-    class TranslationTerm
-      def self.matches?(obj)
-        obj.kind_of?(self) or
-        (obj.kind_of?(Class) and obj <= self)
-      end
-
-      def self.instance_form()
-        new()
-      end
-      def instance_form()
-        self
-      end
-
-      class Operation < self
-      end
-
-      class Param < self
-       private
-        def index(api_params,key)
-          api_params[key]
-        end
-
-        def index_required(api_params,key)
-          unless has_key?(api_params,key)
-            raise ErrorUsage.new("Missing key '#{key}' in params: #{api_params.inspect}")
-          end
-          index(api_params,key)
-        end
-
-        def has_key?(api_params,key)
-          api_params.has_key?(key)
-        end
-
-      end
-    end
-
-    # concrete classes
-
-    class Rest < TranslationTerm::Operation
-      class Post < self
-      end
-    end
-
-    class Required < TranslationTerm::Param
-      def initialize(input_key=nil)
-        @input = input_key
-      end
-
-      def translate(key,api_params,opts={})
-        index_required(api_params,@input||key)
-      end
-
-      class Equal < self
-      end
-    end
-
-    class Equal < TranslationTerm::Param
-      def translate(key,api_params,opts={})
-        index(api_params,key)
-      end
-
-      class Required < self
-        def translate(key,api_params,opts={})
-          index_required(api_params,key)
-        end
-      end
-       
-      def self.OrDefault(default_value)
-        OrDefault.new(default_value)
-      end
-
-      class OrDefault < self
-        def initialize(default_value)
-          @default_value = default_value
-        end
-        def translate(key,api_params,opts={})
-          has_key?(api_params,key) ? index(api_params,key) : @default_value
-        end
-      end
-    end
-
-    class PreviousResponse < TranslationTerm::Param
-      def initialize(response_key)
-        @response_key = response_key
-      end
-      def translate(key,api_params,opts={})
-        unless last_result = opts[:last_result]
-          raise ErrorUsage.new("PreviousResponse used before results computed")
-        end
-        match = nil
-        unless matching_key = [@response_key.to_s,@response_key.to_sym].find{|k|last_result.has_key?(k)}
-          raise ErrorUsage.new("Key #{@response_key} in PreviousResponse not found in last results (#{last_result.inspect})")
-        end
-        last_result[matching_key]
-      end
-    end
-  end
-end

data/lib/execute/command/api_call.rb

@@ -1,60 +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.
-#
-class DTK::Client::Execute
-  class Command
-    class APICall < self
-
-      # order matters; having these defs before requires; plus order of these requires
-      def self.Required(key)
-        Required.new(key)
-      end
-      def self.PreviousResponse(response_key)
-        PreviousResponse.new(response_key)
-      end
-      dtk_require('api_call/translation_term')
-      dtk_require('api_call/map')
-      dtk_require('api_call/service')
-
-
-       # calss block where on one or more commands that achieve the api
-      def raw_executable_commands(&block)
-        method = required(:method).to_sym
-        case required(:object_type).to_sym
-         when :service
-           Service.raw_executable_commands(method,&block)
-         else
-          raise ErrorUsage.new("The object_type '#{object_type}' is not supported")
-        end
-      end
-
-     private
-      def self.raw_executable_commands(method,&block)
-        if command_map = self::CommandMap[method]
-          array_form(command_map).each{|raw_command|block.call(raw_command)}
-        else
-          raise ErrorUsage.new("The method on '#{method}' on object type '#{object_type()}' is not supported")
-        end
-      end
-
-      def self.array_form(obj)
-        obj.kind_of?(Array) ? obj : [obj]
-      end
-
-    end
-  end
-end

data/lib/execute/command_processor/rest_call.rb

@@ -1,59 +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.
-#
-class DTK::Client::Execute; class CommandProcessor
-  class RestCall< self
-    extend ::DTK::Client::CommandBase # TODO: have a Base that is not just for commands (CommandBase)
-    
-    def self.execute(rest_command)
-      response = raw_execute(rest_command)
-      if response.ok?
-        response.data
-      else
-        raise Error.new(response,rest_command)
-      end
-    end
-
-    private
-    def self.raw_execute(rest_command)
-      if rest_command.kind_of?(Command::RestCall::Post)
-        post(rest_url(rest_command.path),rest_command.body)
-      else
-        raise ErrorUsage.new("Unexpected Rest Command type: #{rest_command.class}")
-      end      
-    end
-
-    class Error < ErrorUsage
-      def initialize(response_not_ok,rest_command)
-        error_print_form = error_print_form(response_not_ok)
-        error_msg = "Bad Rest response from call (#{rest_command.input_hash.inspect}:\n #{error_print_form}"
-        super(error_msg)
-      end
-     private
-      def error_print_form(response_not_ok)
-        ret_obj = 
-          if errors = response_not_ok['errors']
-            errors.size == 1 ? errors.first : errors
-           else
-            response_not_ok
-          end
-        ret_obj.kind_of?(String) ? ret_obj : ret_obj.inspect
-      end
-    end
-
-  end
-end; end

data/lib/execute/command_processor.rb

@@ -1,30 +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.
-#
-class DTK::Client::Execute
-  class CommandProcessor
-    dtk_require('command_processor/rest_call')
-
-    def self.execute(command)
-      if command.kind_of?(Command::RestCall)
-        RestCall.execute(command)
-      else
-        raise ErrorUsage.new("Unexpected Command type: #{command.class}")
-      end
-    end
-  end
-end

data/lib/execute/execute_context.rb

@@ -1,86 +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.
-#
-class DTK::Client::Execute
-  class ExecuteContext
-    dtk_require('execute_context/result_store')
-
-    module ClassMixin
-      def ExecuteContext(opts={},&block)
-        ExecuteContext.new(opts).execute(&block)
-      end
-    end
-
-    def initialize(opts={})
-      @print_results = opts[:print_results]
-      @proxy = Proxy.new()
-    end
-
-    def execute(&block)
-      result, command = instance_eval(&block)
-      result
-    end
-
-    def method_missing(m, *args, &block)
-      result, command = @proxy.send(m, *args, &block)
-      if @print_results
-        pp(:command => command.input_hash(),:result => result) 
-      end
-      [result, command]
-    end
-
-    # commands in the execute context
-    class Proxy
-      def initialize()
-        @result_store = ResultStore.new()
-      end
-
-      def call(object_type__method,params={})
-        object_type, method = split_object_type__method(object_type__method)
-        api_command = Command::APICall.new(:object_type => object_type, :method => method, :params => params)
-        result = nil
-        api_command.raw_executable_commands() do |raw_command|
-          last_result = @result_store.get_last_result?()
-          command = raw_command.translate(params,:last_result => last_result)
-          result = CommandProcessor.execute(command)
-          @result_store.store(result)
-        end
-        [result, api_command]
-      end
-      
-      def post_rest_call(path,body={})
-        command = Command::RestCall::Post.new(:path => path, :body => body, :last_result => @last_result)
-        result = CommandProcessor.execute(command)
-        [result, command]
-      end
-
-     private 
-      # returns [object_type, method]
-      def split_object_type__method(str)
-        DelimitersObjectTypeMethod.each do |d| 
-          if str =~ Regexp.new("(^[^#{d}]+)#{d}([^#{d}]+$)") 
-            return [$1,$2]
-          end
-        end
-        raise ErrorUsage.new("Illegal term '#{str}'")
-      end
-      
-      DelimitersObjectTypeMethod = ['\/']
-    end
-
-  end
-end