cloudrail_si 0.1.5

data/lib/cloudrail_si/servicecode/Interpreter.rb

@@ -0,0 +1,213 @@
+require 'json'
+
+require_relative '../Helpers/helper'
+require_relative '../servicecode/VarAddress'
+
+require_relative './commands/AwaitCodeRedirect'
+require_relative './commands/CallFunc'
+require_relative './commands/Break'
+require_relative './commands/Clone'
+require_relative './commands/Concat'
+require_relative './commands/Conditional'
+require_relative './commands/Create'
+require_relative './commands/Delete'
+require_relative './commands/Get'
+require_relative './commands/GetMimeType'
+require_relative './commands/JumpRel'
+require_relative './commands/Pull'
+require_relative './commands/Push'
+require_relative './commands/Return'
+require_relative './commands/Set'
+require_relative './commands/Size'
+require_relative './commands/ThrowError'
+require_relative './commands/array/Uint8ToBase64'
+require_relative './commands/debug/Out'
+require_relative './commands/hash/Sha1'
+require_relative './commands/hash/Md5'
+require_relative './commands/json/Parse'
+require_relative './commands/json/Stringify'
+require_relative './commands/http/RequestCall'
+require_relative './commands/math/Floor'
+require_relative './commands/math/MathCombine'
+require_relative './commands/object/GetKeyArray'
+require_relative './commands/object/GetKeyValueArrays'
+require_relative './commands/string/Base64Encode'
+require_relative './commands/string/Format'
+require_relative './commands/string/IndexOf'
+require_relative './commands/string/LastIndexOf'
+require_relative './commands/string/Split'
+require_relative './commands/string/StringTransform'
+require_relative './commands/string/Substr'
+require_relative './commands/string/Substring'
+require_relative './commands/stream/StreamToString'
+require_relative './commands/stream/StringToStream'
+require_relative './commands/stream/MakeJoinedStream'
+require_relative './commands/stream/MakeLimitedStream'
+
+module CloudRailSi
+    module ServiceCode
+        class Interpreter
+            attr_reader :sandbox
+
+            def initialize(sandbox)
+                @sandbox = sandbox
+
+                @COMMAND_LIST = [
+                    CallFunc.new,
+                    Break.new,
+                    Clone.new,
+                    Create.new,
+                    Delete.new,
+                    Get.new,
+                    JumpRel.new,
+                    Pull.new,
+                    Push.new,
+                    Return.new,
+                    Set.new,
+                    Size.new,
+                    Uint8ToBase64.new,
+                    Sha1.new,
+                    Md5.new,
+                    Base64Encode.new,
+                    StreamToString.new,
+                    StringToStream.new,
+                    MakeJoinedStream.new,
+                    MakeLimitedStream.new,
+                    RequestCall.new,
+                    Out.new,
+                    AwaitCodeRedirect.new,
+                    GetMimeType.new,
+                    Conditional.new('if==than', lambda { |c| (c == 0) }, false),
+                    Conditional.new('if>=than', lambda { |c| (c >= 0) }, true),
+                    Conditional.new('if>than', lambda { |c| (c > 0) }, true),
+                    Conditional.new('if<=than', lambda { |c| (c <= 0) }, true),
+                    Conditional.new('if<than', lambda { |c| (c < 0) }, true),
+                    Conditional.new('if!=than', lambda { |c| (c != 0) }, false),
+                    ThrowError.new,
+                    Parse.new,
+                    Stringify.new,
+                    MathCombine.new('math.add', lambda { |elems| elems.reduce(0, :+) }),
+                    MathCombine.new('math.multiply', lambda { |elems| elems.reduce(1, :*) }),
+                    MathCombine.new('math.max', lambda { |elems | elems.max }),
+                    MathCombine.new('math.min', lambda{ |elems | elems | elems.min }),
+                    Floor.new,
+                    GetKeyArray.new,
+                    GetKeyValueArrays.new,
+                    Concat.new,
+                    Format.new,
+                    IndexOf.new,
+                    LastIndexOf.new,
+                    Split.new,
+                    Substr.new,
+                    Substring.new,
+                    StringTransform.new('string.lowerCase', lambda { |str| str.downcase }),
+                    StringTransform.new('string.upperCase', lambda { |str| str.upcase }),
+                    StringTransform.new('string.urlEncode', lambda { |str| URI::encode_www_form_component(str) }),
+                    StringTransform.new('string.urlDecode', lambda { |str| URI::decode_www_form_component(str, Encoding::UTF_8) })
+                ]
+                @COMMANDS = {}
+                @COMMAND_LIST.each { |command|
+                    @COMMANDS[command.get_identifier()] = command
+                }
+            end
+
+            def call_function(function_name, *parameters)
+                @sandbox.create_new_stack_level(function_name, 0)
+                Helper.add_all(@sandbox.current_parameters(), parameters)
+                if (@sandbox.current_function_code().nil?)
+                    error_message = "Service code error: function #{function_name} not found"
+                    raise Errors::InternalError.new(error_message)
+                end
+                return run_sync() # this was an async run
+            end
+
+            def call_function_sync(function_name, *parameters)
+                @sandbox.create_new_stack_level(function_name, 0)
+                Helper.add_all(@sandbox.current_parameters(), parameters)
+                if (@sandbox.current_function_code().nil?)
+                    error_message = "Service code error: function #{function_name} not found"
+                    raise Errors::InternalError.new(error_message)
+                end
+                return run_sync()
+            end
+
+            def run
+                raise Errors::InternalError.new('interpreter.run not supported.')
+            end
+
+            def run_sync
+                begin
+                    while (@sandbox.current_service_code_line() < @sandbox.current_function_code().length && @sandbox.current_service_code_line() >= 0)
+                        command = @sandbox.current_function_code()[@sandbox.current_service_code_line()]
+                        Helper.log "\n\n\n#{command}"
+                        if (@COMMANDS[command[0]].nil?)
+                            raise Errors::InternalError.new("Unknown command: #{command[0]}")
+                        end
+                        command_parameters = Interpreter.decode_command_parameters(command)
+                        @COMMANDS[command[0]].execute(@sandbox, command_parameters)
+                        return if !@sandbox.thrown_error.nil?
+                        @sandbox.increment_current_service_code_line(1)
+                        while ((@sandbox.current_service_code_line() >= @sandbox.current_function_code().length ||
+                            @sandbox.current_service_code_line() < 0) && @sandbox.code_function_name_stack.length > 1)
+                            @sandbox.return_from_function()
+                        end
+                    end
+
+                rescue => e
+                    raise e if (e.class.name == CloudRailSi::Errors::UserError)
+                    error_message = 'Service code error in function ' + @sandbox.current_function_name() + ' at line ' + @sandbox.current_service_code_line().to_s + ' with message: ' + e.message
+                    raise CloudRailSi::Errors::InternalError.new(error_message)
+                end
+            end
+
+            def self.decode_command_parameters(command)
+                command_parameters = command.clone[1..-1] # first param was function name
+                (0..command_parameters.length).each do |i|
+                    if (Helper.is_string(command_parameters[i]))
+                        if (command_parameters[i].index('$') === 0)
+                            command_parameters[i] = VarAddress.new(command_parameters[i][1..-1])
+                        elsif (command_parameters[i].index('\\$') === 0)
+                            command_parameters[i] = command_parameters[i][1..-1]
+                        end
+                    end
+                end
+                return command_parameters
+            end
+
+            def get_parameter(idx)
+                @sandbox.get_parameter(idx, 0)
+            end
+
+            def save_as_string
+                @sandbox.peristent_storage.to_json
+            end
+
+            def load_as_string(saved_state)
+                @sandbox.persistent_storage = JSON.parse(saved_state)
+            end
+
+            def resume_function(function_name, *parameters)
+                if (@sandbox.parameters_stack.length === 0)
+                    first_parameters = []
+                    @sandbox.parameters_stack.push(first_parameters)
+                else
+                    first_parameters = @sandbox.parameters_stack[0]
+                end
+                (0..parameters.length).each do |i|
+                    if (Helper.is_object(parameters[i]))
+                        m = parameters[i]
+                        Helper.clear(m)
+                        Helper.put_all(m, first_parameters[i])
+                    else
+                        if (i >= first_parameters.length)
+                            first_parameters.push(parameters[i])
+                        else
+                            first_parameters[i] = parameters[i]
+                        end
+                    end
+                end
+                return run_sync()
+            end
+        end
+    end
+end

data/lib/cloudrail_si/servicecode/Sandbox.rb

@@ -0,0 +1,361 @@
+require_relative './Interpreter'
+require_relative '../errors/InternalError'
+require_relative '../helpers/Helper'
+
+module CloudRailSi
+    module ServiceCode
+        class Sandbox
+            attr_reader :thrown_error
+            attr_reader :code_function_name_stack
+            attr_reader :local_variables_stack
+            attr_reader :instance_dependency_storage
+            attr_reader :code_line_stack
+
+            def is_sandbox
+                true
+            end
+
+            def initialize(service_code, persistent_storage, instance_dependency_storage)
+                @local_variables_stack = []
+                @parameters_stack = []
+                @code_function_name_stack = []
+                @code_line_stack = []
+                @persistent_storage = []
+                @service_code = service_code
+                @persistent_storage = persistent_storage
+                @instance_dependency_storage = instance_dependency_storage
+                @LIST_MAX_ADD_JUMP_ALLOWED = 32
+                @thrown_error = nil
+            end
+
+            def set_thrown_error(thrown_error)
+                Helper.debug
+                @thrown_error = thrown_error
+            end
+
+            def create_new_stack_level(function_name, code_line)
+                @local_variables_stack.push([])
+                @parameters_stack.push([])
+                @code_function_name_stack.push(function_name)
+                @code_line_stack.push(code_line)
+            end
+
+            def current_parameters
+                return nil if (@parameters_stack.length === 0)
+                @parameters_stack[-1]
+            end
+
+            def current_function_name
+                return nil if (@code_function_name_stack.length === 0)
+                @code_function_name_stack[-1]
+            end
+
+            def current_function_code
+                @service_code[current_function_name()]
+            end
+
+            def current_service_code_line
+                return -1 if (@code_line_stack.length === 0)
+                return @code_line_stack[-1]
+            end
+
+            def increment_current_service_code_line(amount)
+                @code_line_stack[-1] += amount if @code_line_stack.length
+            end
+            def return_from_function
+                return if (@code_function_name_stack.length <= 1)
+
+                call_function_command_parameters = Interpreter.decode_command_parameters(@service_code[@code_function_name_stack[-2]][@code_line_stack[-2]])
+
+                (0..call_function_command_parameters.length - 1).each do |i|
+                    parameter_var = call_function_command_parameters[i]
+                    if Helper.is_var_address(parameter_var)
+                        value = @parameters_stack[-1][i - 1]
+                        set_variable(parameter_var, value, -2)
+                    end
+                end
+                @code_function_name_stack.pop()
+                @code_line_stack.pop()
+                @local_variables_stack.pop()
+                @parameters_stack.pop()
+                increment_current_service_code_line(1)
+            end
+            def set_variable(var_address, value, stacklevel=-1)
+                if Helper.is_var_address(var_address)
+                    var_address_parts = decode_variable_address(var_address)
+                else
+                    var_address_parts = var_address
+                end
+
+                variables = get_stack_for_address_part(var_address_parts[0], stacklevel)
+                var_idx = var_address_parts[1]
+                if (var_address_parts.length <= 2)
+                    if (variables.length == var_idx)
+                        variables.push(value)
+                    elsif (variables.length > var_idx)
+                        variables[var_idx] = value
+                    elsif (variables.length + @LIST_MAX_ADD_JUMP_ALLOWED > var_idx)
+                        (0..var_idx - variables.length + 1).each do |i|
+                            variables.push(nil)
+                        end
+                        variables[var_idx] = value
+                    else
+                        raise Errors::InternalError.new("Could not decode variable #{var_address_parts.join(':')}")
+                    end
+                    return true
+                end
+
+                return set_entry(variables[var_idx], var_address_parts[2..-1], value)
+            end
+
+            def get_variable(var_address, stacklevel=-1, empty_is_null=false)
+                if Helper.is_var_address(var_address)
+                    var_address_parts = decode_variable_address(var_address)
+                else
+                    var_address_parts = var_address
+                end
+                variables = get_stack_for_address_part(var_address_parts[0], stacklevel)
+
+                return nil if (empty_is_null && var_address_parts[1] >= variables.length)
+
+                local_entry = variables[var_address_parts[1]]
+                return local_entry if (var_address_parts.length <= 2)
+                get_entry(local_entry, var_address_parts[2..-1], empty_is_null)
+            end
+
+            def delete_variable(var_address_parts, stacklevel=-1)
+                variables = get_stack_for_address_part(var_address_parts[0], stacklevel)
+                var_idx = var_address_parts[1]
+                if (var_address_parts.length <= 2)
+                    variables[var_idx] = nil if (var_idx < variables.length)
+                    return true
+                end
+                delete_entry(variables[var_idx], var_address_parts[2..-1])
+            end
+            def get_stack_for_address_part(part, stacklevel)
+                if (part == 'L')
+                    variables = @local_variables_stack[stacklevel]
+                elsif (part == 'P')
+                    variables = @parameters_stack[stacklevel]
+                elsif (part == 'S')
+                    variables = @persistent_storage
+                else
+                    raise Errors::InternalError.new("Could not attribute variable part #{part}")
+                end
+                return variables
+            end
+
+            def decode_variable_address(var_address)
+                dec_adr = []
+                adr = var_address.instance_variable_get(:@address_string)
+                Helper.assert(adr[0] != '$')
+                if (adr[0] < '0' || adr[0] > '9')
+                    dec_adr.push(adr[0])
+                    adr = adr[1..-1]
+                end
+                adr_parts = adr.split('.')
+                (0..adr_parts.length - 1).each do |i|
+                    part = adr_parts[i]
+                    if (Helper.is_number_string(part))
+                        dec_adr.push(Integer(part))
+                    else
+                        dec_adr.push(part)
+                    end
+                end
+                return dec_adr
+            end
+
+            def set_entry(container, var_address, value)
+                if (var_address.length > 1)
+                    next_container = get_entry(container, var_address[0..-2], false)
+
+                    return set_entry(next_container, var_address[1..-1], value)
+                end
+                var_address_part = var_address[0]
+
+                if (Helper.is_array(container))
+                    if (Helper.is_number_string(var_address_part))
+                        var_address_part = Integer(var_address_part)
+                    end
+                    if (!Helper.is_number(var_address_part) || var_address_part >= container.length)
+                        raise Errors::InternalError.new('Invalid index while indexing into an array')
+                    end
+                    idx = var_address_part
+                    list = container
+                    if (list.length + @LIST_MAX_ADD_JUMP_ALLOWED <= idx)
+                        (idx - list.length + 1).times do |i|
+                            list.push(nil)
+                        end
+                    end
+                    list[idx] = value
+                elsif (Helper.is_object(container))
+                    if (!Helper.is_string(var_address_part))
+                        var_address_part = var_address_part.to_s
+                    end
+
+                    #There are three ways to interpret an address; we try them all
+                    begin
+                        container.instance_variable_set('@' + var_address_part, value)
+                    rescue
+                    end
+                    begin
+                        container.send(Helper.to_snake_case(var_address_part) + "=", value)
+                    rescue
+                    end
+                    begin
+                        container[var_address_part] = value
+                    rescue
+                    end
+            elsif Helper.is_sandbox(container)
+                    if (!Helper.is_string(var_address_part))
+                        var_address_part = var_address_part.to_s
+                    end
+                    container.set(var_address_part, value)
+                end
+                return false
+            end
+            def get_entry(container, var_address, empty_is_null)
+                entry = ''
+                var_address_part = var_address[0]
+                if (Helper.is_array(container) || Helper.is_string(container))
+                    if (Helper.is_number_string(var_address_part))
+                        var_address_part = Integer(var_address_part)
+                    end
+                    if (!Helper.is_number(var_address_part))
+                        var_address_part = 0 #TODO: for paypal, transactions is missing if the count is zero; this "fixes" it but might break other things.
+#                        raise Errors::InternalError.new('Invalid index while indexing into an array or string')
+                    end
+                    if (!(empty_is_null && var_address_part >= container.length))
+                        entry = container[var_address_part]
+                    end
+                elsif (Helper.is_object(container))
+                    if (!Helper.is_string(var_address_part))
+                        var_address_part = var_address_part.to_s
+                    end
+                    if (container.nil? && (!empty_is_null))
+                        entry = {}
+                    else
+                        begin
+                            entry = container.instance_variable_get('@' + var_address_part) # will fail if var_address_part starts with a number; set to nil if doesn't exist
+                        rescue
+                        end
+                        if !entry
+                            begin
+                                entry = container[var_address_part]
+                            rescue
+                                begin
+                                    entry = container.send(Helper.to_snake_case(var_address_part))
+                                rescue
+                                    entry = {}
+                                    Helper.debug
+                                end
+                            end
+                        end
+                    end
+                elsif Helper.is_sandbox(container)
+                    if (!Helper.is_string(var_address_part))
+                        var_address_part = var_address_part.to_s
+                    end
+                    entry = container.get(var_address_part)
+                end
+                if (var_address.length > 1)
+                    return get_entry(   entry, var_address[1..-1], empty_is_null)
+                end
+                return entry
+            end
+            def delete_entry(container, var_address)
+                if (var_address.length > 1)
+                    next_container = get_entry(container, var_address, false)
+                    return delete_entry(next_container, var_address[1..-1])
+                end
+                var_address_part = var_address[0]
+                if (Helper.is_array(container))
+                    if (Helper.is_number_string(var_address_part))
+                        var_address_part = Integer(var_address_part)
+                    end
+                    if (!Helper.is_number(var_address_part) || var_address_part >= container.length)
+                        raise Errors::InternalError.new('Invalid index while indexing into an array')
+                    end
+                    idx = var_address_part
+                    list = container
+                    if (idx < list.length)
+                        list.delete_at(idx)
+                    end
+                    while (list.length && list[-1].nil?)
+                        list.pop()
+                    end
+                elsif (Helper.is_object(container))
+                    var_address_part = var_address_part.to_s
+                    container.delete(var_address_part)
+                elsif Helper.is_sandbox(container)
+                    var_address_part = var_address_part.to_s
+                    container.set(var_address_part, nil)
+                end
+                return false
+            end
+            def call_function(function_name, parameters)
+                create_new_stack_level(function_name, -1)
+                parameter_stack = current_parameters()
+                Helper.add_all(parameter_stack, parameters)
+            end
+            def compare_variables(a_obj, b_obj, command_id, type_check)
+                a_obj = Helper.resolve(self, a_obj, false)
+                b_obj = Helper.resolve(self, b_obj, false)
+                if (!type_check && (a_obj.nil? || b_obj.nil?))
+                    return 0 if (a_obj.nil? && b_obj.nil?)
+                    return -1
+                end
+
+                if ((a_obj.is_a? Numeric) && (b_obj.is_a? Numeric))
+                    # doesn't matter if one is int and other is float
+                elsif (a_obj.class != b_obj.class)
+                    Helper.debug
+                    return -1 if !type_check
+                    raise Errors::InternalError.new("Command #{command_id} compares arguments of different types")
+                end
+
+                return Helper.compare(a_obj, b_obj)
+            end
+            def save_state_to_string
+                savelist = []
+                savelist.push(@code_function_name_stack)
+                savelist.push(@code_line_stack)
+                savelist.push(@local_variables_stack)
+                savelist.push(@parameters_stack)
+                savelist.push(@persistent_storage)
+                as_json = savelist.to_json
+                # TODO: Add support for objects such as CustomDate
+
+                return as_json
+            end
+            def load_state_from_string(saved_state)
+                savelist = JSON.parse(saved_state)
+
+                # TODO: Add support for objects such as CustomDate
+                @code_function_name_stack = savelist[0]
+                @code_line_stack = savelist[1]
+                @local_variables_stack = savelist[2]
+                merge_stacks = lambda { |json_stack, stack|
+                    (json_stack.length).times do |i|
+                        if (i >= stack.length)
+                            stack.push(json_stack[i])
+                        else
+                            stack[i] = json_stack[i]
+                        end
+                    end
+                }
+                json_parameters_stack = savelist[3]
+                json_persistent_storage = savelist[4]
+                merge_stacks(json_parameters_stack, @parameters_stack)
+                merge_stacks(json_persistent_storage, @persistent_storage)
+            end
+            def get_parameter(idx, stacklevel)
+                return nil if (@parameters_stack.length === 0 || stacklevel >= @parameters_stack.length || idx >= @parameters_stack[stacklevel].length)
+                @parameters_stack[stacklevel][idx]
+            end
+            def get_params_stack
+                @parameters_stack
+            end
+        end
+    end
+end