javonet-ruby-sdk 2.5.14 → 2.5.16

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/GetTypeHandler.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+"""
+The GetTypeHandler class handles retrieving types.
+"""
+
+import importlib
+import inspect
+import logging
+import os
+import sys
+from importlib import import_module
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.LoadLibraryHandler import LoadLibraryHandler
+from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
+from javonet.core.typeCache.TypeCache import TypeCache
+import traceback
+
+
+class GetTypeHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving types.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new type retrieval handler.
+        """
+        self._required_parameters_count = 1
+        self.namespace_cache = NamespaceCache()
+        self.type_cache = TypeCache()
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(self.__class__.__name__ + " parameters mismatch!")
+
+            type_to_return = self._get_type_from_payload(command)
+
+            if type_to_return is None:
+                raise Exception("Type {} not found".format(command.payload[0]))
+
+            if ((
+                    self.namespace_cache.is_namespace_cache_empty() and self.type_cache.is_type_cache_empty()) or  # both caches are empty
+                    self.namespace_cache.is_type_allowed(type_to_return) or  # namespace is allowed
+                    self.type_cache.is_type_allowed(type_to_return)  # type is allowed
+            ):
+                pass  # continue - type is allowed
+            else:
+                allowed_namespaces = ", ".join(self.namespace_cache.get_cached_namespaces())
+                allowed_types = ", ".join(self.type_cache.get_cached_types())
+                raise Exception(
+                    "Type {} not allowed. \nAllowed namespaces: {}\nAllowed types: {}".format(
+                        type_to_return.__name__, allowed_namespaces, allowed_types))
+
+            return type_to_return
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            sys_path = "\n".join(sys.path)
+            available_types = "\n".join(self.get_all_available_types())
+            new_message = str(e) + "\nLoaded directories:\n" + sys_path + "\nAvailable user types:\n" + available_types + "\n\n\n"
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in GetTypeHandler: {0}\n{1}".format(new_message, tb_str))
+
+    def _get_type_from_payload(self, command):
+        """
+        Gets a type from the command payload.
+
+        :param command: Command with type information
+        :return: Retrieved type
+        """
+        if len(command.payload) == 1:
+            type_name = command.payload[0].split(".")
+            # Handle Python 2.7 vs Python 3 module name differences
+            if type_name[0] == "builtins":
+                type_name[0] = "__builtin__"
+            
+            if len(type_name) == 1:
+                return import_module(type_name[0])
+            else:
+                return self._get_type_from_nested_payload(type_name)
+        else:
+            # Handle Python 2.7 vs Python 3 module name differences
+            payload = list(command.payload)
+            if payload[0] == "builtins":
+                payload[0] = "__builtin__"
+            
+            return self._get_type_from_nested_payload(payload)
+
+    def _get_type_from_nested_payload(self, payload):
+        module_name = ".".join(payload[:-1])
+        class_name = payload[-1]
+        loaded_module = import_module(module_name)
+        return getattr(loaded_module, class_name)
+
+    def get_all_available_types(self):
+        available_types = set()
+        for directory in LoadLibraryHandler.loaded_directories:
+            for root, _, files in os.walk(directory):
+                if "Binaries" in root:
+                    continue
+                for file in files:
+                    if file.lower().endswith(".py") and file != "__init__.py":
+                        module_name = os.path.splitext(file)[0]
+                        module_path = os.path.relpath(os.path.join(root, module_name), directory).replace(os.sep, ".")
+                        try:
+                            module = importlib.import_module(module_path)
+                            for name, obj in inspect.getmembers(module, inspect.isclass):
+                                qualified_name = "{}.{}".format(module_path, name)
+                                available_types.add(qualified_name)
+                        except Exception:
+                            pass
+        return list(available_types) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/Handler.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+"""
+The Handler class is the main handler for all commands in Javonet.
+"""
+
+from javonet.core.handler.AbstractHandler import AbstractHandler
+from javonet.core.handler.ValueHandler import ValueHandler
+from javonet.core.handler.LoadLibraryHandler import LoadLibraryHandler
+from javonet.core.handler.InvokeStaticMethodHandler import InvokeStaticMethodHandler
+from javonet.core.handler.SetStaticFieldHandler import SetStaticFieldHandler
+from javonet.core.handler.CreateClassInstanceHandler import CreateClassInstanceHandler
+from javonet.core.handler.GetStaticFieldHandler import GetStaticFieldHandler
+from javonet.core.handler.ResolveInstanceHandler import ResolveInstanceHandler
+from javonet.core.handler.GetTypeHandler import GetTypeHandler
+from javonet.core.handler.InvokeInstanceMethodHandler import InvokeInstanceMethodHandler
+from javonet.core.handler.CastingHandler import CastingHandler
+from javonet.core.handler.GetInstanceFieldHandler import GetInstanceFieldHandler
+from javonet.core.handler.SetInstanceFieldHandler import SetInstanceFieldHandler
+from javonet.core.handler.DestructReferenceHandler import DestructReferenceHandler
+from javonet.core.handler.ArrayGetItemHandler import ArrayGetItemHandler
+from javonet.core.handler.ArrayGetSizeHandler import ArrayGetSizeHandler
+from javonet.core.handler.ArrayGetRankHandler import ArrayGetRankHandler
+from javonet.core.handler.ArraySetItemHandler import ArraySetItemHandler
+from javonet.core.handler.ArrayHandler import ArrayHandler
+from javonet.core.handler.GetEnumItemHandler import GetEnumItemHandler
+from javonet.core.handler.GetEnumNameHandler import GetEnumNameHandler
+from javonet.core.handler.GetEnumValueHandler import GetEnumValueHandler
+from javonet.core.handler.EnableNamespaceHandler import EnableNamespaceHandler
+from javonet.core.handler.EnableTypeHandler import EnableTypeHandler
+from javonet.core.handler.GetStaticMethodAsDelegateHandler import GetStaticMethodAsDelegateHandler
+from javonet.core.handler.GetInstanceMethodAsDelegateHandler import GetInstanceMethodAsDelegateHandler
+from javonet.core.handler.PassDelegateHandler import PassDelegateHandler
+from javonet.core.handler.InvokeDelegateHandler import InvokeDelegateHandler
+from javonet.core.handler.InvokeGlobalFunctionHandler import InvokeGlobalFunctionHandler
+
+
+from javonet.core.handler.HandlerDictionary import handler_dict
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
+from javonet.utils.CommandType import CommandType
+from javonet.utils.Command import Command
+
+
+class Handler(AbstractHandler):
+    """
+    Handler class for processing commands.
+    """
+    def __init__(self):
+        """
+        Initialize the handler with all command handlers.
+        """
+        handler_dict[CommandType.Value] = ValueHandler()
+        handler_dict[CommandType.LoadLibrary] = LoadLibraryHandler()
+        handler_dict[CommandType.InvokeStaticMethod] = InvokeStaticMethodHandler()
+        handler_dict[CommandType.SetStaticField] = SetStaticFieldHandler()
+        handler_dict[CommandType.CreateClassInstance] = CreateClassInstanceHandler()
+        handler_dict[CommandType.GetStaticField] = GetStaticFieldHandler()
+        handler_dict[CommandType.Reference] = ResolveInstanceHandler()
+        handler_dict[CommandType.GetType] = GetTypeHandler()
+        handler_dict[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodHandler()
+        handler_dict[CommandType.Cast] = CastingHandler()
+        handler_dict[CommandType.GetInstanceField] = GetInstanceFieldHandler()
+        handler_dict[CommandType.SetInstanceField] = SetInstanceFieldHandler()
+        handler_dict[CommandType.DestructReference] = DestructReferenceHandler()
+        handler_dict[CommandType.ArrayGetItem] = ArrayGetItemHandler()
+        handler_dict[CommandType.ArrayGetSize] = ArrayGetSizeHandler()
+        handler_dict[CommandType.ArrayGetRank] = ArrayGetRankHandler()
+        handler_dict[CommandType.ArraySetItem] = ArraySetItemHandler()
+        handler_dict[CommandType.Array] = ArrayHandler()
+        handler_dict[CommandType.GetEnumItem] = GetEnumItemHandler()
+        handler_dict[CommandType.GetEnumName] = GetEnumNameHandler()
+        handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
+        handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
+        handler_dict[CommandType.EnableType] = EnableTypeHandler()
+        handler_dict[CommandType.GetStaticMethodAsDelegate] = GetStaticMethodAsDelegateHandler()
+        handler_dict[CommandType.GetInstanceMethodAsDelegate] = GetInstanceMethodAsDelegateHandler()
+        handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
+        handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
+        handler_dict[CommandType.InvokeGlobalFunction] = InvokeGlobalFunctionHandler()
+
+    def handle_command(self, command):
+        """
+        Handle a command and return a response.
+        
+        :param command: Command to handle
+        :type command: Command
+        :return: Response command
+        :rtype: Command
+        """
+        try:
+            if command.command_type == CommandType.RetrieveArray:
+                response_array = handler_dict[CommandType.Reference].handle_command(command.payload[0])
+                return Command.create_array_response(response_array, command.runtime_name)
+
+            handler = handler_dict.get(command.command_type)
+            if handler is None:
+                raise ValueError("No handler found for command type: {0}".format(command.command_type))
+                
+            response = handler.handle_command(command)
+            return self.__parse_response(response, command.runtime_name)
+        except Exception as e:
+            return ExceptionSerializer.serialize_exception(e, command)
+
+    def __parse_response(self, response, runtime_name):
+        """
+        Parse the response and create appropriate command.
+        
+        :param response: Response to parse
+        :param runtime_name: Runtime name
+        :return: Command with parsed response
+        :rtype: Command
+        """
+        if self.__is_response_simple_type(response) or self.__is_response_null(response):
+            return Command.create_response(response, runtime_name)
+        else:
+            reference_cache = ReferencesCache()
+            guid = reference_cache.cache_reference(response)
+            return Command.create_reference(guid, runtime_name)
+
+    @staticmethod
+    def __is_response_simple_type(response):
+        """
+        Check if response is a simple type.
+        
+        :param response: Response to check
+        :return: True if response is a simple type
+        :rtype: bool
+        """
+        # In Python 2.7 we have to handle unicode and long
+        return isinstance(response, (int, long, float, bool, str, unicode))
+
+    @staticmethod
+    def __is_response_null(response):
+        """
+        Check if response is None.
+        
+        :param response: Response to check
+        :return: True if response is None
+        :rtype: bool
+        """
+        return response is None
+
+    @staticmethod
+    def __is_response_array(response):
+        """
+        Check if response is an array.
+        
+        :param response: Response to check
+        :return: True if response is an array
+        :rtype: bool
+        """
+        return isinstance(response, list)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/HandlerDictionary.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""
+The HandlerDictionary class stores a dictionary of command handlers.
+"""
+
+# Global dictionary for handlers
+handler_dict = {}
+
+
+class HandlerDictionary(object):
+    """
+    Class for managing command handlers dictionary.
+    """
+
+    @staticmethod
+    def add_handler_to_dict(command_type, handler):
+        """
+        Add a handler to the dictionary.
+        
+        :param command_type: Type of command
+        :param handler: Handler for the command
+        """
+        handler_dict[command_type] = handler 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/InvokeDelegateHandler.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeDelegateHandler class handles delegate invocations.
+"""
+
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class InvokeDelegateHandler(AbstractCommandHandler):
+    """
+    Handler for invoking delegates.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new delegate invocation handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            delegates_cache = DelegatesCache()
+            method = delegates_cache.resolve_delegate(command)
+            if len(command.payload) > 1:
+                method_arguments = command.payload[1:]
+                return method(*method_arguments)
+            else:
+                return method()
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in InvokeDelegateHandler: {0}\n{1}".format(str(e), tb_str))
+
+    def handle(self, command):
+        """
+        Handles the delegate invocation command.
+
+        :param command: Command to handle
+        :return: Command with operation result
+        """
+        delegate_id = command.get_payload()[0]
+        args = command.get_payload()[1:]
+        result = Command(command.runtime_name, CommandType.Value, [])
+        result = result.add_arg_to_payload(delegate_id)
+        for arg in args:
+            result = result.add_arg_to_payload(arg)
+        return result 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/InvokeGlobalFunctionHandler.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeGlobalFunctionHandler class handles global function invocations.
+"""
+
+import importlib
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class InvokeGlobalFunctionHandler(AbstractCommandHandler):
+    """
+    Handler for invoking global functions.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new global function invocation handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeGlobalFunction Parameters mismatch! "
+                                "Expected at least a fully qualified function name (module.function).")
+
+            # The first payload parameter must be the fully qualified function name,
+            # e.g. "my_module.my_function".
+            full_function_name = command.payload[0]
+            if '.' not in full_function_name:
+                raise Exception("Invalid function name format. "
+                                "Expected a fully qualified name like 'module_name.function_name'.")
+
+            module_name, function_name = full_function_name.rsplit('.', 1)
+
+            try:
+                module = importlib.import_module(module_name)
+            except ImportError as e:
+                raise ImportError("Could not import module '{}'.".format(module_name))
+
+            try:
+                function = getattr(module, function_name)
+            except AttributeError as e:
+                available = [attr for attr in dir(module) if callable(getattr(module, attr))]
+                message = ("Function '{}' not found in module '{}'. "
+                           "Available functions:\n".format(function_name, module_name) + "\n".join(available))
+                raise AttributeError(message)
+
+            if not callable(function):
+                raise Exception("Attribute '{}' in module '{}' is not callable.".format(function_name, module_name))
+
+            function_args = command.payload[1:]
+            return function(*function_args)
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in InvokeGlobalFunctionHandler: {0}\n{1}".format(str(e), tb_str))
+
+    def handle(self, command):
+        """
+        Handles the global function invocation command.
+
+        :param command: Command to handle
+        :return: Command with operation result
+        """
+        function_name = command.get_payload()[0]
+        args = command.get_payload()[1:]
+        result = Command(command.runtime_name, CommandType.Value, [])
+        result = result.add_arg_to_payload(function_name)
+        for arg in args:
+            result = result.add_arg_to_payload(arg)
+        return result 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/InvokeInstanceMethodHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeInstanceMethodHandler class handles instance method invocations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class InvokeInstanceMethodHandler(AbstractCommandHandler):
+    """
+    Handler for invoking instance methods.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance method invocation handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeInstanceMethod Parameters mismatch!")
+
+            class_instance = command.payload[0]
+            try:
+                method = getattr(class_instance, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(class_instance) if callable(getattr(class_instance, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], class_instance.__class__.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+            
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
+                return method(*method_arguments)
+            return method()
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in InvokeInstanceMethodHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/InvokeStaticMethodHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeStaticMethodHandler class handles static method invocations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class InvokeStaticMethodHandler(AbstractCommandHandler):
+    """
+    Handler for invoking static methods.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new static method invocation handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeStaticMethod Parameters mismatch!")
+
+            clazz = command.payload[0]
+            try:
+                method = getattr(clazz, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(clazz) if callable(getattr(clazz, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], clazz.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+            
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
+                return method(*method_arguments)
+            return method()
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in InvokeStaticMethodHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/LoadLibraryHandler.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+"""
+The LoadLibraryHandler class handles library loading.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import os
+import traceback
+
+
+class LoadLibraryHandler(AbstractCommandHandler):
+    """
+    Handler for loading libraries.
+    """
+
+    # Class variable to store loaded directories
+    loaded_directories = []
+
+    def __init__(self):
+        """
+        Initializes a new library loading handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the LoadLibrary command.
+        
+        :param command: Command to process
+        :return: 0 on success
+        :raises: Exception if parameters mismatch or directory is invalid
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("LoadLibrary payload parameters mismatch")
+
+            # Check if path is a directory and add to sys.path
+            if os.path.isdir(command.payload[0]):
+                sys.path.append(command.payload[0])
+                LoadLibraryHandler.loaded_directories.append(command.payload[0])
+            else:
+                raise Exception(command.payload[0] + " is not a valid directory")
+
+            return 0
+            
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error loading library: {0}\n{1}".format(str(e), tb_str))
+
+    @staticmethod
+    def get_loaded_directories():
+        """
+        Get list of loaded directories.
+        
+        :return: List of loaded directory paths
+        """
+        return LoadLibraryHandler.loaded_directories

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/PassDelegateHandler.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+The PassDelegateHandler class handles delegate passing.
+"""
+
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class PassDelegateHandler(AbstractCommandHandler):
+    """
+    Handler for passing delegates.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new delegate passing handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            # TO BE IMPLEMENTED
+            return None
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in PassDelegateHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/ResolveInstanceHandler.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+import sys
+import traceback
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+
+
+class ResolveInstanceHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the ResolveInstance command.
+        
+        :param command: Command to process
+        :type command: Command
+        :return: Resolved instance
+        :raises: Exception if parameters mismatch or reference resolution fails
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            references_cache = ReferencesCache()
+            return references_cache.resolve_reference(command)
+            
+        except Exception as e:
+            # W Python 2.7 nie ma with_traceback i from None
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error resolving instance: {0}\n{1}".format(str(e), tb_str))