dtk-shell 0.10.0

data/lib/execute/command/api_call/map.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.
+#
+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

@@ -0,0 +1,91 @@
+#
+# 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

@@ -0,0 +1,119 @@
+#
+# 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/rest_call.rb

@@ -0,0 +1,37 @@
+#
+# 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 RestCall < self
+      # TODO: allow calls like 'converge' which is a macro; we either directly support or have a sub class of RestCall called macro
+      attr_reader :path
+      def initialize(hash)
+        super
+        @path = required(:path)
+      end
+
+      class Post < self
+        attr_reader :body
+        def initialize(hash)
+          super
+          @body = optional?(:body)||{}
+        end
+      end
+    end
+  end
+end

data/lib/execute/command_processor.rb

@@ -0,0 +1,30 @@
+#
+# 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/command_processor/rest_call.rb

@@ -0,0 +1,59 @@
+#
+# 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/error_usage.rb

@@ -0,0 +1,21 @@
+#
+# 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 ErrorUsage < ::DTK::Client::Error
+  end
+end

data/lib/execute/execute_context.rb

@@ -0,0 +1,86 @@
+#
+# 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